Use a specialized new tab page in TOUCH_UI builds

chrome/browser/resources/touch_ntp/eventtracker.js

+// Copyright (c) 2011 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 EventTracker is a simple class that manages the addition and
+ *  removal of DOM event listeners.  In particular, it keeps track of all
+ *  listeners that have been added and makes it easy to remove some or all of
+ *  them without requiring all the information again.  This is particularly
+ *  handy when the listener is a generated function such as a lambda or the
+ *  result of calling Function.bind.  The goal of this class is to make it
+ *  easier to avoid memory leaks caused by DOM<->JS cycles - removing event
+ *  listeners breakes the DOM->JS part of the cycle.
+ */
+'use strict';

[arv (Not doing code reviews), 2011/03/15 23:53:43]

Please do not use 'use strict' at the top level. It will break code that is in
other files

[Rick Byers, 2011/03/16 22:06:02]

Oh, because we concatenate all the files together when embedding as a resource,
right?  Ok - that's no problem for all my classes (which define a single global
each).  For standalone_hack.js I don't need to worry because we don't embed it. 
I'll see what I can come up with for newtabpage.js - I was feeling a little bad
about polluting the global namespace there anyway.

Has anyone ever looked into changing how we embed HTML resources to embed each
script file as a separate resource?  That would have the additional benefit of
avoiding duplication for all the shared JS files (which I assume are being
embedded into MANY different resources).

[arv (Not doing code reviews), 2011/03/16 22:55:05]

Yup
We have a way to do this already using chrome://resources/ URLs

+
+/**
+ *  Create an EventTracker to track a set of events.
+ *  EventTracker instances are typically tied 1:1 with other objects or
+ *  DOM elements whose listeners should be removed when the object is disposed
+ *  or the corresponding elements are removed from the DOM.
+ *  @constructor
+ */
+function EventTracker() {
+  /**
+   *  @type {Array.<EventTracker.Entry>}
+   *  @private
+   */
+  this.listeners_ = [];
+}
+
+/**
+ * The type of the internal tracking entry.
+ *  @typedef {{node: !Node,
+ *            eventType: string,
+ *            listener: Function,
+ *            capture: boolean}}
+ */
+EventTracker.Entry;
+
+EventTracker.prototype = {
+  /**
+   * Add an event listener - replacement for Node.addEventListener.
+   * @param {!Node} node The DOM node to add a listener to.
+   * @param {string} eventType The type of event to subscribe to.
+   * @param {Function} listener The listener to add.
+   * @param {boolean} capture Whether to invoke during the capture phase.
+   */
+  add: function(node, eventType, listener, capture) {
+    var h = {
+      node: node,
+      eventType: eventType,
+      listener: listener,
+      capture: capture
+    };
+    this.listeners_.push(h);
+    node.addEventListener(eventType, listener, capture);
+  },
+
+  /**
+   * Remove any specified event listeners added with this EventTracker.
+   * @param {!Node} node The DOM node to remove a listener from.
+   * @param {string} eventType The type of event to remove.
+   */
+  remove: function(node, eventType) {
+    this.listeners_ = this.listeners_.filter(function(h) {
+      if (h.node == node && h.eventType == eventType) {
+        EventTracker.removeEventListener_(h);
+        return false;
+      }
+      return true;
+    });
+  },
+
+  /**
+   * Remove all event listeners added with this EventTracker.
+   */
+  removeAll: function() {
+    this.listeners_.forEach(EventTracker.removeEventListener_);
+    this.listeners_ = [];
+  }
+};
+
+/**
+ * Remove a single event listener given it's tracker entry.  It's up to the
+ * caller to ensure the entry is removed from listeners_.
+ * @param {EventTracker.Entry} h The entry describing the listener to remove.
+ * @private
+ */
+EventTracker.removeEventListener_ = function(h)
+{
+  h.node.removeEventListener(h.eventType, h.listener, h.capture);
+};
+