Drops capabilities that we shouldn't send over the wire.

Used for capabilities which aren't BeanToJson-convertable, and are only used by the local
launcher.
340437
private static Capabilities dropCapabilities(Capabilities capabilities) {
    if (capabilities == null) {
      return new ImmutableCapabilities();
    }

    MutableCapabilities caps;

    if (isLegacy(capabilities)) {
      final Set<String> toRemove = Sets.newHashSet(BINARY, PROFILE);
      caps = new MutableCapabilities(
          Maps.filterKeys(capabilities.asMap(), key -> !toRemove.contains(key)));
    } else {
      caps = new MutableCapabilities(capabilities);
    }

    // Ensure that the proxy is in a state fit to be sent to the extension
    Proxy proxy = Proxy.extractFrom(capabilities);
    if (proxy != null) {
      caps.setCapability(PROXY, proxy);
    }

    return caps;
  }
1253504
function() {
        jQuery(dropZone).removeClass('enabled');
        dropZone.removeEventListener('dragover', dragOver, false);
        dropZone.removeEventListener('drop', dragDrop, false);
      }
277753
public void setRemoveUnusedVariables(Reach reach) {
    switch (reach) {
      case ALL:
        this.removeUnusedVars = true;
        this.removeUnusedLocalVars = true;
        break;
      case LOCAL_ONLY:
        this.removeUnusedVars = false;
        this.removeUnusedLocalVars = true;
        break;
      case NONE:
        this.removeUnusedVars = false;
        this.removeUnusedLocalVars = false;
        break;
      default:
        throw new IllegalStateException("unexpected");
    }
  }
199873
def drop
      begin
        session.with(read: :primary).command(drop: name)
      rescue Moped::Errors::OperationFailure => e
        raise e unless e.ns_not_found?
        false
      end
    end
1125763
void destroy() {
        for (DistributedObjectFuture future : proxies.values()) {
            if (!future.isSetAndInitialized()) {
                continue;
            }

            DistributedObject distributedObject = extractDistributedObject(future);
            invalidate(distributedObject);
        }
        proxies.clear();
    }
1332337
def unhook_drop(self):
        
        widget = self.widget
        widget.setAcceptDrops(False)
        del widget.dragEnterEvent
        del widget.dragMoveEvent
        del widget.dragLeaveEvent
        del widget.dropEvent
435300
def drop(self):
        
        if self.restriction:
            raise DataJointError('A relation with an applied restriction condition cannot be dropped.'
                                 ' Call drop() on the unrestricted Table.')
        self.connection.dependencies.load()
        do_drop = True
        tables = [table for table in self.connection.dependencies.descendants(self.full_table_name)
                  if not table.isdigit()]
        if config['safemode']:
            for table in tables:
                print(table, '(%d tuples)' % len(FreeTable(self.connection, table)))
            do_drop = user_choice("Proceed?", default='no') == 'yes'
        if do_drop:
            for table in reversed(tables):
                FreeTable(self.connection, table).drop_quick()
            print('Tables dropped.  Restart kernel.')
953112
public boolean isDropEnabled() {

        if (m_dropEnabled != null) {
            return m_dropEnabled.booleanValue();
        }
        CmsTree<?> tree = getTree();
        if (tree == null) {
            return false;
        }
        return tree.isDropEnabled();
    }
720052
public void free()
    {
        m_converter = null;
        for (int i = this.getComponentCount() - 1; i >= 0; i--)
        {
            JComponent component = (JComponent)this.getComponent(i);
            if (component instanceof Freeable)
                ((Freeable)component).free();
        }
    }
277442
def drop_privileges():
    
    uid = int(pwd.getpwnam(settings.DROPLET_USER).pw_uid)
    os.setuid(uid)
220043
def revert_wire(options = {})
      response = JSON.parse(@client.patch("items/#{send(:id)}/revert_wire", options).body)
      @attributes = response['items']
      true
    end
349952
List<File> removeUnreadable() {
		// List unreadable
		List<InventoryEntry> unreadable = configs.values()
				.stream()
				.filter(v->!v.getConfiguration().isPresent())
				.collect(Collectors.toList());
		// Remove from inventory
		unreadable.forEach(v->configs.remove(v.getIdentifier()));
		// Return the list of removed files
		return unreadable.stream()
				.map(v->v.getPath())
				.collect(Collectors.toList());
	}
550177
protected synchronized void dropClient(ClientImpl clientToDrop) {
        Client currentClient = this.client.get();
        if (currentClient != null && currentClient == clientToDrop) {
            try {
                currentClient.close();
                this.client.set(null);
            }
            catch (Exception x) {
                // ignore
            }
        }
        this.users = 0;
    }
1035175
public <T> void destroy() {
        final Set<Entry<Bean<?>, Object>> beanSet = beanReferences.entrySet();
        final Iterator<Entry<Bean<?>, Object>> i = beanSet.iterator();
        Bean<?> bean;
        while (i.hasNext()) {
            bean = i.next().getKey();
            final T instance = (T) beanReferences.get(bean);

            destroyReference((Bean<T>) bean, instance);
        }

        beanReferences.clear();
    }
467388
public static void drop(HttpExchange req) throws IOException {
		setStandardHeaders(req);
		req.sendResponseHeaders(418, 0);
		try (OutputStream body = req.getResponseBody()) {
			body.write(("apdu4j/"+SCTool.getVersion()).getBytes(StandardCharsets.UTF_8));
		}
	}
598330
function reject(r) {
    var capability = newPromiseCapability(this);
    capability.reject.call(undefined, r);
    return capability.promise;
  }
371258
function () {
				delete nucleus.props;
				delete nucleus.needs;
				delete nucleus.providers;
				delete nucleus.listeners;
				while (q.length) {
					q.pop();
				}
				nucleus = props = needs = providers = listeners =
					q = q.pending = q.next = q.args = 0;
			}