MD Settings: Internet: Allow Shared Proxies

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 38 matching lines @@
      * Whether or not to use the same manual proxy for all protocols.
      * @private
      */
     useSameProxy_: {
       type: Boolean,
       value: false,
       observer: 'useSameProxyChanged_',
     },
 
     /**
+     * Reflects prefs.settings.use_shared_proxies for data binding.
+     * @private
+     */
+    useSharedProxies_: Boolean,
+
+    /**
      * Array of proxy configuration types.
      * @private {!Array<string>}
      * @const
      */
     proxyTypes_: {
       type: Array,
       value: [
         CrOnc.ProxySettingsType.DIRECT,
         CrOnc.ProxySettingsType.PAC,
         CrOnc.ProxySettingsType.WPAD,
@@ skipping 12 matching lines @@
       value: {
         DIRECT: CrOnc.ProxySettingsType.DIRECT,
         PAC: CrOnc.ProxySettingsType.PAC,
         MANUAL: CrOnc.ProxySettingsType.MANUAL,
         WPAD: CrOnc.ProxySettingsType.WPAD,
       },
       readOnly: true,
     },
   },
 
+  observers: [
+    'useSharedProxiesChanged_(prefs.settings.use_shared_proxies.value)',
+  ],
+
   /**
    * Saved Manual properties so that switching to another type does not loose
    * any set properties while the UI is open.
    * @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.
    * @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() {
+    this.updateProxy_();
+  },
+
+  /** @private */
+  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_();
+      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} */ (
           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} */ (
@@ skipping 16 matching lines @@
         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) || '';
+
+    this.setProxyAsync_(proxy);
+  },
+
+  /**
+   * @param {!CrOnc.ProxySettings} proxy
+   * @private
+   */
+  setProxyAsync_: function(proxy) {
+    // Set this.proxy after dom-repeat has been stamped.
+    this.async(function() {
+      this.proxy = proxy;
+    }.bind(this));
   },
 
   /** @private */
   useSameProxyChanged_: function() {
     if (!this.receivedManualProxy_)
       return;
     this.sendProxyChange_();
   },
 
+  /** @private */
+  useSharedProxiesChanged_: function() {
+    let 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},
@@ skipping 93 matching lines @@
     if (proxyType == CrOnc.ProxySettingsType.MANUAL)
       return this.i18n('networkProxyTypeManual');
     if (proxyType == CrOnc.ProxySettingsType.PAC)
       return this.i18n('networkProxyTypePac');
     if (proxyType == CrOnc.ProxySettingsType.WPAD)
       return this.i18n('networkProxyTypeWpad');
     return this.i18n('networkProxyTypeDirect');
   },
 
   /**
+   * @return {!CrOnc.ManagedProperty|undefined}
+   * @private
+   */
+  getProxySettingsTypeProperty_: function() {
+    return /** @type {!CrOnc.ManagedProperty|undefined} */ (
+        this.get('ProxySettings.Type', this.networkProperties));
+  },
+
+  /**
    * @return {boolean}
    * @private
    */
   getShowNetworkPolicyIndicator_: function() {
-    let property = /** @type {!CrOnc.ManagedProperty|undefined}*/ (
-        this.get('ProxySettings.Type', this.networkProperties));
+    let property = this.getProxySettingsTypeProperty_();
     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));
+    let property = this.getProxySettingsTypeProperty_();
     return !!property && this.isExtensionControlled(property);
   },
 
   /**
+   * @param {!CrOnc.ManagedProperty} property
+   * @return {boolean}
+   * @private
+   */
+  getShowAllowShared_: function(property) {
+    return !this.isControlled(property) && this.isShared_();
+  },
+
+  /**
    * @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);
+        !this.isExtensionControlled(property) &&
+        (!this.isShared_() || this.useSharedProxies_);
   },
 
   /**
+   * @return {boolean}
+   * @private
+   */
+  isShared_: function() {
+    return this.networkProperties.Source == 'Device' ||
+        this.networkProperties.Source == 'DevicePolicy';
+  },
+
+  /**
    * 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));
+    let property = this.getProxySettingsTypeProperty_();
     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;
-  }
+  },
+
+  /**
+   * Handles the change event for the shared proxy checkbox. Shows a
+   * confirmation dialog.
+   * @param {Event} event
+   * @private
+   */
+  onAllowSharedProxiesChange_: function(event) {
+    this.$.confirmAllowSharedDialog.showModal();
+  },
+
+  /**
+   * Handles the shared proxy confirmation dialog 'Confirm' button.
+   * @private
+   */
+  onAllowSharedDialogConfirm_: function() {
+    /** @type {!SettingsCheckboxElement} */ (this.$.allowShared)
+        .sendPrefChange();
+    this.$.confirmAllowSharedDialog.close();
+  },
+
+  /**
+   * Handles the shared proxy confirmation dialog 'Cancel' button or a cancel
+   * event.
+   * @private
+   */
+  onAllowSharedDialogCancel_: function() {
+    /** @type {!SettingsCheckboxElement} */ (this.$.allowShared)
+        .resetToPrefValue();
+    this.$.confirmAllowSharedDialog.close();
+  },
 });