[invalidations] Added table with registered objectsIds

chrome/browser/resources/about_invalidations.js

-// Copyright (c) 2014 The Chromium Authors. All rights reserved.
+// 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.invalidations', function() {
+  /**
+   * Local variable where we maintain a count of the invalidations received
+   * and of every ObjectId that has ever been updated (note that this doesn't
+   * log any invalidations ocurred prior to opening the about:invalidation page)
+   */
+  var tableObjects = {};
 
   function quote(str) {
     return '\"' + str + '\"';
   }
 
   function nowTimeString() {
     return '[' + new Date().getTime() + '] ';
   }
 
   /**
    * Appends a string to a textarea log.
    *
    * @param {string} logMessage The string to be appended.
    */
   function appendToLog(logMessage) {
     var invalidationsLog = $('invalidations-log');
     invalidationsLog.value += logMessage + '\n';
   }
+  /**
+   *  Updates the jstemplate with the latest ObjectIds, ordered by registrar.
+   */
+  function repaintTable() {
+    var header = {

[rlarocque, 2014/02/15 00:09:39]

Why not just put this in the HTML?  Putting it there inside a <thead> element
might make it easier to style, too.

[mferreria_g, 2014/02/15 01:27:39]

Wasn't aware of the <thead> element. Done.

+      registrar: 'Registrar',
+      source: 'Source',
+      name: 'Name',
+      count: 'Count',
+      version: 'Last Version',
+      time: 'Last Time',
+      payload: 'Last Payload',
+      type: 'header'
+    };
+    var keys = [];
+    for (var key in tableObjects)
+      keys.push(key);
+    keys.sort();
+    var sortedInvalidations = [];
+    sortedInvalidations.push(header);
+    for (var i = 0; i < keys.length; i++)
+      sortedInvalidations.push(tableObjects[keys[i]]);
+    var wrapped = { objectsidtable: sortedInvalidations };
+    jstProcess(new JsEvalContext(wrapped), $('objectsid-table-div'));
+  }
 
   /**
    * Shows the current state of the InvalidatorService
    *
    * @param {string} newState The string to be displayed and logged.
    */
   function updateState(newState) {
     var logMessage = nowTimeString() +
       'Invalidations service state changed to ' + quote(newState);
 
     appendToLog(logMessage);
     $('invalidations-state').textContent = newState;
     currentInvalidationState = newState;
   }
 
   /**
    * Adds to the log the latest invalidations received
    *
    * @param {Array of Object} allInvalidations The array of ObjectId
-   * that contains the invalidations received by the InvalidatorService
+   *     that contains the invalidations received by the InvalidatorService.
    */
   function logInvalidations(allInvalidations) {
     for (var i = 0; i < allInvalidations.length; i++) {
       var inv = allInvalidations[i];
       if (inv.hasOwnProperty('objectId')) {
         var logMessage = nowTimeString() +
           'Received Invalidation with type ' +
           quote(inv.objectId.name) +
           ' version ' +
           quote((inv.isUnknownVersion ? 'Unknown' : inv.version)) +
           ' with payload ' +
           quote(inv.payload);
 
         appendToLog(logMessage);
+        var isInvalidation = true;
+        logToTable(inv, isInvalidation);
       }
     }
+    repaintTable();
+  }
+
+  /**
+   * Marks a change in the table whether a new invalidation has arrived
+   * or a new ObjectId is currently being added or updated.
+   *
+   * @param {object} oId The ObjectId being added or updated.
+   * @param {bool} isInvaldation A flag that says that an invalidation
+   *     for this ObjectId has arrived or we just need to add it to the table
+   *     as it was just updated its state.
+   */
+  function logToTable(oId, isInvalidation) {
+    var registrar = oId.registrar;
+    var name = oId.objectId.name;
+    var source = oId.objectId.source;
+    var key = source + '-' + name;
+    var time = new Date();
+    var version = oId.isUnknownVersion ? '?' :
+      oId.version;
+    var payload = '';
+    if (oId.hasOwnProperty('payload'))
+      payload = oId.payload;
+    if (!(key in tableObjects)) {
+      tableObjects[key] = {
+        name: name,
+        source: source,
+        count: 0,
+        registrar: registrar,
+        time: '',
+        version: '',
+        payload: '',
+        type: 'content'
+      };
+    }
+    // Refresh the type to be a content because it might have been
+    // greyed out.
+    tableObjects[key].type = 'content';
+    if (isInvalidation) {
+      tableObjects[key].count = tableObjects[key].count + 1;
+      tableObjects[key].time = time.toTimeString();
+      tableObjects[key].version = version;
+      tableObjects[key].payload = payload;
+    }
   }
 
   /**
+   * Updates the table with the objects ids registered for invalidations
+   *
+   * @param {string} registrar The name of the owner of the InvalidationHandler
+   *     that is registered for invalidations
+   * @param {Array of Object} allIds An array of ObjectsIds that are currently
+   *     registered for invalidations. It is not differential (as in, whatever
+   *     is not registered now but was before, it mean it was taken out the
+   *     registered objects)
+   */
+  function updateIds(registrar, allIds) {
+    // Grey out every datatype assigned to this registrar
+    // (and reenable them later in case they are still registered).
+    for (var key in tableObjects) {
+      if (tableObjects[key]['registrar'] === registrar)
+        tableObjects[key].type = 'greyed';
+    }
+    // Reenable those ObjectsIds still registered with this registrar.
+    for (var i = 0; i < allIds.length; i++) {
+      var oId = { objectId: allIds[i], registrar: registrar };
+      var isInvalidation = false;
+      logToTable(oId, isInvalidation);
+    }
+    repaintTable();
+  }
+
+  /**
    * Function that notifies the Invalidator Logger that the UI is
    * ready to receive real-time notifications.
    */
   function onLoadWork() {
     chrome.send('doneLoading');
   }
 
   return {
     updateState: updateState,
+    updateIds: updateIds,
     logInvalidations: logInvalidations,
     onLoadWork: onLoadWork
   };
 });
 
 document.addEventListener('DOMContentLoaded', chrome.invalidations.onLoadWork);