MD Settings: Eliminate use of ES6 for Chrome OS

chrome/browser/resources/settings/internet_page/network_proxy.js

 // Copyright 2015 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.
 
 /**
  * @fileoverview Polymer element for displaying and editing network proxy
  * values.
  */
 Polymer({
   is: 'network-proxy',
@@ skipping 135 matching lines @@
   updateProxy_: function() {
     if (!this.networkProperties)
       return;
 
     /** @type {!CrOnc.ProxySettings} */
     var proxy = this.createDefaultProxySettings_();
 
     // For shared networks with unmanaged proxy settings, ignore any saved
     // proxy settings (use the default values).
     if (this.isShared_()) {
-      let property = this.getProxySettingsTypeProperty_();
+      var property = this.getProxySettingsTypeProperty_();
       if (!this.isControlled(property) && !this.useSharedProxies_) {
         this.setProxyAsync_(proxy);
         return;  // Proxy settings will be ignored.
       }
     }
 
     /** @type {!chrome.networkingPrivate.ManagedProxySettings|undefined} */
     var proxySettings = this.networkProperties.ProxySettings;
     if (proxySettings) {
       proxy.Type = /** @type {!CrOnc.ProxySettingsType} */ (
@@ skipping 10 matching lines @@
             proxy.Manual.HTTPProxy;
         proxy.Manual.FTPProxy =
             /** @type {!CrOnc.ProxyLocation|undefined} */ (
                 CrOnc.getSimpleActiveProperties(
                     proxySettings.Manual.FTPProxy)) ||
             proxy.Manual.HTTPProxy;
         proxy.Manual.SOCKS =
             /** @type {!CrOnc.ProxyLocation|undefined} */ (
                 CrOnc.getSimpleActiveProperties(proxySettings.Manual.SOCKS)) ||
             proxy.Manual.HTTPProxy;
-        let json_http = JSON.stringify(proxy.Manual.HTTPProxy);
+        var jsonHttp = JSON.stringify(proxy.Manual.HTTPProxy);
         this.useSameProxy_ =
-            json_http == JSON.stringify(proxy.Manual.SecureHTTPProxy) &&
-            json_http == JSON.stringify(proxy.Manual.FTPProxy) &&
-            json_http == JSON.stringify(proxy.Manual.SOCKS);
+            jsonHttp == JSON.stringify(proxy.Manual.SecureHTTPProxy) &&

[dpapad, 2017/01/23 19:12:54]

FWIW: There are no guarantees that JSON.stringify() serializes properties in a
deterministic order, so comparisons like this are a bit fragile.

From the documenatation, "Properties of non-array objects are not guaranteed to
be stringified in any particular order", see
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Obje....

[stevenjb, 2017/01/24 02:02:04]

I'm pretty sure that in this context JSON.stringify will be consistent, but it's
not exactly optimal anyway; done.

+            jsonHttp == JSON.stringify(proxy.Manual.FTPProxy) &&
+            jsonHttp == JSON.stringify(proxy.Manual.SOCKS);
       }
       if (proxySettings.ExcludeDomains) {
         proxy.ExcludeDomains = /** @type {!Array<string>|undefined} */ (
             CrOnc.getActiveValue(proxySettings.ExcludeDomains));
       }
       proxy.PAC = /** @type {string|undefined} */ (
           CrOnc.getActiveValue(proxySettings.PAC));
     }
     // Use saved ExcludeDomanains and Manual if not defined.
     proxy.ExcludeDomains = proxy.ExcludeDomains || this.savedExcludeDomains_;
@@ skipping 19 matching lines @@
     }.bind(this));
   },
 
   /** @private */
   useSameProxyChanged_: function() {
     this.proxyModified_ = true;
   },
 
   /** @private */
   useSharedProxiesChanged_: function() {
-    let pref = this.getPref('settings.use_shared_proxies');
+    var pref = this.getPref('settings.use_shared_proxies');
     this.useSharedProxies_ = !!pref && !!pref.value;
     this.updateProxy_();
   },
 
   /**
    * @return {CrOnc.ProxySettings} An empty/default proxy settings object.
    * @private
    */
   createDefaultProxySettings_: function() {
     return {
       Type: CrOnc.ProxySettingsType.DIRECT,
       ExcludeDomains: [],
       Manual: {
         HTTPProxy: {Host: '', Port: 80},
         SecureHTTPProxy: {Host: '', Port: 80},
         FTPProxy: {Host: '', Port: 80},
         SOCKS: {Host: '', Port: 1080}
       },
       PAC: ''
     };
   },
 
   /**
    * Called when the proxy changes in the UI.
    * @private
    */
   sendProxyChange_: function() {
     if (this.proxy_.Type == CrOnc.ProxySettingsType.MANUAL) {
-      let proxy =
+      var proxy =
           /** @type {!CrOnc.ProxySettings} */ (Object.assign({}, this.proxy_));
-      let manual = proxy.Manual;
-      let defaultProxy = manual.HTTPProxy;
+      var manual = proxy.Manual;
+      var defaultProxy = manual.HTTPProxy;
       if (!defaultProxy || !defaultProxy.Host)
         return;
       if (this.useSameProxy_ || !this.get('SecureHTTPProxy.Host', manual)) {
         proxy.Manual.SecureHTTPProxy = /** @type {!CrOnc.ProxyLocation} */ (
             Object.assign({}, defaultProxy));
       }
       if (this.useSameProxy_ || !this.get('FTPProxy.Host', manual)) {
         proxy.Manual.FTPProxy = /** @type {!CrOnc.ProxyLocation} */ (
             Object.assign({}, defaultProxy));
       }
@@ skipping 11 matching lines @@
     this.fire('proxy-change', {field: 'ProxySettings', value: this.proxy_});
     this.proxyModified_ = false;
   },
 
   /**
    * Event triggered when the selected proxy type changes.
    * @param {!Event} event
    * @private
    */
   onTypeChange_: function(event) {
-    let target = /** @type {!HTMLSelectElement} */ (event.target);
+    var target = /** @type {!HTMLSelectElement} */ (event.target);
     var type = /** @type {chrome.networkingPrivate.ProxySettingsType} */ (
         target.value);
     this.set('proxy_.Type', type);
     if (type == CrOnc.ProxySettingsType.MANUAL)
       this.proxyModified_ = true;
     else
       this.sendProxyChange_();
   },
 
   /** @private */
@@ skipping 57 matching lines @@
   getProxySettingsTypeProperty_: function() {
     return /** @type {!CrOnc.ManagedProperty|undefined} */ (
         this.get('ProxySettings.Type', this.networkProperties));
   },
 
   /**
    * @return {boolean}
    * @private
    */
   shouldShowNetworkPolicyIndicator_: function() {
-    let property = this.getProxySettingsTypeProperty_();
+    var property = this.getProxySettingsTypeProperty_();
     return !!property && !this.isExtensionControlled(property) &&
         this.isNetworkPolicyEnforced(property);
   },
 
   /**
    * @return {boolean}
    * @private
    */
   shouldShowExtensionIndicator_: function() {
-    let property = this.getProxySettingsTypeProperty_();
+    var property = this.getProxySettingsTypeProperty_();
     return !!property && this.isExtensionControlled(property);
   },
 
   /**
    * @param {!CrOnc.ManagedProperty} property
    * @return {boolean}
    * @private
    */
   shouldShowAllowShared_: function(property) {
     return !this.isControlled(property) && this.isShared_();
   },
 
   /**
    * @param {string} propertyName
    * @return {boolean} Whether the named property setting is editable.
    * @private
    */
   isEditable_: function(propertyName) {
     if (!this.editable || (this.isShared_() && !this.useSharedProxies_))
       return false;
     if (!this.networkProperties.hasOwnProperty('ProxySettings'))
       return true;  // No proxy settings defined, so not enforced.
-    let property = /** @type {!CrOnc.ManagedProperty|undefined} */ (
+    var property = /** @type {!CrOnc.ManagedProperty|undefined} */ (
         this.get('ProxySettings.' + propertyName, this.networkProperties));
     if (!property)
       return true;
     return this.isPropertyEditable_(property);
   },
 
   /**
    * @param {!CrOnc.ManagedProperty|undefined} property
    * @return {boolean} Whether |property| is editable.
    * @private
@@ skipping 56 matching lines @@
    * Handles the shared proxy confirmation dialog 'Cancel' button or a cancel
    * event.
    * @private
    */
   onAllowSharedDialogCancel_: function() {
     /** @type {!SettingsCheckboxElement} */ (this.$.allowShared)
         .resetToPrefValue();
     this.$.confirmAllowSharedDialog.close();
   },
 });