base.EventHook

remoting/webapp/base/js/base.js

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 /**
  * @fileoverview
  * A module that contains basic utility components and methods for the
  * chromoting project
  *
  */
@@ skipping 44 matching lines @@
   return callstack.join('\n');
 };
 
 /**
   * @interface
   */
 base.Disposable = function() {};
 base.Disposable.prototype.dispose = function() {};
 
 /**
+ * @constructor
+ * @param {...base.Disposable} var_args
+ * @implements {base.Disposable}
+ */
+base.Disposables = function(var_args) {
+  /**
+   * @type {Array.<base.Disposable>}
+   * @private
+   */
+  this.disposables_ = Array.prototype.slice.call(arguments, 0);
+};
+
+base.Disposables.prototype.dispose = function() {
+  for (var i = 0; i < this.disposables_.length; i++) {
+    this.disposables_[i].dispose();
+  }
+};
+
+/**
  * A utility function to invoke |obj|.dispose without a null check on |obj|.
  * @param {base.Disposable} obj
  */
 base.dispose = function(obj) {
   if (obj) {
     base.debug.assert(typeof obj.dispose == 'function');
     obj.dispose();
   }
 };
 
@@ skipping 34 matching lines @@
     function(key) {
       return dict[key];
     });
 };
 
 /**
  * @param {*} value
  * @return {*} a recursive copy of |value| or null if |value| is not copyable
  *   (e.g. undefined, NaN).
  */
-base.deepCopy = function (value) {
+base.deepCopy = function(value) {
   try {
     return JSON.parse(JSON.stringify(value));
   } catch (e) {}
   return null;
 };
 
 /**
  * @type {boolean|undefined}
  * @private
  */
@@ skipping 295 matching lines @@
     listeners.forEach(
       /** @param {function(*=):void} listener */
       function(listener){
         if (listener) {
           listener(opt_details);
         }
     });
   }
 };
 
+
+/**
+  * A lightweight object that helps manage the lifetime of an event listener.
+  *
+  * For example, do the following if you want to automatically unhook events
+  * when your object is disposed:
+  *
+  * var MyConstructor = function(domElement) {
+  *   this.eventHooks_ = new base.Disposables(
+  *     new base.EventHook(domElement, 'click', this.onClick_.bind(this)),
+  *     new base.EventHook(domElement, 'keydown', this.onClick_.bind(this)),
+  *     new base.ChromeEventHook(chrome.runtime.onMessage,
+  *                              this.onMessage_.bind(this))
+  *   );
+  * }
+  *
+  * MyConstructor.prototype.dispose = function() {
+  *   this.eventHooks_.dispose();
+  *   this.eventHooks_ = null;
+  * }
+  *
+  * @param {base.EventSource} src
+  * @param {string} eventName
+  * @param {function(...?)} listener
+  *
+  * @constructor
+  * @implements {base.Disposable}
+  */
+base.EventHook = function(src, eventName, listener) {
+  this.src_ = src;
+  this.eventName_ = eventName;
+  this.listener_ = listener;
+  src.addEventListener(eventName, listener);
+};
+
+base.EventHook.prototype.dispose = function() {
+  this.src_.removeEventListener(this.eventName_, this.listener_);
+};
+
+/**
+  * An event hook implementation for DOM Events.
+  *
+  * @param {HTMLElement} src
+  * @param {string} eventName
+  * @param {function(...?)} listener
+  * @param {boolean} capture
+  *
+  * @constructor
+  * @implements {base.Disposable}
+  */
+base.DomEventHook = function(src, eventName, listener, capture) {
+  this.src_ = src;
+  this.eventName_ = eventName;
+  this.listener_ = listener;
+  this.capture_ = capture;
+  src.addEventListener(eventName, listener, capture);
+};
+
+base.DomEventHook.prototype.dispose = function() {
+  this.src_.removeEventListener(this.eventName_, this.listener_, this.capture_);
+};
+
+
+/**
+  * An event hook implementation for Chrome Events.
+  *
+  * @param {chrome.Event} src
+  * @param {function(...?)} listener
+  *
+  * @constructor
+  * @implements {base.Disposable}
+  */
+base.ChromeEventHook = function(src, listener) {
+  this.src_ = src;
+  this.listener_ = listener;
+  src.addListener(listener);
+};
+
+base.ChromeEventHook.prototype.dispose = function() {
+  this.src_.removeListener(this.listener_);
+};
+
+
 /**
   * Converts UTF-8 string to ArrayBuffer.
   *
   * @param {string} string
   * @return {ArrayBuffer}
   */
 base.encodeUtf8 = function(string) {
   var utf8String = unescape(encodeURIComponent(string));
   var result = new Uint8Array(utf8String.length);
   for (var i = 0; i < utf8String.length; i++)
     result[i] = utf8String.charCodeAt(i);
   return result.buffer;
-}
+};
 
 /**
   * Decodes UTF-8 string from ArrayBuffer.
   *
   * @param {ArrayBuffer} buffer
   * @return {string}
   */
 base.decodeUtf8 = function(buffer) {
   return decodeURIComponent(
       escape(String.fromCharCode.apply(null, new Uint8Array(buffer))));
-}
+};
 
 /**
  * Generate a nonce, to be used as an xsrf protection token.
  *
  * @return {string} A URL-Safe Base64-encoded 128-bit random value. */
 base.generateXsrfToken = function() {
   var random = new Uint8Array(16);
   window.crypto.getRandomValues(random);
   var base64Token = window.btoa(String.fromCharCode.apply(null, random));
   return base64Token.replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
 };
 
 /**
  * @param {string} jsonString A JSON-encoded string.
  * @return {Object|undefined} The decoded object, or undefined if the string
  *     cannot be parsed.
  */
 base.jsonParseSafe = function(jsonString) {
   try {
     return /** @type {Object} */ (JSON.parse(jsonString));
   } catch (err) {
     return undefined;
   }
-}
+};