Run tools/clang-format-js on chrome/browser/resources/net_internals

chrome/browser/resources/net_internals/log_util.js

 // Copyright (c) 2012 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.
 
 log_util = (function() {
   'use strict';
 
   /**
    * Creates a new log dump.  |events| is a list of all events, |polledData| is
    * an object containing the results of each poll, |tabData| is an object
@@ skipping 13 matching lines @@
    *   |constants| needed to interpret the data.  This also includes some
    *               browser state information.
    *   |events| from the NetLog.
    *   |polledData| from each PollableDataHelper available on the source OS.
    *   |tabData| containing any tab-specific state that's not present in
    *             |polledData|.
    *
    * |polledData| and |tabData| may be empty objects, or may be missing data for
    * tabs not present on the OS the log is from.
    */
-  function createLogDump(userComments, constants, events, polledData, tabData,
-                         numericDate, privacyStripping) {
+  function createLogDump(
+      userComments, constants, events, polledData, tabData, numericDate,
+      privacyStripping) {
     if (privacyStripping)
       events = events.map(stripPrivacyInfo);
 
     var logDump = {
       'userComments': userComments,
       'constants': constants,
       'events': events,
       'polledData': polledData,
       'tabData': tabData
     };
@@ skipping 11 matching lines @@
    * |oldLogDump|.  The other parts of the log dump come from current
    * net-internals state.
    */
   function createUpdatedLogDump(userComments, oldLogDump, privacyStripping) {
     var numericDate = null;
     if (oldLogDump.constants.clientInfo &&
         oldLogDump.constants.clientInfo.numericDate) {
       numericDate = oldLogDump.constants.clientInfo.numericDate;
     }
     var logDump = createLogDump(
-        userComments,
-        Constants,
+        userComments, Constants,
         EventsTracker.getInstance().getAllCapturedEvents(),
-        oldLogDump.polledData,
-        getTabData_(),
-        numericDate,
-        privacyStripping);
+        oldLogDump.polledData, getTabData_(), numericDate, privacyStripping);
     return JSON.stringify(logDump);
   }
 
   /**
    * Creates a full log dump using |polledData| and the return value of each
    * tab's saveState function and passes it to |callback|.
    */
-  function onUpdateAllCompleted(userComments, callback, privacyStripping,
-                                polledData) {
+  function onUpdateAllCompleted(
+      userComments, callback, privacyStripping, polledData) {
     var logDump = createLogDump(
-        userComments,
-        Constants,
-        EventsTracker.getInstance().getAllCapturedEvents(),
-        polledData,
-        getTabData_(),
-        timeutil.getCurrentTime(),
-        privacyStripping);
+        userComments, Constants,
+        EventsTracker.getInstance().getAllCapturedEvents(), polledData,
+        getTabData_(), timeutil.getCurrentTime(), privacyStripping);
     callback(JSON.stringify(logDump));
   }
 
   /**
    * Called to create a new log dump.  Must not be called once a dump has been
    * loaded.  Once a log dump has been created, |callback| is passed the dumped
    * text as a string.
    */
   function createLogDumpAsync(userComments, callback, privacyStripping) {
-    g_browser.updateAllInfo(
-        onUpdateAllCompleted.bind(null, userComments, callback,
-                                  privacyStripping));
+    g_browser.updateAllInfo(onUpdateAllCompleted.bind(
+        null, userComments, callback, privacyStripping));
   }
 
   /**
    * Gather any tab-specific state information prior to creating a log dump.
    */
   function getTabData_() {
     var tabData = {};
     var tabSwitcher = MainView.getInstance().tabSwitcher();
     var tabIdToView = tabSwitcher.getAllTabViews();
     for (var tabId in tabIdToView) {
@@ skipping 43 matching lines @@
     if (errorString.length > 0)
       return 'Load failed:\n\n' + errorString;
 
     if (typeof(logDump.polledData) != 'object')
       logDump.polledData = {};
     if (typeof(logDump.tabData) != 'object')
       logDump.tabData = {};
 
     if (logDump.constants.logFormatVersion != Constants.logFormatVersion) {
       return 'Unable to load different log version.' +
-             ' Found ' + logDump.constants.logFormatVersion +
-             ', Expected ' + Constants.logFormatVersion;
+          ' Found ' + logDump.constants.logFormatVersion + ', Expected ' +
+          Constants.logFormatVersion;
     }
 
     g_browser.receivedConstants(logDump.constants);
 
     // Check for validity of each log entry, and then add the ones that pass.
     // Since the events are kept around, and we can't just hide a single view
     // on a bad event, we have more error checking for them than other data.
     var validEvents = [];
     var numDeprecatedPassiveEvents = 0;
     for (var eventIndex = 0; eventIndex < logDump.events.length; ++eventIndex) {
       var event = logDump.events[eventIndex];
-      if (typeof event == 'object' &&
-          typeof event.source == 'object' &&
+      if (typeof event == 'object' && typeof event.source == 'object' &&
           typeof event.time == 'string' &&
           typeof EventTypeNames[event.type] == 'string' &&
           typeof EventSourceTypeNames[event.source.type] == 'string' &&
           getKeyWithValue(EventPhase, event.phase) != '?') {
         if (event.wasPassivelyCaptured) {
           // NOTE: Up until Chrome 18, log dumps included "passively captured"
           // events. These are no longer supported, so skip past them
           // to avoid confusing the rest of the code.
           numDeprecatedPassiveEvents++;
           continue;
@@ skipping 35 matching lines @@
     for (var tabId in tabIdToView) {
       var view = tabIdToView[tabId];
       view.onLoadLogStart(logDump.polledData, logDump.tabData[tabId]);
     }
     EventsTracker.getInstance().addLogEntries(validEvents);
 
     var numInvalidEvents = logDump.events.length -
         (validEvents.length + numDeprecatedPassiveEvents);
     if (numInvalidEvents > 0) {
       errorString += 'Unable to load ' + numInvalidEvents +
-                     ' events, due to invalid data.\n\n';
+          ' events, due to invalid data.\n\n';
     }
 
     if (numDeprecatedPassiveEvents > 0) {
       errorString += 'Discarded ' + numDeprecatedPassiveEvents +
           ' passively collected events. Use an older version of Chrome to' +
           ' load this dump if you want to see them.\n\n';
     }
 
     // Update all views with data from the file.  Show only those views which
     // successfully load the data.
     for (var tabId in tabIdToView) {
       var view = tabIdToView[tabId];
       var showView = false;
       // The try block eliminates the need for checking every single value
       // before trying to access it.
       try {
-        if (view.onLoadLogFinish(logDump.polledData,
-                                 logDump.tabData[tabId],
-                                 logDump)) {
+        if (view.onLoadLogFinish(
+                logDump.polledData, logDump.tabData[tabId], logDump)) {
           showView = true;
         }
       } catch (error) {
-        errorString += 'Caught error while calling onLoadLogFinish: ' +
-                       error + '\n\n';
+        errorString +=
+            'Caught error while calling onLoadLogFinish: ' + error + '\n\n';
       }
       tabSwitcher.showTabLink(tabId, showView);
     }
 
     return errorString + 'Log loaded.';
   }
 
   /**
    * Loads a log dump from the string |logFileContents|, which can be either a
    * full net-internals dump, or a NetLog dump only.  Returns a string
    * containing a log of the load.
    */
   function loadLogFile(logFileContents, fileName) {
     // Try and parse the log dump as a single JSON string.  If this succeeds,
     // it's most likely a full log dump.  Otherwise, it may be a dump created by
     // --log-net-log.
     var parsedDump = null;
     var errorString = '';
     try {
       parsedDump = JSON.parse(logFileContents);
     } catch (error) {
       try {
         // We may have a --log-net-log=blah log dump.  If so, remove the comma
         // after the final good entry, and add the necessary close brackets.
-        var end = Math.max(logFileContents.lastIndexOf(',\n'),
-                           logFileContents.lastIndexOf(',\r'));
+        var end = Math.max(
+            logFileContents.lastIndexOf(',\n'),
+            logFileContents.lastIndexOf(',\r'));
         if (end != -1) {
           parsedDump = JSON.parse(logFileContents.substring(0, end) + ']}');
           errorString += 'Log file truncated.  Events may be missing.\n';
         }
-      }
-      catch (error2) {
+      } catch (error2) {
       }
     }
 
     if (!parsedDump)
       return 'Unable to parse log dump as JSON file.';
     return errorString + loadLogDump(parsedDump, fileName);
   }
 
   // Exports.
   return {
     createUpdatedLogDump: createUpdatedLogDump,
     createLogDumpAsync: createLogDumpAsync,
     loadLogFile: loadLogFile
   };
 })();