MD Settings: Internet: Cleanup JS

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',
 
   behaviors: [CrPolicyNetworkBehavior],
 
   properties: {
     /**
      * The network properties dictionary containing the proxy properties to
      * display and modify.
      * @type {!CrOnc.NetworkProperties|undefined}
      */
     networkProperties: {
       type: Object,
       observer: 'networkPropertiesChanged_',
     },
 
-    /**
-     * Whether or not the proxy values can be edited.
-     */
+    /** Whether or not the proxy values can be edited. */
     editable: {
       type: Boolean,
       value: false,
     },
 
     /**
      * UI visible / edited proxy configuration.
      * @type {!CrOnc.ProxySettings}
      */
     proxy: {
       type: Object,
       value: function() {
         return this.createDefaultProxySettings_();
       },
     },
 
-    /**
-     * The Web Proxy Auto Discovery URL extracted from networkProperties.
-     */
+    /** The Web Proxy Auto Discovery URL extracted from networkProperties. */
     WPAD: {
       type: String,
       value: '',
     },
 
     /**
-     * Whetner or not to use the same manual proxy for all protocols.
+     * Whether or not to use the same manual proxy for all protocols.
+     * @private
      */
-    useSameProxy: {
+    useSameProxy_: {
       type: Boolean,
       value: false,
       observer: 'useSameProxyChanged_',
     },
 
     /**
      * Array of proxy configuration types.
-     * @type {!Array<string>}
+     * @private {!Array<string>}
      * @const
      */
     proxyTypes_: {
       type: Array,
       value: [
         CrOnc.ProxySettingsType.DIRECT,
         CrOnc.ProxySettingsType.PAC,
         CrOnc.ProxySettingsType.WPAD,
         CrOnc.ProxySettingsType.MANUAL,
       ],
       readOnly: true
     },
 
     /**
      * Object providing proxy type values for data binding.
-     * @type {!Object}
+     * @private {!Object}
      * @const
      */
-    ProxySettingsType: {
+    ProxySettingsType_: {
       type: Object,
       value: {
         DIRECT: CrOnc.ProxySettingsType.DIRECT,
         PAC: CrOnc.ProxySettingsType.PAC,
         MANUAL: CrOnc.ProxySettingsType.MANUAL,
         WPAD: CrOnc.ProxySettingsType.WPAD,
       },
       readOnly: true,
     },
   },
 
   /**
    * Saved Manual properties so that switching to another type does not loose
    * any set properties while the UI is open.
-   * @type {!CrOnc.ManualProxySettings|undefined}
+   * @private {!CrOnc.ManualProxySettings|undefined}
    */
   savedManual_: undefined,
 
   /**
    * Saved ExcludeDomains properties so that switching to a non-Manual type does
    * not loose any set exclusions while the UI is open.
-   * @type {!Array<string>|undefined}
+   * @private {!Array<string>|undefined}
    */
   savedExcludeDomains_: undefined,
 
   /**
    * Polymer networkProperties changed method.
    */
   networkPropertiesChanged_: function() {
     if (!this.networkProperties)
       return;
 
@@ skipping 62 matching lines @@
   /**
    * Called when the proxy changes in the UI.
    */
   sendProxyChange_: function() {
     if (this.proxy.Type == CrOnc.ProxySettingsType.MANUAL) {
       var proxy =
           /** @type {!CrOnc.ProxySettings} */ (Object.assign({}, this.proxy));
       var defaultProxy = proxy.Manual.HTTPProxy;
       if (!defaultProxy || !defaultProxy.Host)
         return;
-      if (this.useSameProxy || !proxy.Manual.SecureHTTPProxy) {
+      if (this.useSameProxy_ || !proxy.Manual.SecureHTTPProxy) {
         proxy.Manual.SecureHTTPProxy = /** @type {!CrOnc.ProxyLocation} */ (
             Object.assign({}, defaultProxy));
       }
-      if (this.useSameProxy || !proxy.Manual.FTPProxy) {
+      if (this.useSameProxy_ || !proxy.Manual.FTPProxy) {
         proxy.Manual.FTPProxy = /** @type {!CrOnc.ProxyLocation} */ (
             Object.assign({}, defaultProxy));
       }
-      if (this.useSameProxy || !proxy.Manual.SOCKS) {
+      if (this.useSameProxy_ || !proxy.Manual.SOCKS) {
         proxy.Manual.SOCKS = /** @type {!CrOnc.ProxyLocation} */ (
             Object.assign({}, defaultProxy));
       }
       this.savedManual_ = Object.assign({}, proxy.Manual);
       this.savedExcludeDomains_ = proxy.ExcludeDomains;
       this.proxy = proxy;
     } else if (this.proxy.Type == CrOnc.ProxySettingsType.PAC) {
       if (!this.proxy.PAC)
         return;
     }
@@ skipping 79 matching lines @@
   /**
    * @param {string} property The property to test
    * @param {string} value The value to test against
    * @return {boolean} True if property == value
    * @private
    */
   matches_: function(property, value) {
     return property == value;
   }
 });