MD Settings: Eliminate use of ES6 for Chrome OS

chrome/browser/resources/settings/internet_page/internet_detail_page.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
  * 'settings-internet-detail' is the settings subpage containing details
  * for a network.
  */
 (function() {
@@ skipping 139 matching lines @@
             this.networksChangedListener_);
         this.networksChangedListener_ = null;
       }
       return;
     }
     if (!this.networksChangedListener_) {
       this.networksChangedListener_ = this.onNetworksChangedEvent_.bind(this);
       this.networkingPrivate.onNetworksChanged.addListener(
           this.networksChangedListener_);
     }
-    let queryParams = settings.getQueryParameters();
+    var queryParams = settings.getQueryParameters();
     this.guid = queryParams.get('guid') || '';
     if (!this.guid) {
       console.error('No guid specified for page:' + route);
       this.close_();
     }
     this.getNetworkDetails_();
   },
 
   /** @private */
   close_: function() {
@@ skipping 404 matching lines @@
           /** @type {chrome.networkingPrivate.IPConfigType|undefined} */ (
               CrOnc.getActiveValue(
                   this.networkProperties.NameServersConfigType));
       var newNsConfigType =
           /** @type {chrome.networkingPrivate.IPConfigType} */ (value);
       if (newNsConfigType == nsConfigType)
         return;
       onc.NameServersConfigType = newNsConfigType;
     } else if (field == 'StaticIPConfig') {
       if (ipConfigType == CrOnc.IPConfigType.STATIC) {
-        let staticIpConfig = this.networkProperties.StaticIPConfig;
-        let ipConfigValue = /** @type {!Object} */ (value);
+        var staticIpConfig = this.networkProperties.StaticIPConfig;
+        var ipConfigValue = /** @type {!Object} */ (value);
         if (staticIpConfig &&
             this.allPropertiesMatch_(staticIpConfig, ipConfigValue)) {
           return;
         }
       }
       onc.IPAddressConfigType = CrOnc.IPConfigType.STATIC;
       if (!onc.StaticIPConfig) {
         onc.StaticIPConfig =
             /** @type {!chrome.networkingPrivate.IPConfigProperties} */ ({});
       }
-      for (let key in value)
+      for (var key in value)
         onc.StaticIPConfig[key] = value[key];
     } else if (field == 'NameServers') {
       // If a StaticIPConfig property is specified and its NameServers value
       // matches the new value, no need to set anything.
-      let nameServers = /** @type {!Array<string>} */ (value);
+      var nameServers = /** @type {!Array<string>} */ (value);
       if (onc.NameServersConfigType == CrOnc.IPConfigType.STATIC &&
           onc.StaticIPConfig && onc.StaticIPConfig.NameServers == nameServers) {
         return;
       }
       onc.NameServersConfigType = CrOnc.IPConfigType.STATIC;
       if (!onc.StaticIPConfig) {
         onc.StaticIPConfig =
             /** @type {!chrome.networkingPrivate.IPConfigProperties} */ ({});
       }
       onc.StaticIPConfig.NameServers = nameServers;
@@ skipping 80 matching lines @@
     // networkProperties.Type == CrOnc.Type.ETHERNET.
     return this.isRemembered_(networkProperties);
   },
 
   /**
    * @param {!Array<string>} fields
    * @return {boolean}
    * @private
    */
   hasVisibleFields_: function(fields) {
-    for (let key of fields) {
-      let value = this.get(key, this.networkProperties);
+    for (var f = 0; f < fields.length; ++f) {
+      var value = this.get(fields[f], this.networkProperties);
       if (value !== undefined && value !== '')
         return true;
     }
     return false;
   },
 
   /**
    * @return {boolean}
    * @private
    */
   hasInfoFields_: function() {
     return this.hasVisibleFields_(this.getInfoFields_());
   },
 
   /**
    * @return {!Array<string>} The fields to display in the info section.
    * @private
    */
   getInfoFields_: function() {
     /** @type {!Array<string>} */ var fields = [];
     if (this.networkProperties.Type == CrOnc.Type.CELLULAR) {
       fields.push(
           'Cellular.ActivationState', 'Cellular.RoamingState',
           'RestrictedConnectivity', 'Cellular.ServingOperator.Name');
     }
     if (this.networkProperties.Type == CrOnc.Type.VPN) {
-      let vpnType = CrOnc.getActiveValue(this.networkProperties.VPN.Type);
+      var vpnType = CrOnc.getActiveValue(this.networkProperties.VPN.Type);
       if (vpnType == 'ThirdPartyVPN') {
         fields.push('VPN.ThirdPartyVPN.ProviderName');
       } else {
         fields.push('VPN.Host', 'VPN.Type');
         if (vpnType == 'OpenVPN')
           fields.push('VPN.OpenVPN.Username');
         else if (vpnType == 'L2TP-IPsec')
           fields.push('VPN.L2TP.Username');
       }
     }
@@ skipping 116 matching lines @@
   /**
    * @param {!Object} curValue
    * @param {!Object} newValue
    * @return {boolean} True if all properties set in |newValue| are equal to
    *     the corresponding properties in |curValue|. Note: Not all properties
    *     of |curValue| need to be specified in |newValue| for this to return
    *     true.
    * @private
    */
   allPropertiesMatch_: function(curValue, newValue) {
-    for (let key in newValue) {
+    for (var key in newValue) {
       if (newValue[key] != curValue[key])
         return false;
     }
     return true;
   }
 });
 })();