Revert of Allow users to add third-party VPNs from the settings page

chrome/browser/resources/options/chromeos/network_list.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.
 
 /**
  * This partially describes the network list entries passed to
  * refreshNetworkData. The contents of those lists actually match
  * CrOnc.NetworkConfigType with the addition of the policyManaged property.
  * TODO(stevenjb): Use networkingPrivate.getNetworks.
  * @typedef {{
@@ skipping 357 matching lines @@
         Menu.decorate(menu);
         for (var i = 0; i < this.data.menu.length; i++) {
           var entry = this.data.menu[i];
           createCallback_(menu, null, entry.label, entry.command);
         }
         return menu;
       }
       return null;
     },
 
-    /**
-     * Determines if a menu can be updated on the fly. Menus that cannot be
-     * updated are fully regenerated using createMenu. The advantage of
-     * updating a menu is that it can preserve ordering of networks avoiding
-     * entries from jumping around after an update.
-     * @return {boolean} Whether the menu can be updated on the fly.
-     */
     canUpdateMenu: function() {
       return false;
     },
 
     /**
-     * Removes the current menu contents, causing it to be regenerated when the
-     * menu is shown the next time. If the menu is showing right now, its
-     * contents are regenerated immediately and the menu remains visible.
-     */
-    refreshMenu: function() {
-      this.menu_ = null;
-      if (activeMenu_ == this.getMenuName())
-        this.showMenu();
-    },
-
-    /**
      * Displays a popup menu.
      */
     showMenu: function() {
       var rebuild = false;
       // Force a rescan if opening the menu for WiFi networks to ensure the
       // list is up to date. Networks are periodically rescanned, but depending
       // on timing, there could be an excessive delay before the first rescan
       // unless forced.
       var rescan = !activeMenu_ && this.data_.key == 'WiFi';
       if (!this.menu_) {
         rebuild = true;
         var existing = $(this.getMenuName());
         if (existing) {
-          if (this.canUpdateMenu() && this.updateMenu())
+          if (this.updateMenu())
             return;
           closeMenu_();
         }
         this.menu_ = this.createMenu();
         this.menu_.addEventListener('mousedown', function(e) {
           // Prevent blurring of list, which would close the menu.
           e.preventDefault();
         });
         var parent = $('network-menus');
         if (existing)
@@ skipping 83 matching lines @@
     createMenu: function() {
       var menu = this.ownerDocument.createElement('div');
       menu.id = this.getMenuName();
       menu.className = 'network-menu';
       menu.hidden = true;
       Menu.decorate(menu);
       var addendum = [];
       if (this.data_.key == 'WiFi') {
         addendum.push({
           label: loadTimeData.getString('joinOtherNetwork'),
-          command: createAddNonVPNConnectionCallback_('WiFi'),
+          command: createAddConnectionCallback_('WiFi'),
           data: {}
         });
       } else if (this.data_.key == 'Cellular') {
         if (cellularEnabled_ && cellularSupportsScan_) {
           addendum.push({
             label: loadTimeData.getString('otherCellularNetworks'),
-            command: createAddNonVPNConnectionCallback_('Cellular'),
+            command: createAddConnectionCallback_('Cellular'),
             addClass: ['other-cellulars'],
             data: {}
           });
         }
 
         var label = enableDataRoaming_ ? 'disableDataRoaming' :
             'enableDataRoaming';
         var disabled = !loadTimeData.getValue('loggedInAsOwner');
         var entry = {label: loadTimeData.getString(label),
                      data: {}};
         if (disabled) {
           entry.command = null;
           entry.tooltip =
               loadTimeData.getString('dataRoamingDisableToggleTooltip');
         } else {
           var self = this;
           entry.command = function() {
             options.Preferences.setBooleanPref(
                 'cros.signed.data_roaming_enabled',
                 !enableDataRoaming_, true);
             // Force revalidation of the menu the next time it is displayed.
             self.menu_ = null;
           };
         }
         addendum.push(entry);
       } else if (this.data_.key == 'VPN') {
-        addendum = addendum.concat(createAddVPNConnectionEntries_());
+        addendum.push({
+          label: loadTimeData.getString('joinOtherNetwork'),
+          command: createAddConnectionCallback_('VPN'),
+          data: {}
+        });
       }
 
       var list = this.data.rememberedNetworks;
       if (list && list.length > 0) {
         var callback = function(list) {
           $('remembered-network-list').clear();
           var dialog = options.PreferredNetworks.getInstance();
           PageManager.showPageByName('preferredNetworksPage', false);
           dialog.update(list);
           sendChromeMetricsAction('Options_NetworkShowPreferred');
@@ skipping 78 matching lines @@
             separator = false;
           } else if (!separator) {
             menu.appendChild(MenuItem.createSeparator());
             separator = true;
           }
         }
       }
       return menu;
     },
 
-    /** @override */
+    /**
+     * Determines if a menu can be updated on the fly. Menus that cannot be
+     * updated are fully regenerated using createMenu. The advantage of
+     * updating a menu is that it can preserve ordering of networks avoiding
+     * entries from jumping around after an update.
+     */
     canUpdateMenu: function() {
       return this.data_.key == 'WiFi' && activeMenu_ == this.getMenuName();
     },
 
     /**
      * Updates an existing menu.  Updated menus preserve ordering of prior
      * entries.  During the update process, the ordering may differ from the
      * preferred ordering as determined by the network library.  If the
      * ordering becomes potentially out of sync, then the updated menu is
      * marked for disposal on close.  Reopening the menu will force a
-     * regeneration, which will in turn fix the ordering. This method must only
-     * be called if canUpdateMenu() returned |true|.
+     * regeneration, which will in turn fix the ordering.
      * @return {boolean} True if successfully updated.
      */
     updateMenu: function() {
+      if (!this.canUpdateMenu())
+        return false;
       var oldMenu = $(this.getMenuName());
       var group = oldMenu.getElementsByClassName('network-menu-group')[0];
       if (!group)
         return false;
       var newMenu = this.createMenu();
       var discardOnClose = false;
       var oldNetworkButtons = this.extractNetworkConnectButtons_(oldMenu);
       var newNetworkButtons = this.extractNetworkConnectButtons_(newMenu);
       for (var key in oldNetworkButtons) {
         if (newNetworkButtons[key]) {
@@ skipping 166 matching lines @@
       this.autoExpands = true;
       this.dataModel = new ArrayDataModel([]);
       this.selectionModel = new ListSingleSelectionModel();
       this.addEventListener('blur', this.onBlur_.bind(this));
       this.selectionModel.addEventListener('change',
                                            this.onSelectionChange_.bind(this));
 
       // Wi-Fi control is always visible.
       this.update({key: 'WiFi', networkList: []});
 
-      this.updateAddConnectionMenuEntries_();
+      var entryAddWifi = {
+        label: loadTimeData.getString('addConnectionWifi'),
+        command: createAddConnectionCallback_('WiFi')
+      };
+      var entryAddVPN = {
+        label: loadTimeData.getString('addConnectionVPN'),
+        command: createAddConnectionCallback_('VPN')
+      };
+      this.update({key: 'addConnection',
+                   iconType: 'add-connection',
+                   menu: [entryAddWifi, entryAddVPN]
+                  });
 
       var prefs = options.Preferences.getInstance();
       prefs.addEventListener('cros.signed.data_roaming_enabled',
           function(event) {
             enableDataRoaming_ = event.value.value;
           });
       this.endBatchUpdates();
-
-      options.VPNProviders.addObserver(this.onVPNProvidersChanged_.bind(this));
     },
 
     /**
-     * Called when the list of VPN providers changes. Refreshes the contents of
-     * menus that list VPN providers.
-     * @private
-     */
-    onVPNProvidersChanged_() {
-      // Refresh the contents of the VPN menu.
-      var index = this.indexOf('VPN');
-      if (index != undefined)
-        this.getListItemByIndex(index).refreshMenu();
-
-      // Refresh the contents of the "add connection" menu.
-      this.updateAddConnectionMenuEntries_();
-      index = this.indexOf('addConnection');
-      if (index != undefined)
-        this.getListItemByIndex(index).refreshMenu();
-    },
-
-    /**
-     * Updates the entries in the "add connection" menu, based on the VPN
-     * providers currently enabled in the primary user's profile.
-     * @private
-     */
-    updateAddConnectionMenuEntries_() {
-      var entries = [{
-        label: loadTimeData.getString('addConnectionWifi'),
-        command: createAddNonVPNConnectionCallback_('WiFi')
-      }];
-      entries = entries.concat(createAddVPNConnectionEntries_());
-      this.update({key: 'addConnection',
-                   iconType: 'add-connection',
-                   menu: entries
-                  });
-    },
-
-    /**
      * When the list loses focus, unselect all items in the list and close the
      * active menu.
      * @private
      */
     onBlur_: function() {
       this.selectionModel.unselectAll();
       closeMenu_();
     },
 
     /**
@@ skipping 334 matching lines @@
     for (var i = 0; i < networkList.length; i++) {
       var entry = networkList[i];
       if (entry.ConnectionState == 'Connected' ||
           entry.ConnectionState == 'Connecting')
         return entry;
     }
     return null;
   }
 
   /**
-   * Creates a callback function that adds a new connection of the given type.
-   * This method may be used for all network types except VPN.
+   * Create a callback function that adds a new connection of the given type.
    * @param {string} type An ONC network type
    * @return {function()} The created callback.
    * @private
    */
-  function createAddNonVPNConnectionCallback_(type) {
+  function createAddConnectionCallback_(type) {
     return function() {
       if (type == 'WiFi')
         sendChromeMetricsAction('Options_NetworkJoinOtherWifi');
-      chrome.send('addNonVPNConnection', [type]);
+      else if (type == 'VPN')
+        sendChromeMetricsAction('Options_NetworkJoinOtherVPN');
+      chrome.send('addConnection', [type]);
     };
   }
 
   /**
-   * Creates a callback function that shows the "add network" dialog for the
-   * built-in OpenVPN/L2TP VPN provider.
-   * @return {function()} The created callback.
-   * @private
-   */
-  function createVPNConnectionWithAddBuiltInProviderCallback_() {
-    return function() {
-      sendChromeMetricsAction('Options_NetworkAddVPNBuiltIn');
-      chrome.send('addVPNConnection');
-    };
-  }
-
-  /**
-   * Creates a callback function that asks the third-party VPN provider
-   * identified by |extensionID| to show its "add network" dialog.
-   * @param {string} providerID The VPN provider's extension ID.
-   * @return {function()} The created callback.
-   * @private
-   */
-  function createAddVPNConnectionWithThirdPartyProviderCallback_(extensionID) {
-    return function() {
-      sendChromeMetricsAction('Options_NetworkAddVPNThirdParty');
-      chrome.send('addVPNConnection', [extensionID]);
-    };
-  }
-
-  /**
-   * Generates an "add network" entry for each VPN provider currently enabled in
-   * the primary user's profile.
-   * @return {!Array<{label: string, command: function(), data: !Object}>} The
-   *     list of entries.
-   * @private
-   */
-  function createAddVPNConnectionEntries_() {
-    var entries = [];
-    var providers = options.VPNProviders.getProviders();
-    for (var i = 0; i < providers.length; ++i) {
-      entries.push({
-        label: loadTimeData.getStringF('addConnectionVPNTemplate',
-                                       providers[i].name),
-        command: providers[i].extensionID ?
-            createAddVPNConnectionWithThirdPartyProviderCallback_(
-                providers[i].extensionID) :
-            createVPNConnectionWithAddBuiltInProviderCallback_(),
-        data: {}
-      });
-    }
-    return entries;
-  }
-
-  /**
    * Whether the Network list is disabled. Only used for display purpose.
    */
   cr.defineProperty(NetworkList, 'disabled', cr.PropertyKind.BOOL_ATTR);
 
   // Export
   return {
     NetworkList: NetworkList
   };
 });