Instrumenting missing API calls

chrome/browser/resources/google_now/utility.js

 // Copyright (c) 2013 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.
 
 'use strict';
 
 // TODO(vadimt): Remove alerts.
 
 /**
  * @fileoverview Utility objects and functions for Google Now extension.
@@ skipping 64 matching lines @@
    */
   var pendingCallbacks = {};
 
   /**
    * True if currently executed code is a part of a task.
    * @type {boolean}
    */
   var isInTask = false;
 
   /**
+   * True if currently executed code runs in an instrumented callback.
+   * @type {boolean}
+   */
+  var isInInstrumentedCallback = false;
+
+  /**
+   * Checks that we run in an instrumented callback.
+   */
+  function checkInInstrumentedCallback() {
+    if (!isInInstrumentedCallback) {
+      // Cannot use verify() since no one will catch the exception.
+      // This alert will detect bugs at the development stage, and is very
+      // unlikely to be seen by users.
+      var error = 'Not in instrumented callback: ' + new Error().stack;
+      console.error(error);
+      alert(error);

[arv (Not doing code reviews), 2013/08/02 22:41:52]

why both alert and console.log?

[vadimt, 2013/08/02 22:47:04]

Alert to know that this has happened at all.
console.error - to easily attach console output to bug reports.
Also, I see that alert dialogs from time to time have glitches that make
information unreadable.

+    }
+  }
+
+  /**
    * Starts the first queued task.
    */
   function startFirst() {
     verify(queue.length >= 1, 'startFirst: queue is empty');
     verify(!isInTask, 'startFirst: already in task');
     isInTask = true;
 
     // Start the oldest queued task, but don't remove it from the queue.
     verify(
         taskPendingCallbackCount == 0,
@@ skipping 31 matching lines @@
 
   /**
    * Adds a new task. If another task is not running, runs the task immediately.
    * If any task in the queue is not compatible with the task, ignores the new
    * task. Otherwise, stores the task for future execution.
    * @param {string} taskName Name of the task.
    * @param {function(function())} task Function to run. Takes a callback
    *     parameter. Call this callback on completion.
    */
   function add(taskName, task) {
+    checkInInstrumentedCallback();
     console.log('Adding task ' + taskName);
     if (!canQueue(taskName))
       return;
 
     queue.push({name: taskName, task: task});
 
     if (queue.length == 1) {
       startFirst();
     }
   }
@@ skipping 54 matching lines @@
 
   /**
    * Unique ID of the next callback.
    * @type {number}
    */
   var nextCallbackId = 0;
 
   /**
    * Adds error processing to an API callback.
    * @param {Function} callback Callback to instrument.
-   * @param {boolean=} opt_dontRequire True if the callback is not required to
-   *     be invoked.
+   * @param {boolean=} opt_isEventListener True if the callback is an event
+   *      listener.
    * @return {Function} Instrumented callback.
    */
-  function wrapCallback(callback, opt_dontRequire) {
-    verify(!(opt_dontRequire && isInTask), 'Unrequired callback in a task.');
+  function wrapCallback(callback, opt_isEventListener) {
+    verify(!(opt_isEventListener && isInTask),
+           'Unrequired callback in a task.');
     var callbackId = nextCallbackId++;
     var isTaskCallback = isInTask;
     if (isTaskCallback)
       ++taskPendingCallbackCount;
-    if (!opt_dontRequire)
+    if (!opt_isEventListener) {
+      checkInInstrumentedCallback();
       pendingCallbacks[callbackId] = new Error().stack;
+    }
 
     return function() {
       // This is the wrapper for the callback.
       try {
         if (isTaskCallback) {
           verify(!isInTask, 'wrapCallback: already in task');
           isInTask = true;
         }
-        if (!opt_dontRequire)
+        if (!opt_isEventListener)
           delete pendingCallbacks[callbackId];
 
         // Call the original callback.
+        verify(!isInInstrumentedCallback, 'Re-entering instrumented callback');
+        isInInstrumentedCallback = true;
         callback.apply(null, arguments);
+        verify(isInInstrumentedCallback,
+               'Instrumented callback is not instrumented upon exit');
+        isInInstrumentedCallback = false;
 
         if (isTaskCallback) {
           verify(isInTask, 'wrapCallback: not in task at exit');
           isInTask = false;
           if (--taskPendingCallbackCount == 0)
             finish();
         }
       } catch (error) {
         var message = 'Uncaught exception:\n' + error.stack;
         console.error(message);
@@ skipping 30 matching lines @@
       if (typeof callback != 'function') {
         alert('Argument ' + callbackParameter + ' of ' + functionName +
               ' is not a function');
       }
       arguments[callbackParameter] = wrapCallback(
           callback, functionName == 'addListener');
       return originalFunction.apply(namespace, arguments);
     };
   }
 
+  instrumentApiFunction(chrome.alarms, 'get', 1);
   instrumentApiFunction(chrome.alarms.onAlarm, 'addListener', 0);
+  instrumentApiFunction(chrome.identity, 'getAuthToken', 1);
   instrumentApiFunction(chrome.runtime.onSuspend, 'addListener', 0);
 
   chrome.runtime.onSuspend.addListener(function() {
     var stringifiedPendingCallbacks = JSON.stringify(pendingCallbacks);
     verify(
         queue.length == 0 && stringifiedPendingCallbacks == '{}',
         'Incomplete task or pending callbacks when unloading event page,' +
         ' queue = ' + JSON.stringify(queue) +
         ', pendingCallbacks = ' + stringifiedPendingCallbacks);
   });
@@ skipping 191 matching lines @@
   // Poll for the sign in state every hour.
   // One hour is just an arbitrary amount of time chosen.
   chrome.alarms.create(alarmName, {periodInMinutes: 60});
 
   return {
     addListener: addListener,
     isSignedIn: isSignedIn,
     removeToken: removeToken
   };
 }