Settings: Internet: Update proxy controlled indicator and fields.

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],
+  behaviors: [CrPolicyNetworkBehavior, I18nBehavior, PrefsBehavior],
 
   properties: {
     /**
      * The network properties dictionary containing the proxy properties to
      * display and modify.
      * @type {!CrOnc.NetworkProperties|undefined}
      */
     networkProperties: {
       type: Object,
       observer: 'networkPropertiesChanged_',
@@ skipping 72 matching lines @@
    */
   savedManual_: undefined,
 
   /**
    * Saved ExcludeDomains properties so that switching to a non-Manual type does
    * not loose any set exclusions while the UI is open.
    * @private {!Array<string>|undefined}
    */
   savedExcludeDomains_: undefined,
 
+  /**
+   * Set to true the first time we receive a manual proxy. Used to set the
+   * initial |useSameProxy_| value.
+   * @private {boolean}
+   */
+  receivedManualProxy_: false,
+
   /** @private */
   networkPropertiesChanged_: function() {
     if (!this.networkProperties)
       return;
 
     /** @type {!CrOnc.ProxySettings} */
     var proxy = this.createDefaultProxySettings_();
     /** @type {!chrome.networkingPrivate.ManagedProxySettings|undefined} */
     var proxySettings = this.networkProperties.ProxySettings;
     if (proxySettings) {
       proxy.Type = /** @type {!CrOnc.ProxySettingsType} */ (
           CrOnc.getActiveValue(proxySettings.Type));
       if (proxySettings.Manual) {
         proxy.Manual.HTTPProxy = /** @type {!CrOnc.ProxyLocation|undefined} */ (
             CrOnc.getSimpleActiveProperties(proxySettings.Manual.HTTPProxy));
         proxy.Manual.SecureHTTPProxy =
             /** @type {!CrOnc.ProxyLocation|undefined} */ (
                 CrOnc.getSimpleActiveProperties(
                     proxySettings.Manual.SecureHTTPProxy));
         proxy.Manual.FTPProxy = /** @type {!CrOnc.ProxyLocation|undefined} */ (
             CrOnc.getSimpleActiveProperties(proxySettings.Manual.FTPProxy));
         proxy.Manual.SOCKS = /** @type {!CrOnc.ProxyLocation|undefined} */ (
             CrOnc.getSimpleActiveProperties(proxySettings.Manual.SOCKS));
+        if (!this.receivedManualProxy_) {
+          let json_http = 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);
+          this.receivedManualProxy_ = true;
+        }
       }
       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_;
     proxy.Manual = proxy.Manual || this.savedManual_;
 
     // Set this.proxy after dom-repeat has been stamped.
     this.async(function() {
       this.proxy = proxy;
     }.bind(this));
 
     // Set the Web Proxy Auto Discovery URL.
     var ipv4 =
         CrOnc.getIPConfigForType(this.networkProperties, CrOnc.IPType.IPV4);
     this.WPAD = (ipv4 && ipv4.WebProxyAutoDiscoveryUrl) || '';
   },
 
   /** @private */
   useSameProxyChanged_: function() {
+    if (!this.receivedManualProxy_)
+      return;
     this.sendProxyChange_();
   },
 
   /**
    * @return {CrOnc.ProxySettings} An empty/default proxy settings object.
    * @private
    */
   createDefaultProxySettings_: function() {
     return {
       Type: CrOnc.ProxySettingsType.DIRECT,
@@ skipping 85 matching lines @@
    */
   onProxyExclusionsChange_: function(event) {
     this.sendProxyChange_();
   },
 
   /**
    * @param {string} proxyType The proxy type.
    * @return {string} The description for |proxyType|.
    * @private
    */
-  proxyTypeDesc_: function(proxyType) {
-    // TODO(stevenjb): Translate.
+  getProxyTypeDesc_: function(proxyType) {
     if (proxyType == CrOnc.ProxySettingsType.MANUAL)
-      return 'Manual proxy configuration';
+      return this.i18n('networkProxyTypeManual');
     if (proxyType == CrOnc.ProxySettingsType.PAC)
-      return 'Automatic proxy configuration';
+      return this.i18n('networkProxyTypePac');
     if (proxyType == CrOnc.ProxySettingsType.WPAD)
-      return 'Web proxy autodiscovery';
-    return 'Direct Internet connection';
+      return this.i18n('networkProxyTypeWpad');
+    return this.i18n('networkProxyTypeDirect');
   },
 
   /**
-   * @param {boolean} editable
-   * @param {!CrOnc.NetworkProperties} networkProperties
-   * @param {string} key
-   * @return {boolean} Whether the property is editable.
+   * @return {boolean}
    * @private
    */
-  isPropertyEditable_: function(editable, networkProperties, key) {
-    if (!editable)
-      return false;
-    var property = /** @type {!CrOnc.ManagedProperty|undefined} */ (
-        this.get(key, networkProperties));
-    return !this.isNetworkPolicyEnforced(property);
+  getShowNetworkPolicyIndicator_: function() {
+    let property = /** @type {!CrOnc.ManagedProperty|undefined}*/ (
+        this.get('ProxySettings.Type', this.networkProperties));
+    return !!property && !this.isExtensionControlled(property) &&
+        this.isNetworkPolicyEnforced(property);
   },
 
   /**
+   * @return {boolean}
+   * @private
+   */
+  getShowPrefPolicyIndicator_: function() {
+    let property = /** @type {!CrOnc.ManagedProperty|undefined}*/ (
+        this.get('ProxySettings.Type', this.networkProperties));
+    return !!property && this.isExtensionControlled(property);
+  },
+
+  /**
+   * @param {!CrOnc.ManagedProperty|undefined} property
+   * @return {boolean} Whether the property setting is enforced.
+   * @private
+   */
+  isEditable_: function(property) {
+    return this.editable && !this.isNetworkPolicyEnforced(property) &&
+        !this.isExtensionControlled(property);
+  },
+
+  /**
+   * Used to check the editable state for proxy related UI that may or may
+   * not be directly controlled by a policy. We use the enforced state of the
+   * 'ProxySettings.Type' property for these controls.
+   * @return {boolean} Whether the proxy control is editable.
+   * @private
+   */
+  isProxyEditable_: function() {
+    let property = /** @type {!CrOnc.ManagedProperty|undefined}*/ (
+        this.get('ProxySettings.Type', this.networkProperties));
+    return !!property && this.isEditable_(property);
+  },
+
+  /**
    * @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;
   }
 });