Use a specialized new tab page in TOUCH_UI builds

chrome/browser/resources/touch_ntp/eventtracker.js

Index: chrome/browser/resources/touch_ntp/eventtracker.js
diff --git a/chrome/browser/resources/touch_ntp/eventtracker.js b/chrome/browser/resources/touch_ntp/eventtracker.js
new file mode 100644
index 0000000000000000000000000000000000000000..8c3142793bcd29c59ae2ec6f5cd21bbe6aa672f1
--- /dev/null
+++ b/chrome/browser/resources/touch_ntp/eventtracker.js
@@ -0,0 +1,95 @@
+// 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

[arv (Not doing code reviews), 2011/03/10 19:25:59]

@fileoverview EventTracker ...

[Rick Byers, 2011/03/11 02:44:33]

Done.

+ *  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.
+ */
+
+/** @constructor
+ *  Create an EventTracker to track a set of events.

[arv (Not doing code reviews), 2011/03/10 19:25:59]

/**
 * Description
 * @constructor
 */

[Rick Byers, 2011/03/11 02:44:33]

Done.

+ *  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.
+ */
+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;
+
+/**
+ * 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.
+ */
+EventTracker.prototype.add = function(node, eventType, listener, capture)

[arv (Not doing code reviews), 2011/03/10 19:25:59]

Use the following syntax instead:

EventTracker.prototype = {
  add: function(...) {
    ...
  },
  ...

};

The more verbose syntax you are currently using is not necessary for modern JS
engines.

[Rick Byers, 2011/03/11 02:44:33]

I like it, thanks! Done.  Does it not matter that this style omits the
'constructor' property that would otherwise exist?

Note that gjslint isn't smart enough to detect the type of 'this' using this
style, so since I don't want to loose good linting, I've added @this
annotations.  Kind of defeats the simplification though.  Do you think this is
still worth it?  Let me know and I'll convert all my other classes to this style
too.

Maybe we need a Chrome JavaScript style guide for rules like this (that
presumably can't go in the Google JavaScript style guide due to older browsers)?

What is your preference for how to write static methods (like the one below)?

[arv (Not doing code reviews), 2011/03/11 20:08:46]

No. constructor is not reliable anyway.

function A() {}
A.prototype = {...};
var a = new A;
a.constructor === Object;

but

function A() {}
var a = new A;
a.constructor === A;
We can fix gjslint :-)
Yeah
ClassName.staticMethodName = function() { ... };

+{

[arv (Not doing code reviews), 2011/03/10 19:25:59]

{ before new line

[Rick Byers, 2011/03/11 02:44:33]

Done.

+  var h = {node: node,

[arv (Not doing code reviews), 2011/03/10 19:25:59]

var h = {
  eventType: ...
  ...
};

[Rick Byers, 2011/03/11 02:44:33]

Done.

+           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.
+ */
+EventTracker.prototype.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.
+ */
+EventTracker.prototype.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

[Rick Byers, 2011/03/11 02:44:33]

Note that this is a static method (doesn't access any instance members).  I'm
following the Google style guide here, does it look OK?

[arv (Not doing code reviews), 2011/03/11 20:08:46]

Yes, looks perfect

+ */
+EventTracker.removeEventListener_ = function(h)
+{
+  h.node.removeEventListener(h.eventType, h.listener, h.capture);
+};
+
+

[arv (Not doing code reviews), 2011/03/10 19:25:59]

remove empty lines

[Rick Byers, 2011/03/11 02:44:33]

Done.

+
+
+