sync: Add UI code for per type debug counters

chrome/browser/resources/sync_internals/types.js

Index: chrome/browser/resources/sync_internals/types.js
diff --git a/chrome/browser/resources/sync_internals/types.js b/chrome/browser/resources/sync_internals/types.js
new file mode 100644
index 0000000000000000000000000000000000000000..c9a21a44cbc96068fe592c15acb27aa15fa5da95
--- /dev/null
+++ b/chrome/browser/resources/sync_internals/types.js
@@ -0,0 +1,92 @@
+// 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.
+
+cr.define('chrome.sync.types', function() {
+  var typeCountersMap = {};
+
+  /**
+   * Redraws the counters table taking advantage of the most recent
+   * available information.
+   *
+   * Makes use of typeCountersMap, which is defined in the containing scope.
+   */
+  var refreshTypeCountersDisplay = function() {
+    var typeCountersArray = [];
+
+    // Transform our map into an array to make jstemplate happy.
+    Object.keys(typeCountersMap).sort().forEach(function(t) {
+      typeCountersArray.push({
+        type: t,
+        counters: typeCountersMap[t],
+      });
+    });
+
+    jstProcess(
+        new JsEvalContext({ rows: typeCountersArray }),
+        $('type-counters-table'));
+  };
+
+  /**
+   * Helps to initialize the table by picking up where initTypeCounters() left
+   * off.  That function registers this listener and requests that this event
+   * be emitted.
+   *
+   * @param {!Object} e An event containing the list of known sync types.
+   */
+  var onReceivedListOfTypes = function(e) {
+    var types = e.details.types;
+    types.map(function(type) {
+      if (!typeCountersMap.hasOwnProperty(type)) {
+        typeCountersMap[type] = {};
+      }
+    });
+    chrome.sync.events.removeEventListener(
+        'onReceivedListOfTypes',
+        onReceivedListOfTypes);
+    refreshTypeCountersDisplay();
+  };
+
+  /**
+   * Callback for receipt of updated per-type counters.
+   *
+   * @param {!Object} e An event containing an updated counter.
+   */
+  var onReceivedCounterUpdate = function(e) {
+    var details = e.details;
+
+    var modelType = details.modelType;
+    var counters = details.counters;
+
+    if (typeCountersMap.hasOwnProperty(modelType))
+      for (k in counters) {
+        typeCountersMap[modelType][k] = counters[k];
+      }
+    refreshTypeCountersDisplay();
+  };
+
+  /**
+   * Initializes state and callbacks for the per-type counters and status UI.
+   */
+  var initTypeCounters = function() {
+    chrome.sync.events.addEventListener(
+        'onCountersUpdated',

[maniscalco, 2014/05/23 00:55:00]

Does it matter that this says onCountersUpdated instead of
onReceivedCountersUpdate ?

[rlarocque, 2014/05/27 20:13:26]

Not technically, no.  One specifies the type of event and the other specifies
the function to call when it occurs.

There's also no harm in making them the same.  I guess I'll just do that.

+        onReceivedCounterUpdate);
+    chrome.sync.events.addEventListener(
+        'onReceivedListOfTypes',
+        onReceivedListOfTypes);
+
+    chrome.sync.requestListOfTypes();
+    chrome.sync.registerForPerTypeCounters();
+  };
+
+  var onLoad = function() {
+    initTypeCounters();
+  };
+
+  return {
+    onLoad: onLoad
+  };
+});
+
+document.addEventListener('DOMContentLoaded', chrome.sync.types.onLoad, false);