WIP: run clang-format-js on lots of things

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';
 
 /**
  * @fileoverview Utility objects and functions for Google Now extension.
  * Most important entities here:
  * (1) 'wrapper' is a module used to add error handling and other services to
@@ skipping 105 matching lines @@
   return request;
 }
 
 /**
  * Sends an error report to the server.
  * @param {Error} error Error to send.
  */
 function sendErrorReport(error) {
   // Don't remove 'error.stack.replace' below!
   var filteredStack = error.canSendMessageToServer ?
-      error.stack : error.stack.replace(/.*\n/, '(message removed)\n');
+      error.stack :
+      error.stack.replace(/.*\n/, '(message removed)\n');
   var file;
   var line;
   var topFrameLineMatch = filteredStack.match(/\n    at .*\n/);
   var topFrame = topFrameLineMatch && topFrameLineMatch[0];
   if (topFrame) {
     // Examples of a frame:
     // 1. '\n    at someFunction (chrome-extension://
     //     pafkbggdmjlpgkdkcbjmhmfcdpncadgh/background.js:915:15)\n'
     // 2. '\n    at chrome-extension://pafkbggdmjlpgkdkcbjmhmfcdpncadgh/
     //     utility.js:269:18\n'
@@ skipping 18 matching lines @@
     if (topFrameElements.length >= 3) {
       file = topFrameElements[topFrameElements.length - 3];
       line = topFrameElements[topFrameElements.length - 2];
     }
   }
 
   var errorText = error.name;
   if (error.canSendMessageToServer)
     errorText = errorText + ': ' + error.message;
 
-  var errorObject = {
-    message: errorText,
-    file: file,
-    line: line,
-    trace: filteredStack
-  };
+  var errorObject =
+      {message: errorText, file: file, line: line, trace: filteredStack};
 
   // We use relatively direct calls here because the instrumentation may be in
   // a bad state. Wrappers and promises should not be involved in the reporting.
   var request = buildServerRequest('POST', 'jserrors', 'application/json');
   request.onloadend = function(event) {
     console.log('sendErrorReport status: ' + request.status);
   };
 
   chrome.identity.getAuthToken({interactive: false}, function(token) {
     if (token) {
@@ skipping 102 matching lines @@
   function debugGetStateString() {
     return 'pendingCallbacks @' + Date.now() + ' = ' +
         JSON.stringify(pendingCallbacks);
   }
 
   /**
    * Checks that we run in a wrapped callback.
    */
   function checkInWrappedCallback() {
     if (!isInWrappedCallback) {
-      reportError(buildErrorWithMessageForServer(
-          'Not in instrumented callback'));
+      reportError(
+          buildErrorWithMessageForServer('Not in instrumented callback'));
     }
   }
 
   /**
    * Adds error processing to an API callback.
    * @param {Function} callback Callback to instrument.
    * @param {boolean=} opt_isEventListener True if the callback is a listener to
    *     a Chrome API event.
    * @return {Function} Instrumented callback.
    */
@@ skipping 20 matching lines @@
 
         if (wrapperPluginInstance)
           wrapperPluginInstance.prologue();
 
         // Call the original callback.
         var returnValue = callback.apply(null, arguments);
 
         if (wrapperPluginInstance)
           wrapperPluginInstance.epilogue();
 
-        verify(isInWrappedCallback,
-               'Instrumented callback is not instrumented upon exit');
+        verify(
+            isInWrappedCallback,
+            'Instrumented callback is not instrumented upon exit');
         isInWrappedCallback = false;
 
         return returnValue;
       } catch (error) {
         reportError(error);
       }
     };
   }
 
   /**
    * Returns an instrumented function.
    * @param {!Array<string>} functionIdentifierParts Path to the chrome.*
    *     function.
    * @param {string} functionName Name of the chrome API function.
    * @param {number} callbackParameter Index of the callback parameter to this
    *     API function.
    * @return {Function} An instrumented function.
    */
   function createInstrumentedFunction(
-      functionIdentifierParts,
-      functionName,
-      callbackParameter) {
+      functionIdentifierParts, functionName, callbackParameter) {
     return function() {
       // This is the wrapper for the API function. Pass the wrapped callback to
       // the original function.
       var callback = arguments[callbackParameter];
       if (typeof callback != 'function') {
         reportError(buildErrorWithMessageForServer(
             'Argument ' + callbackParameter + ' of ' +
             functionIdentifierParts.join('.') + '.' + functionName +
             ' is not a function'));
       }
-      arguments[callbackParameter] = wrapCallback(
-          callback, functionName == 'addListener');
+      arguments[callbackParameter] =
+          wrapCallback(callback, functionName == 'addListener');
 
       var chromeContainer = chrome;
       functionIdentifierParts.forEach(function(fragment) {
         chromeContainer = chromeContainer[fragment];
       });
-      return chromeContainer[functionName].
-          apply(chromeContainer, arguments);
+      return chromeContainer[functionName].apply(chromeContainer, arguments);
     };
   }
 
   /**
    * Instruments an API function to add error processing to its user
    * code-provided callback.
    * @param {string} functionIdentifier Full identifier of the function without
    *     the 'chrome.' portion.
    * @param {number} callbackParameter Index of the callback parameter to this
    *     API function.
@@ skipping 16 matching lines @@
       instrumentedContainer = instrumentedContainer[fragment];
     });
 
     var targetFunction = chromeContainer[functionName];
     if (!targetFunction) {
       reportError(buildErrorWithMessageForServer(
           'Cannot instrument ' + functionIdentifier));
     }
 
     instrumentedContainer[functionName] = createInstrumentedFunction(
-        functionIdentifierParts,
-        functionName,
-        callbackParameter);
+        functionIdentifierParts, functionName, callbackParameter);
   }
 
   instrumentChromeApiFunction('runtime.onSuspend.addListener', 0);
 
   instrumented.runtime.onSuspend.addListener(function() {
     var stringifiedPendingCallbacks = JSON.stringify(pendingCallbacks);
     verify(
         stringifiedPendingCallbacks == '{}',
         'Pending callbacks when unloading event page @' + Date.now() + ':' +
-        stringifiedPendingCallbacks);
+            stringifiedPendingCallbacks);
   });
 
   return {
     wrapCallback: wrapCallback,
     instrumentChromeApiFunction: instrumentChromeApiFunction,
     registerWrapperPluginFactory: registerWrapperPluginFactory,
     checkInWrappedCallback: checkInWrappedCallback,
     debugGetStateString: debugGetStateString
   };
 })();
@@ skipping 122 matching lines @@
      * Takes the argument to a 'then' or 'catch' function and applies
      * a wrapping to callables consistent to ECMA promises.
      * @param {*} maybeCallback Argument to 'then' or 'catch'.
      * @param {CallbackTracker} sameTracker Tracker for the call type.
      *     Example: If the argument is from a 'then' call, use thenTracker.
      * @param {CallbackTracker} otherTracker Tracker for the opposing call type.
      *     Example: If the argument is from a 'then' call, use catchTracker.
      * @return {*} Consumable argument with necessary wrapping applied.
      */
     function registerAndWrapMaybeCallback(
-          maybeCallback, sameTracker, otherTracker) {
+        maybeCallback, sameTracker, otherTracker) {
       // If sameTracker.callbacks is undefined, we've reached an ending state
       // that means this callback will never be called back.
       // We will still forward this call on to let the promise system
       // handle further processing, but since this promise is in an ending state
       // we can be confident it will never be called back.
-      if (isCallable(maybeCallback) &&
-          !maybeCallback.wrappedByPromiseTracker &&
+      if (isCallable(maybeCallback) && !maybeCallback.wrappedByPromiseTracker &&
           sameTracker.callbacks) {
         var handler = wrapper.wrapCallback(function() {
           if (sameTracker.callbacks) {
             clearTracker(otherTracker);
             return maybeCallback.apply(null, arguments);
           }
         }, false);
         // Harmony promises' catch calls will call into handleThen,
         // double-wrapping all catch callbacks. Regular promise catch calls do
         // not call into handleThen. Setting an attribute on the wrapped
@@ skipping 32 matching lines @@
     }
 
     // Register at least one resolve and reject callback so we always receive
     // a callback to update the task manager and clear the callbacks
     // that will never occur.
     //
     // The then form is used to avoid reentrancy by handleCatch,
     // which ends up calling handleThen.
     handleThen(function() {}, function() {});
 
-    return {
-      handleThen: handleThen,
-      handleCatch: handleCatch
-    };
+    return {handleThen: handleThen, handleCatch: handleCatch};
   }
 }
 
 registerPromiseAdapter();
 
 /**
  * Control promise rejection.
  * @enum {number}
  */
 var PromiseRejection = {
   /** Disallow promise rejection */
   DISALLOW: 0,
   /** Allow promise rejection */
   ALLOW: 1
 };
 
 /**
  * Provides the promise equivalent of instrumented.storage.local.get.
  * @param {Object} defaultStorageObject Default storage object to fill.
  * @param {PromiseRejection=} opt_allowPromiseRejection If
  *     PromiseRejection.ALLOW, allow promise rejection on errors, otherwise the
  *     default storage object is resolved.
  * @return {Promise} A promise that fills the default storage object. On
  *     failure, if promise rejection is allowed, the promise is rejected,
  *     otherwise it is resolved to the default storage object.
  */
 function fillFromChromeLocalStorage(
-    defaultStorageObject,
-    opt_allowPromiseRejection) {
+    defaultStorageObject, opt_allowPromiseRejection) {
   return new Promise(function(resolve, reject) {
     // We have to create a keys array because keys with a default value
     // of undefined will cause that key to not be looked up!
     var keysToGet = [];
     for (var key in defaultStorageObject) {
       keysToGet.push(key);
     }
     instrumented.storage.local.get(keysToGet, function(items) {
       if (items) {
         // Merge the result with the default storage object to ensure all keys
@@ skipping 45 matching lines @@
    */
   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,
         'tasks.startFirst: still have pending task callbacks: ' +
-        taskPendingCallbackCount +
-        ', queue = ' + JSON.stringify(queue) + ', ' +
-        wrapper.debugGetStateString());
+            taskPendingCallbackCount + ', queue = ' + JSON.stringify(queue) +
+            ', ' + wrapper.debugGetStateString());
     var entry = queue[0];
     console.log('Starting task ' + entry.name);
 
     entry.task();
 
     verify(isInTask, 'startFirst: not in task at exit');
     isInTask = false;
     if (taskPendingCallbackCount == 0)
       finish();
   }
 
   /**
    * Checks if a new task can be added to the task queue.
    * @param {string} taskName Name of the new task.
    * @return {boolean} Whether the new task can be added.
    */
   function canQueue(taskName) {
     for (var i = 0; i < queue.length; ++i) {
       if (areConflicting(taskName, queue[i].name)) {
-        console.log('Conflict: new=' + taskName +
-                    ', scheduled=' + queue[i].name);
+        console.log(
+            'Conflict: new=' + taskName + ', scheduled=' + queue[i].name);
         return false;
       }
     }
 
     return true;
   }
 
   /**
    * 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
@@ skipping 11 matching lines @@
 
     if (queue.length == 1) {
       startFirst();
     }
   }
 
   /**
    * Completes the current task and starts the next queued task if available.
    */
   function finish() {
-    verify(queue.length >= 1,
-           'tasks.finish: The task queue is empty');
+    verify(queue.length >= 1, 'tasks.finish: The task queue is empty');
     console.log('Finishing task ' + queue[0].name);
     queue.shift();
 
     if (queue.length >= 1)
       startFirst();
   }
 
   instrumented.runtime.onSuspend.addListener(function() {
     verify(
-        queue.length == 0,
-        'Incomplete task when unloading event page,' +
-        ' queue = ' + JSON.stringify(queue) + ', ' +
-        wrapper.debugGetStateString());
+        queue.length == 0, 'Incomplete task when unloading event page,' +
+            ' queue = ' + JSON.stringify(queue) + ', ' +
+            wrapper.debugGetStateString());
   });
 
 
   /**
    * Wrapper plugin for tasks.
    * @constructor
    */
   function TasksWrapperPlugin() {
     this.isTaskCallback = isInTask;
     if (this.isTaskCallback)
@@ skipping 21 matching lines @@
         if (--taskPendingCallbackCount == 0)
           finish();
       }
     }
   };
 
   wrapper.registerWrapperPluginFactory(function() {
     return new TasksWrapperPlugin();
   });
 
-  return {
-    add: add
-  };
+  return {add: add};
 }
 
 /**
  * Builds an object to manage retrying activities with exponential backoff.
  * @param {string} name Name of this attempt manager.
  * @param {function()} attempt Activity that the manager retries until it
  *     calls 'stop' method.
  * @param {number} initialDelaySeconds Default first delay until first retry.
  * @param {number} maximumDelaySeconds Maximum delay between retries.
  * @return {Object} Attempt manager interface.
@@ skipping 178 matching lines @@
   function addListener(callback) {
     listeners.push(callback);
   }
 
   /**
    * Checks if the last signed in state matches the current one.
    * If it doesn't, it notifies the listeners of the change.
    */
   function checkAndNotifyListeners() {
     isSignedIn().then(function(signedIn) {
-      fillFromChromeLocalStorage({lastSignedInState: undefined})
-          .then(function(items) {
-            if (items.lastSignedInState != signedIn) {
-              chrome.storage.local.set(
-                  {lastSignedInState: signedIn});
-              listeners.forEach(function(callback) {
-                callback();
-              });
-            }
-        });
+      fillFromChromeLocalStorage({
+        lastSignedInState: undefined
+      }).then(function(items) {
+        if (items.lastSignedInState != signedIn) {
+          chrome.storage.local.set({lastSignedInState: signedIn});
+          listeners.forEach(function(callback) {
+            callback();
+          });
+        }
       });
+    });
   }
 
   instrumented.identity.onSignInChanged.addListener(function() {
     checkAndNotifyListeners();
   });
 
   instrumented.alarms.onAlarm.addListener(function(alarm) {
     if (alarm.name == alarmName)
       checkAndNotifyListeners();
   });
 
   // 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,
     getAuthToken: getAuthToken,
     getLogin: getLogin,
     isSignedIn: isSignedIn,
     removeToken: removeToken
   };
 }