ONC import option to chromeos tab in chrome://net-internals

chrome/browser/resources/net_internals/browser_bridge.js

 // Copyright (c) 2011 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.
 
 /**
  * This class provides a "bridge" for communicating between the javascript and
  * the browser.
  */
 var BrowserBridge = (function() {
   'use strict';
 
   /**
    * Delay in milliseconds between updates of certain browser information.
    */
   var POLL_INTERVAL_MS = 5000;
 
   /**
    * @constructor
    */
   function BrowserBridge() {
     assertFirstConstructorCall(BrowserBridge);
 
     // List of observers for various bits of browser state.
     this.connectionTestsObservers_ = [];
     this.hstsObservers_ = [];
     this.httpThrottlingObservers_ = [];
     this.constantsObservers_ = [];
+    this.crosONCFileParseObservers_ = [];
 
     this.pollableDataHelpers_ = {};
     this.pollableDataHelpers_.proxySettings =
         new PollableDataHelper('onProxySettingsChanged',
                                this.sendGetProxySettings.bind(this));
     this.pollableDataHelpers_.badProxies =
         new PollableDataHelper('onBadProxiesChanged',
                                this.sendGetBadProxies.bind(this));
     this.pollableDataHelpers_.httpCacheInfo =
         new PollableDataHelper('onHttpCacheInfoChanged',
@@ skipping 179 matching lines @@
     },
 
     refreshSystemLogs: function() {
       this.send('refreshSystemLogs');
     },
 
     getSystemLog: function(log_key, cellId) {
       this.send('getSystemLog', [log_key, cellId]);
     },
 
+    importONCFile: function(fileContent, passcode) {
+      this.send('importONCFile', [fileContent, passcode]);
+    },
+
     //--------------------------------------------------------------------------
     // Messages received from the browser.
     //--------------------------------------------------------------------------
 
     receive: function(command, params) {
       // Does nothing if disabled.
       if (this.disabled_)
         return;
       this[command](params);
     },
 
     receivedConstants: function(constants) {
-      for (var i = 0; i < this.constantsObservers_.length; ++i)
+      for (var i = 0; i < this.constantsObservers_.length; i++)
         this.constantsObservers_[i].onReceivedConstants(constants);
     },
 
     receivedLogEntries: function(logEntries) {
       this.sourceTracker.onReceivedLogEntries(logEntries);
     },
 
     receivedProxySettings: function(proxySettings) {
       this.pollableDataHelpers_.proxySettings.update(proxySettings);
     },
@@ skipping 26 matching lines @@
 
     receivedServiceProviders: function(serviceProviders) {
       this.pollableDataHelpers_.serviceProviders.update(serviceProviders);
     },
 
     receivedPassiveLogEntries: function(entries) {
       this.sourceTracker.onReceivedPassiveLogEntries(entries);
     },
 
     receivedStartConnectionTestSuite: function() {
-      for (var i = 0; i < this.connectionTestsObservers_.length; ++i)
+      for (var i = 0; i < this.connectionTestsObservers_.length; i++)
         this.connectionTestsObservers_[i].onStartedConnectionTestSuite();
     },
 
     receivedStartConnectionTestExperiment: function(experiment) {
-      for (var i = 0; i < this.connectionTestsObservers_.length; ++i) {
+      for (var i = 0; i < this.connectionTestsObservers_.length; i++) {
         this.connectionTestsObservers_[i].onStartedConnectionTestExperiment(
             experiment);
       }
     },
 
     receivedCompletedConnectionTestExperiment: function(info) {
-      for (var i = 0; i < this.connectionTestsObservers_.length; ++i) {
+      for (var i = 0; i < this.connectionTestsObservers_.length; i++) {
         this.connectionTestsObservers_[i].onCompletedConnectionTestExperiment(
             info.experiment, info.result);
       }
     },
 
     receivedCompletedConnectionTestSuite: function() {
-      for (var i = 0; i < this.connectionTestsObservers_.length; ++i)
+      for (var i = 0; i < this.connectionTestsObservers_.length; i++)
         this.connectionTestsObservers_[i].onCompletedConnectionTestSuite();
     },
 
     receivedHSTSResult: function(info) {
-      for (var i = 0; i < this.hstsObservers_.length; ++i)
+      for (var i = 0; i < this.hstsObservers_.length; i++)
         this.hstsObservers_[i].onHSTSQueryResult(info);
     },
 
+    receivedONCFileParse: function(status) {
+      for (var i = 0; i < this.crosONCFileParseObservers_.length; i++)
+        this.crosONCFileParseObservers_[i].onONCFileParse(status);
+    },
+
     receivedHttpCacheInfo: function(info) {
       this.pollableDataHelpers_.httpCacheInfo.update(info);
     },
 
     receivedHttpThrottlingEnabledPrefChanged: function(enabled) {
-      for (var i = 0; i < this.httpThrottlingObservers_.length; ++i) {
+      for (var i = 0; i < this.httpThrottlingObservers_.length; i++) {
         this.httpThrottlingObservers_[i].onHttpThrottlingEnabledPrefChanged(
             enabled);
       }
     },
 
     receivedPrerenderInfo: function(prerenderInfo) {
       this.pollableDataHelpers_.prerenderInfo.update(prerenderInfo);
     },
 
     //--------------------------------------------------------------------------
@@ skipping 148 matching lines @@
      * Adds a listener for the results of HSTS (HTTPS Strict Transport Security)
      * queries. The observer will be called back with:
      *
      *   observer.onHSTSQueryResult(result);
      */
     addHSTSObserver: function(observer) {
       this.hstsObservers_.push(observer);
     },
 
     /**
+     * Adds a listener for ONC file parse status. The observer will be called
+     * back with:
+     *
+     *   observer.onONCFileParse(status);
+     */
+    addCrosONCFileParseObserver: function(observer) {
+      this.crosONCFileParseObservers_.push(observer);
+    },
+
+    /**
      * Adds a listener for HTTP throttling-related events. |observer| will be
      * called back when HTTP throttling is enabled/disabled, through:
      *
      *   observer.onHttpThrottlingEnabledPrefChanged(enabled);
      */
     addHttpThrottlingObserver: function(observer) {
       this.httpThrottlingObservers_.push(observer);
     },
 
     /**
@@ skipping 53 matching lines @@
     this.startUpdate = startUpdateFunction;
     this.observerInfos_ = [];
   }
 
   PollableDataHelper.prototype = {
     getObserverMethodName: function() {
       return this.observerMethodName_;
     },
 
     isObserver: function(object) {
-      for (var i = 0; i < this.observerInfos_.length; ++i) {
+      for (var i = 0; i < this.observerInfos_.length; i++) {
         if (this.observerInfos_[i].observer === object)
           return true;
       }
       return false;
     },
 
     /**
      * If |ignoreWhenUnchanged| is true, we won't send data again until it
      * changes.
      */
     addObserver: function(observer, ignoreWhenUnchanged) {
       this.observerInfos_.push(new ObserverInfo(observer, ignoreWhenUnchanged));
     },
 
     removeObserver: function(observer) {
-      for (var i = 0; i < this.observerInfos_.length; ++i) {
+      for (var i = 0; i < this.observerInfos_.length; i++) {
         if (this.observerInfos_[i].observer === observer) {
           this.observerInfos_.splice(i, 1);
           return;
         }
       }
     },
 
     /**
      * Helper function to handle calling all the observers, but ONLY if the data
      * has actually changed since last time or the observer has yet to receive
      * any data. This is used for data we received from browser on an update
      * loop.
      */
     update: function(data) {
       var prevData = this.currentData_;
       var changed = false;
 
       // If the data hasn't changed since last time, will only need to notify
       // observers that have not yet received any data.
       if (!prevData || JSON.stringify(prevData) != JSON.stringify(data)) {
         changed = true;
         this.currentData_ = data;
       }
 
       // Notify the observers of the change, as needed.
-      for (var i = 0; i < this.observerInfos_.length; ++i) {
+      for (var i = 0; i < this.observerInfos_.length; i++) {
         var observerInfo = this.observerInfos_[i];
         if (changed || !observerInfo.hasReceivedData ||
             !observerInfo.ignoreWhenUnchanged) {
           observerInfo.observer[this.observerMethodName_](this.currentData_);
           observerInfo.hasReceivedData = true;
         }
       }
     },
 
     /**
      * Returns true if one of the observers actively wants the data
      * (i.e. is visible).
      */
     hasActiveObserver: function() {
-      for (var i = 0; i < this.observerInfos_.length; ++i) {
+      for (var i = 0; i < this.observerInfos_.length; i++) {
         if (this.observerInfos_[i].observer.isActive())
           return true;
       }
       return false;
     }
   };
 
   /**
    * This is a helper class used by PollableDataHelper, to keep track of
    * each observer and whether or not it has received any data.  The
@@ skipping 39 matching lines @@
       helper.removeObserver(this);
       --this.observingCount_;
       this.updatedData_[name] = data;
       if (this.observingCount_ == 0)
         this.callback_(this.updatedData_);
     }
   };
 
   return BrowserBridge;
 })();