Depending on whether there is any listener, registers or unregisters the browser storage event.
488597
function () {
            if (!this.storage) {
                return;
            }
            var listeners = !!this._listeners;
            var registeredBrowserEvent = !!this._browserEventCb;

            if (listeners !== registeredBrowserEvent) {
                if (listeners) {
                    this._browserEventCb = {
                        fn : this._browserEvent,
                        scope : this
                    };
                    // listen to events raised by instances in a different window but the same storage location
                    ariaUtilsEvent.addListener(Aria.$window, "storage", this._browserEventCb);
                } else {
                    ariaUtilsEvent.removeListener(Aria.$window, "storage", this._browserEventCb);
                    this._browserEventCb = null;
                }
            }

        }
656097
function unregister() {
    if (!applicationCurrent) {
        return;
    }
    applicationCurrent.stop();

    EVENTS.forEach(function (event) {
        process.removeListener(event, currentHandlers[event]);
    });

    applicationCurrent = null;
    currentHandlers = {};
}
505309
public static void unregisterListener(Context context, PlaybackListener listener) {
        LocalBroadcastManager.getInstance(context.getApplicationContext())
                .unregisterReceiver(listener);
    }
645728
function (inst) {
	    var key = getDictionaryKey(inst);
	    for (var registrationName in listenerBank) {
	      if (!listenerBank.hasOwnProperty(registrationName)) {
	        continue;
	      }

	      if (!listenerBank[registrationName][key]) {
	        continue;
	      }

	      var PluginModule = EventPluginRegistry.registrationNameModules[registrationName];
	      if (PluginModule && PluginModule.willDeleteListener) {
	        PluginModule.willDeleteListener(inst, registrationName);
	      }

	      delete listenerBank[registrationName][key];
	    }
	  }
849044
def remove_listener(self, event_name, listener):
        """"""
        self.listeners[event_name].remove(listener)
        return self
918477
def remove_listener(registry, listener):
    
    if listener is not None and listener in registry:
        registry.remove(listener)
        return True

    return False
1333500
private void registerListeners() {
    protocol.registerAppendHandler(this::append);
    protocol.registerBackupHandler(this::backup);
    protocol.registerConsumeHandler(this::consume);
    protocol.registerResetConsumer(this::reset, threadContext);
  }
121164
function (name, method) {
        this.map.events.unregister(name, this, method);   
        this.map.events.unregister(name, this, this.setEvent);
    }
295130
public void onShutdown() {
        for (String listenerName : registeredFileListeners.keySet()) {
            logger.info("Deregistering File Listener: " + listenerName);
            FileListener listener = registeredFileListeners.get(listenerName);
            listener.stopListening();
        }
    }
275046
public void unregister(EventObserver<?> observer){
        for (Map.Entry<Class, Set<EventObserver>> entry : observers.entrySet()) {
            entry.getValue().remove(observer);
        }

    }
310887
function () {
            if (this._storage) {
                this._removeOldCache();
                this._storage.setItem(this._storageKey, this._cache);
                this._storage.$dispose();
                this._storage = null;
            }
            ariaUtilsEvent.removeListener(Aria.$window, "unload", this._saveCacheCB);
        }
756460
public void unregisterListener(IPluginEventListener listener) {
        if (pluginEventListeners2 != null && pluginEventListeners2.contains(listener)) {
            pluginEventListeners2.remove(listener);
            listener.onPluginEvent(new PluginEvent(this, PluginAction.UNSUBSCRIBE));
        }
    }
1159611
def unlisten(self, event, callback):
        
        try:
            self.listeners[event].remove(callback)
        except ValueError:
            return False
        else:
            return True
1324720
def unregister_listener(self, address, func):
        
        listeners = self.address_listeners[address]
        if listeners is None:
            return False

        if func in listeners:
            listeners.remove(func)
            return True

        return False
582119
function(name, callback, context) {
    if (eventsApi(this, 'stopReplying', name)) {
      return this;
    }

    // Remove everything if there are no arguments passed
    if (!name && !callback && !context) {
      delete this._requests;
    } else if (!removeHandlers(this._requests, name, callback, context)) {
      Radio.debugLog('Attempted to remove the unregistered request', name, this.channelName);
    }

    return this;
  }
1365999
function releaseMemoryObserver() {
  // Only disable on last use.
  if (!memoryObservationCount) {
    return;
  }
  --memoryObservationCount;
  if (memoryObservationCount) {
    return;
  }

  // Unlisten for events.
  Services.obs.removeObserver(
      handleMemoryEvent, 'garbage-collection-statistics', false);

  // Reset memory notification to its original state.
  resetTemporaryPreference('javascript.options.mem.notify');
}
242621
function() {
        if (!this.touch) {
            this.touch = true;
            var events = [
                "mousedown", "mouseup", "mousemove", "click", "dblclick",
                "mouseout"
            ];
            for (var i=0, len=events.length; i<len; i++) {
                if (this[events[i]]) {
                    this.unregister(events[i], this[events[i]]); 
                }
            } 
        }
    }