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 351 matching lines @@
       /** @param {function(*=):void} listener */
       function(listener){
         if (listener) {
           listener(opt_details);
         }
     });
   }
 };
 
 /**
+  * An light weight object that helps managing the lifetime of an event

[Jamie, 2015/02/02 23:46:19]

s/An/A/
s/light weight/lightweight/
s/managing/manage/
s/event/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 () {

[Jamie, 2015/02/02 23:46:20]

No space before ()--even for comments :)

[kelvinp, 2015/02/03 01:42:01]

Done.

+  *   this.eventHooks_.dispose();
+  *   this.eventHooks_ = null;
+  * }
+  *
+  * @param {base.EventSource | HTMLElement} src
+  * @param {string} eventName
+  * @param {Function} listener

[kelvinp, 2015/02/02 23:08:34]

Function is the JavaScript official type name of function.  It is used in flavor
of function(?) here as it doesn't place restrictions on the number/type of
arguments, and the return type.

+  * @param {boolean=} opt_capture
+  *
+  * @constructor
+  * @implements {base.Disposable}
+  */
+base.EventHook = function(src, eventName, listener, opt_capture) {
+  this.src_ = src;
+  this.eventName_ = eventName;
+  this.listener_ = listener;
+  this.capture_ = opt_capture;
+  base.debug.assert(
+      (typeof opt_capture === 'boolean') === (src instanceof HTMLElement),
+      'opt_capture is only valid for DOM Events.');

[Jamie, 2015/02/02 23:46:19]

I think this would be better guarded against by separate EventHook and
DomEventHook classes. The fact that the two types of event use the same names
for the un/hook functions shouldn't translate to using the same wrapper
functions. If they both implemented the same interface, then that would be
another matter...

+  src.addEventListener(eventName, listener, opt_capture);
+};
+
+base.EventHook.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;
   }
-}
+};