Add ManagedProperties to networking_private.idl

This adds types for neworkingPrivate.getManagedProperties.
It also updates settings/internet_page to use getManagedProperties
and the correct types.

BUG=535270
For third_party/closure_compiler/externs/networking_private.js:
TBR=dbeam@chromium.org

Review URL: https://codereview.chromium.org/1376523003

Cr-Commit-Position: refs/heads/master@{#351890}

10 files changed, 978 insertions, 161 deletions

diff --git a/chrome/browser/resources/settings/internet_page/internet_detail_page.html b/chrome/browser/resources/settings/internet_page/internet_detail_page.html
index 21e95a5..9cd13af 100644
--- a/chrome/browser/resources/settings/internet_page/internet_detail_page.html
+++ b/chrome/browser/resources/settings/internet_page/internet_detail_page.html
@@ -118,7 +118,6 @@
                   <network-apnlist editable
                       hidden$="[[!isType_(networkProperties, NetworkType.CELLULAR)]]"
                       network-properties="[[networkProperties]]"
-                      apnlist="[[networkProperties.Cellular.APNList]]"
                       on-apn-change="onNetworkPropertyChange_">
                   </network-apnlist>
                   <network-ip-config editable
diff --git a/chrome/browser/resources/settings/internet_page/internet_detail_page.js b/chrome/browser/resources/settings/internet_page/internet_detail_page.js
index f2bb1bb16..8fa56e8 100644
--- a/chrome/browser/resources/settings/internet_page/internet_detail_page.js
+++ b/chrome/browser/resources/settings/internet_page/internet_detail_page.js
@@ -117,14 +117,14 @@ Polymer({
       return;
 
     // Update autoConnect if it has changed. Default value is false.
-    var autoConnect = /** @type {boolean} */(
-        CrOnc.getActiveTypeValue(this.networkProperties, 'AutoConnect')) ||
-            false;
+    var autoConnect = CrOnc.getAutoConnect(this.networkProperties);
     if (autoConnect != this.autoConnect)
       this.autoConnect = autoConnect;
 
     // Update preferNetwork if it has changed. Default value is false.
-    var preferNetwork = this.networkProperties.Priority > 0;
+    var priority = /** @type {number} */(CrOnc.getActiveValue(
+        this.networkProperties.Priority) || 0);
+    var preferNetwork = priority > 0;
     if (preferNetwork != this.preferNetwork)
       this.preferNetwork = preferNetwork;
 
@@ -173,7 +173,7 @@ Polymer({
   getNetworkDetails_: function() {
     if (!this.guid)
       return;
-    chrome.networkingPrivate.getProperties(
+    chrome.networkingPrivate.getManagedProperties(
         this.guid, this.getPropertiesCallback_.bind(this));
   },
 
@@ -224,7 +224,8 @@ Polymer({
    * @private
    */
   getStateName_: function(properties) {
-    return (properties && properties.Name) || '';
+    return /** @type {string} */(CrOnc.getActiveValue(
+      this.networkProperties.Name) || '');
   },
 
   /**
@@ -295,13 +296,12 @@ Polymer({
 
     // Only show for connected networks or LTE networks with a valid MDN.
     if (!this.isConnectedState_(properties)) {
-      var technology = /** @type {CrOnc.NetworkTechnology|undefined} */(
-          CrOnc.getActiveValue(properties.Cellular.NetworkTechnology));
+      var technology = properties.Cellular.NetworkTechnology;
       if (technology != CrOnc.NetworkTechnology.LTE &&
           technology != CrOnc.NetworkTechnology.LTE_ADVANCED) {
         return false;
       }
-      if (!CrOnc.getActiveValue(properties.Cellular.MDN))
+      if (!properties.Cellular.MDN)
         return false;
     }
 
@@ -658,7 +658,7 @@ Polymer({
   showCellularSim_: function(properties) {
     if (!properties || properties.Type != 'Cellular' || !properties.Cellular)
       return false;
-    return CrOnc.getActiveValue(properties.Cellular.Family) == 'GSM';
+    return properties.Cellular.Family == 'GSM';
   },
 
   /**
diff --git a/chrome/browser/resources/settings/internet_page/network_apnlist.js b/chrome/browser/resources/settings/internet_page/network_apnlist.js
index 71a2adf..e95ff7d 100644
--- a/chrome/browser/resources/settings/internet_page/network_apnlist.js
+++ b/chrome/browser/resources/settings/internet_page/network_apnlist.js
@@ -87,12 +87,16 @@ Polymer({
     if (!this.networkProperties || !this.networkProperties.Cellular)
       return;
 
-    var activeApn;
+    /** @type {!CrOnc.APNProperties|undefined} */ var activeApn;
     var cellular = this.networkProperties.Cellular;
-    if (cellular.APN && cellular.APN.AccessPointName)
-      activeApn = cellular.APN;
-    else if (cellular.LastGoodAPN && cellular.LastGoodAPN.AccessPointName)
+    /** @type {!chrome.networkingPrivate.ManagedAPNProperties|undefined} */ var
+        apn = cellular.APN;
+    if (apn && apn.AccessPointName) {
+      activeApn = /** @type {!CrOnc.APNProperties|undefined} */(
+          CrOnc.getSimpleActiveProperties(apn));
+    } else if (cellular.LastGoodAPN && cellular.LastGoodAPN.AccessPointName) {
       activeApn = cellular.LastGoodAPN;
+    }
     this.setApnSelectList_(activeApn);
   },
 
@@ -158,7 +162,12 @@ Polymer({
   getApnList_: function() {
     if (!this.networkProperties || !this.networkProperties.Cellular)
       return [];
-    return this.networkProperties.Cellular.APNList || [];
+    /** @type {!chrome.networkingPrivate.ManagedAPNList|undefined} */ var
+        apnlist = this.networkProperties.Cellular.APNList;
+    if (!apnlist)
+      return [];
+    return /** @type {!Array<!CrOnc.APNProperties>} */ (
+        CrOnc.getActiveValue(apnlist));
   },
 
   /**
diff --git a/chrome/browser/resources/settings/internet_page/network_property_list.js b/chrome/browser/resources/settings/internet_page/network_property_list.js
index 1483895..87b64216 100644
--- a/chrome/browser/resources/settings/internet_page/network_property_list.js
+++ b/chrome/browser/resources/settings/internet_page/network_property_list.js
@@ -60,7 +60,8 @@ Polymer({
     var curValue = this.get(field, this.propertyDict);
     if (typeof curValue == 'object') {
       // Extract the property from an ONC managed dictionary.
-      curValue = CrOnc.getActiveValue(/** @type {!Object} */(curValue));
+      curValue =
+          CrOnc.getActiveValue(/** @type {!CrOnc.ManagedProperty} */(curValue));
     }
     var newValue = event.target.value;
     if (newValue == curValue)
@@ -145,7 +146,8 @@ Polymer({
       return '';
     if (typeof value == 'object') {
       // Extract the property from an ONC managed dictionary
-      value = CrOnc.getActiveValue(/** @type {!Object} */(value));
+      value =
+          CrOnc.getActiveValue(/** @type {!CrOnc.ManagedProperty} */(value));
     }
     // TODO(stevenjb): Localize.
     if (typeof value == 'number' || typeof value == 'boolean')
diff --git a/chrome/browser/resources/settings/internet_page/network_proxy.js b/chrome/browser/resources/settings/internet_page/network_proxy.js
index fc6ff4c..110eb42a 100644
--- a/chrome/browser/resources/settings/internet_page/network_proxy.js
+++ b/chrome/browser/resources/settings/internet_page/network_proxy.js
@@ -108,23 +108,35 @@ Polymer({
     if (!this.networkProperties)
       return;
 
-    var defaultProxy = this.createDefaultProxySettings_();
-    var proxy = this.networkProperties.ProxySettings || {};
-
-    // Ensure that all proxy settings object properties are specified.
-    proxy.ExcludeDomains = proxy.ExcludeDomains || this.savedExcludeDomains_ ||
-                           defaultProxy.ExcludeDomains;
-    proxy.Manual = proxy.Manual || this.savedManual_ ||
-        /** @type {CrOnc.ManualProxySettings} */({});
-    proxy.Manual.HTTPProxy =
-        proxy.Manual.HTTPProxy || defaultProxy.Manual.HTTPProxy;
-    proxy.Manual.SecureHTTPProxy =
-        proxy.Manual.SecureHTTPProxy || defaultProxy.Manual.SecureHTTPProxy;
-    proxy.Manual.FTPProxy =
-        proxy.Manual.FTPProxy || defaultProxy.Manual.FTPProxy;
-    proxy.Manual.SOCKS = proxy.Manual.SOCKS || defaultProxy.Manual.SOCKS;
-    proxy.PAC = proxy.PAC || defaultProxy.PAC;
-    proxy.Type = proxy.Type || defaultProxy.Type;
+    /** @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 (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_;
 
     this.set('proxy', proxy);
     this.$.selectType.value = proxy.Type;
diff --git a/components/onc/docs/onc_spec.html b/components/onc/docs/onc_spec.html
index df43eb8..c28053f 100644
--- a/components/onc/docs/onc_spec.html
+++ b/components/onc/docs/onc_spec.html
@@ -2156,7 +2156,7 @@
 
     <dt class="field">APNList</dt>
     <dd>
-      <span class="field_meta">(optional, read-only)
+      <span class="field_meta">(optional)
         <span class="type">array of APN</span>
       </span>
       List of available APN configurations.
diff --git a/extensions/common/api/networking_private.idl b/extensions/common/api/networking_private.idl
index 64ef51e..ea77c3c 100644
--- a/extensions/common/api/networking_private.idl
+++ b/extensions/common/api/networking_private.idl
@@ -43,7 +43,7 @@ namespace networkingPrivate {
   enum DeviceStateType {
     // Device is available but not initialized.
     Uninitialized,
-    // Device is intialized but not enabled.
+    // Device is initialized but not enabled.
     Disabled,
     // Enabled state has been requested but has not completed.
     Enabling,
@@ -63,6 +63,93 @@ namespace networkingPrivate {
     Direct, Manual, PAC, WPAD
   };
 
+  // Managed property types. These types all share a common structure:
+  // Active: For properties that are translated from the configuration
+  //     manager (e.g. Shill), the 'active' value currently in use by the
+  //     configuration manager.
+  // Effective: The effective source for the property: UserPolicy, DevicePolicy,
+  //     UserSetting or SharedSetting.
+  // UserPolicy: The value provided by the user policy.
+  // DevicePolicy: The value provided by the device policy.
+  // UserSetting: The value set by the logged in user. Only provided if
+  //     UserEditable is true (i.e. no policy affects the property or the
+  //     policy provided value is recommened only).
+  // SharedSetting: The value set for all users of the device. Only provided if
+  //     DeviceEditiable is true (i.e. no policy affects the property or the
+  //     policy provided value is recommened only).
+  // UserEditable: True if the UserPolicy allows the property to be edited
+  //     (i.e. is a recommended value). Defaults to True.
+  // DeviceEditable: True if the DevicePolicy allows the property to be
+  //     edited (i.e. is a recommended value). Defaults to True.
+
+  dictionary ManagedBoolean {
+    boolean? Active;
+    DOMString? Effective;
+    boolean? UserPolicy;
+    boolean? DevicePolicy;
+    boolean? UserSetting;
+    boolean? SharedSetting;
+    boolean? UserEditable;
+    boolean? DeviceEditable;
+  };
+
+  dictionary ManagedLong {
+    long? Active;
+    DOMString? Effective;
+    long? UserPolicy;
+    long? DevicePolicy;
+    long? UserSetting;
+    long? SharedSetting;
+    boolean? UserEditable;
+    boolean? DeviceEditable;
+  };
+
+  dictionary ManagedDOMString {
+    DOMString? Active;
+    DOMString? Effective;
+    DOMString? UserPolicy;
+    DOMString? DevicePolicy;
+    DOMString? UserSetting;
+    DOMString? SharedSetting;
+    boolean? UserEditable;
+    boolean? DeviceEditable;
+  };
+
+  dictionary ManagedDOMStringList {
+    DOMString[]? Active;
+    DOMString? Effective;
+    DOMString[]? UserPolicy;
+    DOMString[]? DevicePolicy;
+    DOMString[]? UserSetting;
+    DOMString[]? SharedSetting;
+    boolean? UserEditable;
+    boolean? DeviceEditable;
+  };
+
+  dictionary ManagedIPConfigType {
+    IPConfigType? Active;
+    DOMString? Effective;
+    IPConfigType? UserPolicy;
+    IPConfigType? DevicePolicy;
+    IPConfigType? UserSetting;
+    IPConfigType? SharedSetting;
+    boolean? UserEditable;
+    boolean? DeviceEditable;
+  };
+
+  dictionary ManagedProxySettingsType {
+    ProxySettingsType? Active;
+    DOMString? Effective;
+    ProxySettingsType? UserPolicy;
+    ProxySettingsType? DevicePolicy;
+    ProxySettingsType? UserSetting;
+    ProxySettingsType? SharedSetting;
+    boolean? UserEditable;
+    boolean? DeviceEditable;
+  };
+
+  // Sub-dictionary types.
+
   dictionary APNProperties {
     DOMString AccessPointName;
     DOMString? Language;
@@ -72,6 +159,26 @@ namespace networkingPrivate {
     DOMString? Username;
   };
 
+  dictionary ManagedAPNProperties {
+    ManagedDOMString AccessPointName;
+    ManagedDOMString? Language;
+    ManagedDOMString? LocalizedName;
+    ManagedDOMString? Name;
+    ManagedDOMString? Password;
+    ManagedDOMString? Username;
+  };
+
+  dictionary ManagedAPNList {
+    APNProperties[]? Active;
+    DOMString? Effective;
+    APNProperties[]? UserPolicy;
+    APNProperties[]? DevicePolicy;
+    APNProperties[]? UserSetting;
+    APNProperties[]? SharedSetting;
+    boolean? UserEditable;
+    boolean? DeviceEditable;
+  };
+
   dictionary CellularProviderProperties {
     DOMString Name;
     DOMString Code;
@@ -96,6 +203,13 @@ namespace networkingPrivate {
     DOMString? OrganizationalUnit;    
   };
 
+  dictionary ManagedIssuerSubjectPattern {
+    ManagedDOMString? CommonName;
+    ManagedDOMString? Locality;
+    ManagedDOMString? Organization;
+    ManagedDOMString? OrganizationalUnit;    
+  };
+
   dictionary CertificatePattern {
     DOMString[]? EnrollmentURI;
     IssuerSubjectPattern? Issuer;
@@ -103,23 +217,11 @@ namespace networkingPrivate {
     IssuerSubjectPattern? Subject;
   };
 
-  dictionary DeviceStateProperties {
-    // Set if the device is enabled. True if the device is currently scanning.
-    boolean? Scanning;
-
-    // Set to the SIM lock type if the device type is Cellular and the device
-    // is locked.
-    DOMString? SimLockType;
-
-    // Set to the SIM present state if the device type is Cellular.
-    boolean? SimPresent;
-
-    // The current state of the device.
-    DeviceStateType State;
-
-    // The network type associated with the device (Cellular, Ethernet, WiFi, or
-    // WiMAX).
-    NetworkType Type;
+  dictionary ManagedCertificatePattern {
+    ManagedDOMStringList? EnrollmentURI;
+    ManagedIssuerSubjectPattern? Issuer;
+    ManagedDOMStringList? IssuerCARef;
+    ManagedIssuerSubjectPattern? Subject;
   };
 
   dictionary EAPProperties {
@@ -137,6 +239,21 @@ namespace networkingPrivate {
     boolean? UseSystemCAs;
   };
 
+  dictionary ManagedEAPProperties {
+    ManagedDOMString? AnonymousIdentity;
+    ManagedCertificatePattern? ClientCertPattern;
+    ManagedDOMString? ClientCertRef;
+    ManagedDOMString? ClientCertType;
+    ManagedDOMString? Identity;
+    ManagedDOMString? Inner;
+    ManagedDOMString Outer;
+    ManagedDOMString? Password;
+    ManagedBoolean? SaveCredentials;
+    ManagedDOMStringList? ServerCARefs;
+    ManagedBoolean? UseProactiveKeyCaching;
+    ManagedBoolean? UseSystemCAs;
+  };
+
   dictionary FoundNetworkProperties {
     DOMString Status;
     DOMString NetworkId;
@@ -154,12 +271,27 @@ namespace networkingPrivate {
     DOMString? WebProxyAutoDiscoveryUrl;
   };
 
+  dictionary ManagedIPConfigProperties {
+    ManagedDOMString? Gateway;
+    ManagedDOMString? IPAddress;
+    ManagedDOMString[]? NameServers;
+    ManagedLong? RoutingPrefix;
+    ManagedDOMString? Type;
+    ManagedDOMString? WebProxyAutoDiscoveryUrl;
+  };
+
   dictionary XAUTHProperties {
     DOMString? Password;
     boolean? SaveCredentials;
     DOMString? Username;
   };
 
+  dictionary ManagedXAUTHProperties {
+    ManagedDOMString? Password;
+    ManagedBoolean? SaveCredentials;
+    ManagedDOMString? Username;
+  };
+
   dictionary IPSecProperties {
     DOMString AuthenticationType;
     CertificatePattern? ClientCertPattern;
@@ -174,6 +306,20 @@ namespace networkingPrivate {
     XAUTHProperties? XAUTH;
   };
 
+  dictionary ManagedIPSecProperties {
+    ManagedDOMString AuthenticationType;
+    ManagedCertificatePattern? ClientCertPattern;
+    ManagedDOMString? ClientCertRef;
+    ManagedDOMString? ClientCertType;
+    ManagedEAPProperties? EAP;
+    ManagedDOMString? Group;
+    ManagedLong IKEVersion;
+    ManagedDOMString? PSK;
+    ManagedBoolean? SaveCredentials;
+    ManagedDOMStringList? ServerCARefs;
+    ManagedXAUTHProperties? XAUTH;
+  };
+
   dictionary L2TPProperties {
     boolean? LcpEchoDisabled;
     DOMString? Password;
@@ -181,6 +327,13 @@ namespace networkingPrivate {
     DOMString? Username;
   };
 
+  dictionary ManagedL2TPProperties {
+    ManagedBoolean? LcpEchoDisabled;
+    ManagedDOMString? Password;
+    ManagedBoolean? SaveCredentials;
+    ManagedDOMString? Username;
+  };
+
   dictionary PaymentPortal {
     DOMString Method;
     DOMString? PostData;
@@ -192,6 +345,11 @@ namespace networkingPrivate {
     long Port;
   };
 
+  dictionary ManagedProxyLocation {
+    ManagedDOMString Host;
+    ManagedLong Port;
+  };
+
   dictionary ManualProxySettings {
     ProxyLocation? HTTPProxy;
     ProxyLocation? SecureHTTPProxy;
@@ -199,6 +357,13 @@ namespace networkingPrivate {
     ProxyLocation? SOCKS;
   };
 
+  dictionary ManagedManualProxySettings {
+    ManagedProxyLocation? HTTPProxy;
+    ManagedProxyLocation? SecureHTTPProxy;
+    ManagedProxyLocation? FTPProxy;
+    ManagedProxyLocation? SOCKS;
+  };
+
   dictionary ProxySettings {
     ProxySettingsType Type;
     ManualProxySettings? Manual;
@@ -206,11 +371,23 @@ namespace networkingPrivate {
     DOMString? PAC;
   };
 
+  dictionary ManagedProxySettings {
+    ManagedProxySettingsType Type;
+    ManagedManualProxySettings? Manual;
+    ManagedDOMStringList? ExcludeDomains;
+    ManagedDOMString? PAC;
+  };
+
   dictionary VerifyX509 {
     DOMString? Name;
     DOMString? Type;
   };
 
+  dictionary ManagedVerifyX509 {
+    ManagedDOMString? Name;
+    ManagedDOMString? Type;
+  };
+
   dictionary OpenVPNProperties {
     DOMString? Auth;
     DOMString? AuthRetry;
@@ -248,6 +425,43 @@ namespace networkingPrivate {
     VerifyX509? VerifyX509;
   };
 
+  dictionary ManagedOpenVPNProperties {
+    ManagedDOMString? Auth;
+    ManagedDOMString? AuthRetry;
+    ManagedBoolean? AuthNoCache;
+    ManagedDOMString? Cipher;
+    ManagedDOMString? ClientCertRef;
+    ManagedCertificatePattern? ClientCertPattern;
+    ManagedDOMString? ClientCertType;
+    ManagedDOMString? CompLZO;
+    ManagedBoolean? CompNoAdapt;
+    ManagedBoolean? IgnoreDefaultRoute;
+    ManagedDOMString? KeyDirection;
+    ManagedDOMString? NsCertType;
+    ManagedDOMString? OTP;
+    ManagedDOMString? Password;
+    ManagedLong? Port;
+    ManagedDOMString? Proto;
+    ManagedDOMString? PushPeerInfo;
+    ManagedDOMString? RemoteCertEKU;
+    ManagedDOMString[]? RemoteCertKU;
+    ManagedDOMString? RemoteCertTLS;
+    ManagedLong? RenegSec;
+    ManagedBoolean? SaveCredentials;
+    ManagedDOMString[]? ServerCARefs;
+    ManagedDOMString? ServerCertRef;
+    ManagedLong? ServerPollTimeout;
+    ManagedLong? Shaper;
+    ManagedDOMString? StaticChallenge;
+    ManagedDOMString? TLSAuthContents;
+    ManagedDOMString? TLSRemote;
+    ManagedDOMString? UserAuthenticationType;
+    ManagedDOMString? Username;
+    ManagedDOMString? Verb;
+    ManagedDOMString? VerifyHash;
+    ManagedVerifyX509? VerifyX509;
+  };
+
   dictionary SIMLockStatus {
     DOMString LockType;  // sim-pin, sim-puk, or ''
     boolean LockEnabled;
@@ -259,6 +473,13 @@ namespace networkingPrivate {
     DOMString? ProviderName;
   };
 
+  dictionary ManagedThirdPartyVPNProperties {
+    ManagedDOMString ExtensionID;
+    DOMString? ProviderName;
+  };
+
+  // Network type dictionary types.
+
   dictionary CellularProperties {
     boolean? AutoConnect;
     APNProperties? APN;
@@ -292,6 +513,39 @@ namespace networkingPrivate {
     DOMString[]? SupportedCarriers;
   };
 
+  dictionary ManagedCellularProperties {
+    ManagedBoolean? AutoConnect;
+    ManagedAPNProperties? APN;
+    ManagedAPNList? APNList;
+    DOMString? ActivationType;
+    ActivationStateType? ActivationState;
+    boolean? AllowRoaming;
+    ManagedDOMString? Carrier;
+    DOMString? ESN;
+    DOMString? Family;
+    DOMString? FirmwareRevision;
+    FoundNetworkProperties[]? FoundNetworks;
+    DOMString? HardwareRevision;
+    CellularProviderProperties[]? HomeProvider;
+    DOMString? ICCID;
+    DOMString? IMEI;
+    APNProperties? LastGoodAPN;
+    DOMString? Manufacturer;
+    DOMString? MDN;
+    DOMString? MEID;
+    DOMString? MIN;
+    DOMString? ModelID;
+    DOMString? NetworkTechnology;
+    PaymentPortal? PaymentPortal;
+    long? PRLVersion;
+    DOMString? RoamingState;
+    CellularProviderProperties? ServingOperator;
+    SIMLockStatus? SIMLockStatus;
+    boolean? SIMPresent;
+    boolean? SupportNetworkScan;
+    DOMString[]? SupportedCarriers;
+  };
+
   dictionary CellularStateProperties {
     ActivationStateType? ActivationState;
     DOMString? NetworkTechnology;
@@ -305,6 +559,11 @@ namespace networkingPrivate {
     EAPProperties? EAP;
   };
 
+  dictionary ManagedEthernetProperties {
+    ManagedDOMString? Authentication;
+    ManagedEAPProperties? EAP;
+  };
+
   dictionary EthernetStateProperties {
     DOMString Authentication;
   };
@@ -319,6 +578,16 @@ namespace networkingPrivate {
     DOMString? Type;
   };
 
+  dictionary ManagedVPNProperties {
+    ManagedBoolean? AutoConnect;
+    ManagedDOMString? Host;
+    ManagedIPSecProperties? IPsec;
+    ManagedL2TPProperties? L2TP;
+    ManagedOpenVPNProperties? OpenVPN;
+    ManagedThirdPartyVPNProperties? ThirdPartyVPN;
+    ManagedDOMString Type;
+  };
+
   dictionary VPNStateProperties {
     DOMString Type;
     IPSecProperties? IPsec;
@@ -341,6 +610,22 @@ namespace networkingPrivate {
     long? SignalStrength;
   };
 
+  dictionary ManagedWiFiProperties {
+    ManagedBoolean? AllowGatewayARPPolling;
+    ManagedBoolean? AutoConnect;
+    DOMString? BSSID;
+    ManagedEAPProperties? EAP;
+    long? Frequency;
+    long[]? FrequencyList;
+    ManagedDOMString? HexSSID;
+    ManagedBoolean? HiddenSSID;
+    ManagedDOMString? Passphrase;
+    ManagedLong? RoamThreshold;
+    ManagedDOMString? SSID;
+    ManagedDOMString Security;
+    long? SignalStrength;
+  };
+
   dictionary WiFiStateProperties {
     DOMString Security;
     long? SignalStrength;
@@ -352,6 +637,12 @@ namespace networkingPrivate {
     long? SignalStrength;
   };
 
+  dictionary ManagedWiMAXProperties {
+    ManagedBoolean? AutoConnect;
+    ManagedEAPProperties? EAP;
+    long? SignalStrength;
+  };
+
   dictionary WiMAXStateProperties {
     long? SignalStrength;
   };
@@ -372,22 +663,6 @@ namespace networkingPrivate {
     WiMAXProperties? WiMAX;
   };
 
-  dictionary NetworkStateProperties {
-    CellularStateProperties? Cellular;
-    boolean? Connectable;
-    ConnectionStateType? ConnectionState;
-    EthernetStateProperties? Ethernet;
-    DOMString? ErrorState;
-    DOMString GUID;
-    DOMString? Name;
-    long? Priority;
-    DOMString? Source;
-    NetworkType Type;
-    VPNStateProperties? VPN;
-    WiFiStateProperties? WiFi;
-    WiMAXStateProperties? WiMAX;
-  };
-
   dictionary NetworkProperties {
     CellularProperties? Cellular;
     boolean? Connectable;
@@ -412,6 +687,65 @@ namespace networkingPrivate {
     WiMAXProperties? WiMAX;
   };
 
+  dictionary ManagedProperties {
+    ManagedCellularProperties? Cellular;
+    boolean? Connectable;
+    ConnectionStateType? ConnectionState;
+    DOMString? ErrorState;
+    ManagedEthernetProperties? Ethernet;
+    DOMString GUID;
+    ManagedIPConfigType? IPAddressConfigType;
+    IPConfigProperties[]? IPConfigs;
+    DOMString? MacAddress;
+    ManagedDOMString? Name;
+    ManagedIPConfigType? NameServersConfigType;
+    ManagedLong? Priority;
+    ManagedProxySettings? ProxySettings;
+    boolean? RestrictedConnectivity;
+    ManagedIPConfigProperties? StaticIPConfig;
+    IPConfigProperties? SavedIPConfig;
+    DOMString? Source;
+    NetworkType Type;
+    ManagedVPNProperties? VPN;
+    ManagedWiFiProperties? WiFi;
+    ManagedWiMAXProperties? WiMAX;
+  };
+
+  dictionary NetworkStateProperties {
+    CellularStateProperties? Cellular;
+    boolean? Connectable;
+    ConnectionStateType? ConnectionState;
+    EthernetStateProperties? Ethernet;
+    DOMString? ErrorState;
+    DOMString GUID;
+    DOMString? Name;
+    long? Priority;
+    DOMString? Source;
+    NetworkType Type;
+    VPNStateProperties? VPN;
+    WiFiStateProperties? WiFi;
+    WiMAXStateProperties? WiMAX;
+  };
+
+  dictionary DeviceStateProperties {
+    // Set if the device is enabled. True if the device is currently scanning.
+    boolean? Scanning;
+
+    // Set to the SIM lock type if the device type is Cellular and the device
+    // is locked.
+    DOMString? SimLockType;
+
+    // Set to the SIM present state if the device type is Cellular.
+    boolean? SimPresent;
+
+    // The current state of the device.
+    DeviceStateType State;
+
+    // The network type associated with the device (Cellular, Ethernet, WiFi, or
+    // WiMAX).
+    NetworkType Type;
+  };
+
   dictionary VerificationProperties {
     // A string containing a PEM-encoded (including the 'BEGIN CERTIFICATE'
     // header and 'END CERTIFICATE' footer) X.509 certificate for use in
@@ -470,7 +804,7 @@ namespace networkingPrivate {
   // TODO(stevenjb): Use NetworkProperties for |result| once defined.
   callback GetPropertiesCallback = void(NetworkProperties result);
   // TODO(stevenjb): Use ManagedNetworkProperties for |result| once defined.
-  callback GetManagedPropertiesCallback = void(object result);
+  callback GetManagedPropertiesCallback = void(ManagedProperties result);
   callback GetStatePropertiesCallback = void(NetworkStateProperties result);
   callback GetNetworksCallback = void(NetworkStateProperties[] result);
   callback GetDeviceStatesCallback = void(DeviceStateProperties[] result);
@@ -666,7 +1000,7 @@ namespace networkingPrivate {
     // * If the SIM is PIN locked, |pin| will be used to unlock the SIM and
     //   the |puk| argument will be ignored if provided.
     // * If the SIM is PUK locked, |puk| and |pin| must be provided. If the
-    //   operation succeds (|puk| is valid), the PIN will be set to |pin|.
+    //   operation succeeds (|puk| is valid), the PIN will be set to |pin|.
     //   (If |pin| is empty or invalid the operation will fail).
     // |networkGuid|: The GUID of the cellular network to unlock.
     // |pin|: The current SIM PIN, or the new PIN if PUK is provided.
diff --git a/third_party/closure_compiler/externs/networking_private.js b/third_party/closure_compiler/externs/networking_private.js
index 50dc614..cc9e8b6 100644
--- a/third_party/closure_compiler/externs/networking_private.js
+++ b/third_party/closure_compiler/externs/networking_private.js
@@ -96,6 +96,96 @@ chrome.networkingPrivate.ProxySettingsType = {
 
 /**
  * @typedef {{
+ *   Active: (boolean|undefined),
+ *   Effective: (string|undefined),
+ *   UserPolicy: (boolean|undefined),
+ *   DevicePolicy: (boolean|undefined),
+ *   UserSetting: (boolean|undefined),
+ *   SharedSetting: (boolean|undefined),
+ *   UserEditable: (boolean|undefined),
+ *   DeviceEditable: (boolean|undefined)
+ * }}
+ * @see https://developer.chrome.com/extensions/networkingPrivate#type-ManagedBoolean
+ */
+chrome.networkingPrivate.ManagedBoolean;
+
+/**
+ * @typedef {{
+ *   Active: (number|undefined),
+ *   Effective: (string|undefined),
+ *   UserPolicy: (number|undefined),
+ *   DevicePolicy: (number|undefined),
+ *   UserSetting: (number|undefined),
+ *   SharedSetting: (number|undefined),
+ *   UserEditable: (boolean|undefined),
+ *   DeviceEditable: (boolean|undefined)
+ * }}
+ * @see https://developer.chrome.com/extensions/networkingPrivate#type-ManagedLong
+ */
+chrome.networkingPrivate.ManagedLong;
+
+/**
+ * @typedef {{
+ *   Active: (string|undefined),
+ *   Effective: (string|undefined),
+ *   UserPolicy: (string|undefined),
+ *   DevicePolicy: (string|undefined),
+ *   UserSetting: (string|undefined),
+ *   SharedSetting: (string|undefined),
+ *   UserEditable: (boolean|undefined),
+ *   DeviceEditable: (boolean|undefined)
+ * }}
+ * @see https://developer.chrome.com/extensions/networkingPrivate#type-ManagedDOMString
+ */
+chrome.networkingPrivate.ManagedDOMString;
+
+/**
+ * @typedef {{
+ *   Active: (!Array<string>|undefined),
+ *   Effective: (string|undefined),
+ *   UserPolicy: (!Array<string>|undefined),
+ *   DevicePolicy: (!Array<string>|undefined),
+ *   UserSetting: (!Array<string>|undefined),
+ *   SharedSetting: (!Array<string>|undefined),
+ *   UserEditable: (boolean|undefined),
+ *   DeviceEditable: (boolean|undefined)
+ * }}
+ * @see https://developer.chrome.com/extensions/networkingPrivate#type-ManagedDOMStringList
+ */
+chrome.networkingPrivate.ManagedDOMStringList;
+
+/**
+ * @typedef {{
+ *   Active: (!chrome.networkingPrivate.IPConfigType|undefined),
+ *   Effective: (string|undefined),
+ *   UserPolicy: (!chrome.networkingPrivate.IPConfigType|undefined),
+ *   DevicePolicy: (!chrome.networkingPrivate.IPConfigType|undefined),
+ *   UserSetting: (!chrome.networkingPrivate.IPConfigType|undefined),
+ *   SharedSetting: (!chrome.networkingPrivate.IPConfigType|undefined),
+ *   UserEditable: (boolean|undefined),
+ *   DeviceEditable: (boolean|undefined)
+ * }}
+ * @see https://developer.chrome.com/extensions/networkingPrivate#type-ManagedIPConfigType
+ */
+chrome.networkingPrivate.ManagedIPConfigType;
+
+/**
+ * @typedef {{
+ *   Active: (!chrome.networkingPrivate.ProxySettingsType|undefined),
+ *   Effective: (string|undefined),
+ *   UserPolicy: (!chrome.networkingPrivate.ProxySettingsType|undefined),
+ *   DevicePolicy: (!chrome.networkingPrivate.ProxySettingsType|undefined),
+ *   UserSetting: (!chrome.networkingPrivate.ProxySettingsType|undefined),
+ *   SharedSetting: (!chrome.networkingPrivate.ProxySettingsType|undefined),
+ *   UserEditable: (boolean|undefined),
+ *   DeviceEditable: (boolean|undefined)
+ * }}
+ * @see https://developer.chrome.com/extensions/networkingPrivate#type-ManagedProxySettingsType
+ */
+chrome.networkingPrivate.ManagedProxySettingsType;
+
+/**
+ * @typedef {{
  *   AccessPointName: string,
  *   Language: (string|undefined),
  *   LocalizedName: (string|undefined),
@@ -109,6 +199,34 @@ chrome.networkingPrivate.APNProperties;
 
 /**
  * @typedef {{
+ *   AccessPointName: !chrome.networkingPrivate.ManagedDOMString,
+ *   Language: (!chrome.networkingPrivate.ManagedDOMString|undefined),
+ *   LocalizedName: (!chrome.networkingPrivate.ManagedDOMString|undefined),
+ *   Name: (!chrome.networkingPrivate.ManagedDOMString|undefined),
+ *   Password: (!chrome.networkingPrivate.ManagedDOMString|undefined),
+ *   Username: (!chrome.networkingPrivate.ManagedDOMString|undefined)
+ * }}
+ * @see https://developer.chrome.com/extensions/networkingPrivate#type-ManagedAPNProperties
+ */
+chrome.networkingPrivate.ManagedAPNProperties;
+
+/**
+ * @typedef {{
+ *   Active: (!Array<!chrome.networkingPrivate.APNProperties>|undefined),
+ *   Effective: (string|undefined),
+ *   UserPolicy: (!Array<!chrome.networkingPrivate.APNProperties>|undefined),
+ *   DevicePolicy: (!Array<!chrome.networkingPrivate.APNProperties>|undefined),
+ *   UserSetting: (!Array<!chrome.networkingPrivate.APNProperties>|undefined),
+ *   SharedSetting: (!Array<!chrome.networkingPrivate.APNProperties>|undefined),
+ *   UserEditable: (boolean|undefined),
+ *   DeviceEditable: (boolean|undefined)
+ * }}
+ * @see https://developer.chrome.com/extensions/networkingPrivate#type-ManagedAPNList
+ */
+chrome.networkingPrivate.ManagedAPNList;
+
+/**
+ * @typedef {{
  *   Name: string,
  *   Code: string,
  *   Country: (string|undefined)
@@ -140,6 +258,17 @@ chrome.networkingPrivate.IssuerSubjectPattern;
 
 /**
  * @typedef {{
+ *   CommonName: (!chrome.networkingPrivate.ManagedDOMString|undefined),
+ *   Locality: (!chrome.networkingPrivate.ManagedDOMString|undefined),
+ *   Organization: (!chrome.networkingPrivate.ManagedDOMString|undefined),
+ *   OrganizationalUnit: (!chrome.networkingPrivate.ManagedDOMString|undefined)
+ * }}
+ * @see https://developer.chrome.com/extensions/networkingPrivate#type-ManagedIssuerSubjectPattern
+ */
+chrome.networkingPrivate.ManagedIssuerSubjectPattern;
+
+/**
+ * @typedef {{
  *   EnrollmentURI: (!Array<string>|undefined),
  *   Issuer: (!chrome.networkingPrivate.IssuerSubjectPattern|undefined),
  *   IssuerCARef: (!Array<string>|undefined),
@@ -151,15 +280,14 @@ chrome.networkingPrivate.CertificatePattern;
 
 /**
  * @typedef {{
- *   Scanning: (boolean|undefined),
- *   SimLockType: (string|undefined),
- *   SimPresent: (boolean|undefined),
- *   State: !chrome.networkingPrivate.DeviceStateType,
- *   Type: !chrome.networkingPrivate.NetworkType
+ *   EnrollmentURI: (!chrome.networkingPrivate.ManagedDOMStringList|undefined),
+ *   Issuer: (!chrome.networkingPrivate.ManagedIssuerSubjectPattern|undefined),
+ *   IssuerCARef: (!chrome.networkingPrivate.ManagedDOMStringList|undefined),
+ *   Subject: (!chrome.networkingPrivate.ManagedIssuerSubjectPattern|undefined)
  * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-DeviceStateProperties
+ * @see https://developer.chrome.com/extensions/networkingPrivate#type-ManagedCertificatePattern
  */
-chrome.networkingPrivate.DeviceStateProperties;
+chrome.networkingPrivate.ManagedCertificatePattern;
 
 /**
  * @typedef {{
@@ -182,6 +310,25 @@ chrome.networkingPrivate.EAPProperties;
 
 /**
  * @typedef {{
+ *   AnonymousIdentity: (!chrome.networkingPrivate.ManagedDOMString|undefined),
+ *   ClientCertPattern: (!chrome.networkingPrivate.ManagedCertificatePattern|undefined),
+ *   ClientCertRef: (!chrome.networkingPrivate.ManagedDOMString|undefined),
+ *   ClientCertType: (!chrome.networkingPrivate.ManagedDOMString|undefined),
+ *   Identity: (!chrome.networkingPrivate.ManagedDOMString|undefined),
+ *   Inner: (!chrome.networkingPrivate.ManagedDOMString|undefined),
+ *   Outer: !chrome.networkingPrivate.ManagedDOMString,
+ *   Password: (!chrome.networkingPrivate.ManagedDOMString|undefined),
+ *   SaveCredentials: (!chrome.networkingPrivate.ManagedBoolean|undefined),
+ *   ServerCARefs: (!chrome.networkingPrivate.ManagedDOMStringList|undefined),
+ *   UseProactiveKeyCaching: (!chrome.networkingPrivate.ManagedBoolean|undefined),
+ *   UseSystemCAs: (!chrome.networkingPrivate.ManagedBoolean|undefined)
+ * }}
+ * @see https://developer.chrome.com/extensions/networkingPrivate#type-ManagedEAPProperties
+ */
+chrome.networkingPrivate.ManagedEAPProperties;
+
+/**
+ * @typedef {{
  *   Status: string,
  *   NetworkId: string,
  *   Technology: string,
@@ -207,6 +354,19 @@ chrome.networkingPrivate.IPConfigProperties;
 
 /**
  * @typedef {{
+ *   Gateway: (!chrome.networkingPrivate.ManagedDOMString|undefined),
+ *   IPAddress: (!chrome.networkingPrivate.ManagedDOMString|undefined),
+ *   NameServers: (!Array<!chrome.networkingPrivate.ManagedDOMString>|undefined),
+ *   RoutingPrefix: (!chrome.networkingPrivate.ManagedLong|undefined),
+ *   Type: (!chrome.networkingPrivate.ManagedDOMString|undefined),
+ *   WebProxyAutoDiscoveryUrl: (!chrome.networkingPrivate.ManagedDOMString|undefined)
+ * }}
+ * @see https://developer.chrome.com/extensions/networkingPrivate#type-ManagedIPConfigProperties
+ */
+chrome.networkingPrivate.ManagedIPConfigProperties;
+
+/**
+ * @typedef {{
  *   Password: (string|undefined),
  *   SaveCredentials: (boolean|undefined),
  *   Username: (string|undefined)
@@ -217,13 +377,23 @@ chrome.networkingPrivate.XAUTHProperties;
 
 /**
  * @typedef {{
+ *   Password: (!chrome.networkingPrivate.ManagedDOMString|undefined),
+ *   SaveCredentials: (!chrome.networkingPrivate.ManagedBoolean|undefined),
+ *   Username: (!chrome.networkingPrivate.ManagedDOMString|undefined)
+ * }}
+ * @see https://developer.chrome.com/extensions/networkingPrivate#type-ManagedXAUTHProperties
+ */
+chrome.networkingPrivate.ManagedXAUTHProperties;
+
+/**
+ * @typedef {{
  *   AuthenticationType: string,
  *   ClientCertPattern: (!chrome.networkingPrivate.CertificatePattern|undefined),
  *   ClientCertRef: (string|undefined),
  *   ClientCertType: (string|undefined),
  *   EAP: (!chrome.networkingPrivate.EAPProperties|undefined),
  *   Group: (string|undefined),
- *   IKEVersion: number,
+ *   IKEVersion: (number|undefined),
  *   PSK: (string|undefined),
  *   SaveCredentials: (boolean|undefined),
  *   ServerCARefs: (!Array<string>|undefined),
@@ -235,6 +405,24 @@ chrome.networkingPrivate.IPSecProperties;
 
 /**
  * @typedef {{
+ *   AuthenticationType: !chrome.networkingPrivate.ManagedDOMString,
+ *   ClientCertPattern: (!chrome.networkingPrivate.ManagedCertificatePattern|undefined),
+ *   ClientCertRef: (!chrome.networkingPrivate.ManagedDOMString|undefined),
+ *   ClientCertType: (!chrome.networkingPrivate.ManagedDOMString|undefined),
+ *   EAP: (!chrome.networkingPrivate.ManagedEAPProperties|undefined),
+ *   Group: (!chrome.networkingPrivate.ManagedDOMString|undefined),
+ *   IKEVersion: !chrome.networkingPrivate.ManagedLong,
+ *   PSK: (!chrome.networkingPrivate.ManagedDOMString|undefined),
+ *   SaveCredentials: (!chrome.networkingPrivate.ManagedBoolean|undefined),
+ *   ServerCARefs: (!chrome.networkingPrivate.ManagedDOMStringList|undefined),
+ *   XAUTH: (!chrome.networkingPrivate.ManagedXAUTHProperties|undefined)
+ * }}
+ * @see https://developer.chrome.com/extensions/networkingPrivate#type-ManagedIPSecProperties
+ */
+chrome.networkingPrivate.ManagedIPSecProperties;
+
+/**
+ * @typedef {{
  *   LcpEchoDisabled: (boolean|undefined),
  *   Password: (string|undefined),
  *   SaveCredentials: (boolean|undefined),
@@ -246,6 +434,17 @@ chrome.networkingPrivate.L2TPProperties;
 
 /**
  * @typedef {{
+ *   LcpEchoDisabled: (!chrome.networkingPrivate.ManagedBoolean|undefined),
+ *   Password: (!chrome.networkingPrivate.ManagedDOMString|undefined),
+ *   SaveCredentials: (!chrome.networkingPrivate.ManagedBoolean|undefined),
+ *   Username: (!chrome.networkingPrivate.ManagedDOMString|undefined)
+ * }}
+ * @see https://developer.chrome.com/extensions/networkingPrivate#type-ManagedL2TPProperties
+ */
+chrome.networkingPrivate.ManagedL2TPProperties;
+
+/**
+ * @typedef {{
  *   Method: string,
  *   PostData: (string|undefined),
  *   Url: (string|undefined)
@@ -265,6 +464,15 @@ chrome.networkingPrivate.ProxyLocation;
 
 /**
  * @typedef {{
+ *   Host: !chrome.networkingPrivate.ManagedDOMString,
+ *   Port: !chrome.networkingPrivate.ManagedLong
+ * }}
+ * @see https://developer.chrome.com/extensions/networkingPrivate#type-ManagedProxyLocation
+ */
+chrome.networkingPrivate.ManagedProxyLocation;
+
+/**
+ * @typedef {{
  *   HTTPProxy: (!chrome.networkingPrivate.ProxyLocation|undefined),
  *   SecureHTTPProxy: (!chrome.networkingPrivate.ProxyLocation|undefined),
  *   FTPProxy: (!chrome.networkingPrivate.ProxyLocation|undefined),
@@ -276,6 +484,17 @@ chrome.networkingPrivate.ManualProxySettings;
 
 /**
  * @typedef {{
+ *   HTTPProxy: (!chrome.networkingPrivate.ManagedProxyLocation|undefined),
+ *   SecureHTTPProxy: (!chrome.networkingPrivate.ManagedProxyLocation|undefined),
+ *   FTPProxy: (!chrome.networkingPrivate.ManagedProxyLocation|undefined),
+ *   SOCKS: (!chrome.networkingPrivate.ManagedProxyLocation|undefined)
+ * }}
+ * @see https://developer.chrome.com/extensions/networkingPrivate#type-ManagedManualProxySettings
+ */
+chrome.networkingPrivate.ManagedManualProxySettings;
+
+/**
+ * @typedef {{
  *   Type: !chrome.networkingPrivate.ProxySettingsType,
  *   Manual: (!chrome.networkingPrivate.ManualProxySettings|undefined),
  *   ExcludeDomains: (!Array<string>|undefined),
@@ -287,6 +506,17 @@ chrome.networkingPrivate.ProxySettings;
 
 /**
  * @typedef {{
+ *   Type: !chrome.networkingPrivate.ManagedProxySettingsType,
+ *   Manual: (!chrome.networkingPrivate.ManagedManualProxySettings|undefined),
+ *   ExcludeDomains: (!chrome.networkingPrivate.ManagedDOMStringList|undefined),
+ *   PAC: (!chrome.networkingPrivate.ManagedDOMString|undefined)
+ * }}
+ * @see https://developer.chrome.com/extensions/networkingPrivate#type-ManagedProxySettings
+ */
+chrome.networkingPrivate.ManagedProxySettings;
+
+/**
+ * @typedef {{
  *   Name: (string|undefined),
  *   Type: (string|undefined)
  * }}
@@ -296,6 +526,15 @@ chrome.networkingPrivate.VerifyX509;
 
 /**
  * @typedef {{
+ *   Name: (!chrome.networkingPrivate.ManagedDOMString|undefined),
+ *   Type: (!chrome.networkingPrivate.ManagedDOMString|undefined)
+ * }}
+ * @see https://developer.chrome.com/extensions/networkingPrivate#type-ManagedVerifyX509
+ */
+chrome.networkingPrivate.ManagedVerifyX509;
+
+/**
+ * @typedef {{
  *   Auth: (string|undefined),
  *   AuthRetry: (string|undefined),
  *   AuthNoCache: (boolean|undefined),
@@ -337,6 +576,47 @@ chrome.networkingPrivate.OpenVPNProperties;
 
 /**
  * @typedef {{
+ *   Auth: (!chrome.networkingPrivate.ManagedDOMString|undefined),
+ *   AuthRetry: (!chrome.networkingPrivate.ManagedDOMString|undefined),
+ *   AuthNoCache: (!chrome.networkingPrivate.ManagedBoolean|undefined),
+ *   Cipher: (!chrome.networkingPrivate.ManagedDOMString|undefined),
+ *   ClientCertRef: (!chrome.networkingPrivate.ManagedDOMString|undefined),
+ *   ClientCertPattern: (!chrome.networkingPrivate.ManagedCertificatePattern|undefined),
+ *   ClientCertType: (!chrome.networkingPrivate.ManagedDOMString|undefined),
+ *   CompLZO: (!chrome.networkingPrivate.ManagedDOMString|undefined),
+ *   CompNoAdapt: (!chrome.networkingPrivate.ManagedBoolean|undefined),
+ *   IgnoreDefaultRoute: (!chrome.networkingPrivate.ManagedBoolean|undefined),
+ *   KeyDirection: (!chrome.networkingPrivate.ManagedDOMString|undefined),
+ *   NsCertType: (!chrome.networkingPrivate.ManagedDOMString|undefined),
+ *   OTP: (!chrome.networkingPrivate.ManagedDOMString|undefined),
+ *   Password: (!chrome.networkingPrivate.ManagedDOMString|undefined),
+ *   Port: (!chrome.networkingPrivate.ManagedLong|undefined),
+ *   Proto: (!chrome.networkingPrivate.ManagedDOMString|undefined),
+ *   PushPeerInfo: (!chrome.networkingPrivate.ManagedDOMString|undefined),
+ *   RemoteCertEKU: (!chrome.networkingPrivate.ManagedDOMString|undefined),
+ *   RemoteCertKU: (!Array<!chrome.networkingPrivate.ManagedDOMString>|undefined),
+ *   RemoteCertTLS: (!chrome.networkingPrivate.ManagedDOMString|undefined),
+ *   RenegSec: (!chrome.networkingPrivate.ManagedLong|undefined),
+ *   SaveCredentials: (!chrome.networkingPrivate.ManagedBoolean|undefined),
+ *   ServerCARefs: (!Array<!chrome.networkingPrivate.ManagedDOMString>|undefined),
+ *   ServerCertRef: (!chrome.networkingPrivate.ManagedDOMString|undefined),
+ *   ServerPollTimeout: (!chrome.networkingPrivate.ManagedLong|undefined),
+ *   Shaper: (!chrome.networkingPrivate.ManagedLong|undefined),
+ *   StaticChallenge: (!chrome.networkingPrivate.ManagedDOMString|undefined),
+ *   TLSAuthContents: (!chrome.networkingPrivate.ManagedDOMString|undefined),
+ *   TLSRemote: (!chrome.networkingPrivate.ManagedDOMString|undefined),
+ *   UserAuthenticationType: (!chrome.networkingPrivate.ManagedDOMString|undefined),
+ *   Username: (!chrome.networkingPrivate.ManagedDOMString|undefined),
+ *   Verb: (!chrome.networkingPrivate.ManagedDOMString|undefined),
+ *   VerifyHash: (!chrome.networkingPrivate.ManagedDOMString|undefined),
+ *   VerifyX509: (!chrome.networkingPrivate.ManagedVerifyX509|undefined)
+ * }}
+ * @see https://developer.chrome.com/extensions/networkingPrivate#type-ManagedOpenVPNProperties
+ */
+chrome.networkingPrivate.ManagedOpenVPNProperties;
+
+/**
+ * @typedef {{
  *   LockType: string,
  *   LockEnabled: boolean,
  *   RetriesLeft: (number|undefined)
@@ -356,6 +636,15 @@ chrome.networkingPrivate.ThirdPartyVPNProperties;
 
 /**
  * @typedef {{
+ *   ExtensionID: !chrome.networkingPrivate.ManagedDOMString,
+ *   ProviderName: (string|undefined)
+ * }}
+ * @see https://developer.chrome.com/extensions/networkingPrivate#type-ManagedThirdPartyVPNProperties
+ */
+chrome.networkingPrivate.ManagedThirdPartyVPNProperties;
+
+/**
+ * @typedef {{
  *   AutoConnect: (boolean|undefined),
  *   APN: (!chrome.networkingPrivate.APNProperties|undefined),
  *   APNList: (!Array<!chrome.networkingPrivate.APNProperties>|undefined),
@@ -393,6 +682,43 @@ chrome.networkingPrivate.CellularProperties;
 
 /**
  * @typedef {{
+ *   AutoConnect: (!chrome.networkingPrivate.ManagedBoolean|undefined),
+ *   APN: (!chrome.networkingPrivate.ManagedAPNProperties|undefined),
+ *   APNList: (!chrome.networkingPrivate.ManagedAPNList|undefined),
+ *   ActivationType: (string|undefined),
+ *   ActivationState: (!chrome.networkingPrivate.ActivationStateType|undefined),
+ *   AllowRoaming: (boolean|undefined),
+ *   Carrier: (!chrome.networkingPrivate.ManagedDOMString|undefined),
+ *   ESN: (string|undefined),
+ *   Family: (string|undefined),
+ *   FirmwareRevision: (string|undefined),
+ *   FoundNetworks: (!Array<!chrome.networkingPrivate.FoundNetworkProperties>|undefined),
+ *   HardwareRevision: (string|undefined),
+ *   HomeProvider: (!Array<!chrome.networkingPrivate.CellularProviderProperties>|undefined),
+ *   ICCID: (string|undefined),
+ *   IMEI: (string|undefined),
+ *   LastGoodAPN: (!chrome.networkingPrivate.APNProperties|undefined),
+ *   Manufacturer: (string|undefined),
+ *   MDN: (string|undefined),
+ *   MEID: (string|undefined),
+ *   MIN: (string|undefined),
+ *   ModelID: (string|undefined),
+ *   NetworkTechnology: (string|undefined),
+ *   PaymentPortal: (!chrome.networkingPrivate.PaymentPortal|undefined),
+ *   PRLVersion: (number|undefined),
+ *   RoamingState: (string|undefined),
+ *   ServingOperator: (!chrome.networkingPrivate.CellularProviderProperties|undefined),
+ *   SIMLockStatus: (!chrome.networkingPrivate.SIMLockStatus|undefined),
+ *   SIMPresent: (boolean|undefined),
+ *   SupportNetworkScan: (boolean|undefined),
+ *   SupportedCarriers: (!Array<string>|undefined)
+ * }}
+ * @see https://developer.chrome.com/extensions/networkingPrivate#type-ManagedCellularProperties
+ */
+chrome.networkingPrivate.ManagedCellularProperties;
+
+/**
+ * @typedef {{
  *   ActivationState: (!chrome.networkingPrivate.ActivationStateType|undefined),
  *   NetworkTechnology: (string|undefined),
  *   RoamingState: (string|undefined),
@@ -414,6 +740,15 @@ chrome.networkingPrivate.EthernetProperties;
 
 /**
  * @typedef {{
+ *   Authentication: (!chrome.networkingPrivate.ManagedDOMString|undefined),
+ *   EAP: (!chrome.networkingPrivate.ManagedEAPProperties|undefined)
+ * }}
+ * @see https://developer.chrome.com/extensions/networkingPrivate#type-ManagedEthernetProperties
+ */
+chrome.networkingPrivate.ManagedEthernetProperties;
+
+/**
+ * @typedef {{
  *   Authentication: string
  * }}
  * @see https://developer.chrome.com/extensions/networkingPrivate#type-EthernetStateProperties
@@ -436,6 +771,20 @@ chrome.networkingPrivate.VPNProperties;
 
 /**
  * @typedef {{
+ *   AutoConnect: (!chrome.networkingPrivate.ManagedBoolean|undefined),
+ *   Host: (!chrome.networkingPrivate.ManagedDOMString|undefined),
+ *   IPsec: (!chrome.networkingPrivate.ManagedIPSecProperties|undefined),
+ *   L2TP: (!chrome.networkingPrivate.ManagedL2TPProperties|undefined),
+ *   OpenVPN: (!chrome.networkingPrivate.ManagedOpenVPNProperties|undefined),
+ *   ThirdPartyVPN: (!chrome.networkingPrivate.ManagedThirdPartyVPNProperties|undefined),
+ *   Type: !chrome.networkingPrivate.ManagedDOMString
+ * }}
+ * @see https://developer.chrome.com/extensions/networkingPrivate#type-ManagedVPNProperties
+ */
+chrome.networkingPrivate.ManagedVPNProperties;
+
+/**
+ * @typedef {{
  *   Type: string,
  *   IPsec: (!chrome.networkingPrivate.IPSecProperties|undefined),
  *   ThirdPartyVPN: (!chrome.networkingPrivate.ThirdPartyVPNProperties|undefined)
@@ -466,6 +815,26 @@ chrome.networkingPrivate.WiFiProperties;
 
 /**
  * @typedef {{
+ *   AllowGatewayARPPolling: (!chrome.networkingPrivate.ManagedBoolean|undefined),
+ *   AutoConnect: (!chrome.networkingPrivate.ManagedBoolean|undefined),
+ *   BSSID: (string|undefined),
+ *   EAP: (!chrome.networkingPrivate.ManagedEAPProperties|undefined),
+ *   Frequency: (number|undefined),
+ *   FrequencyList: (!Array<number>|undefined),
+ *   HexSSID: (!chrome.networkingPrivate.ManagedDOMString|undefined),
+ *   HiddenSSID: (!chrome.networkingPrivate.ManagedBoolean|undefined),
+ *   Passphrase: (!chrome.networkingPrivate.ManagedDOMString|undefined),
+ *   RoamThreshold: (!chrome.networkingPrivate.ManagedLong|undefined),
+ *   SSID: (!chrome.networkingPrivate.ManagedDOMString|undefined),
+ *   Security: !chrome.networkingPrivate.ManagedDOMString,
+ *   SignalStrength: (number|undefined)
+ * }}
+ * @see https://developer.chrome.com/extensions/networkingPrivate#type-ManagedWiFiProperties
+ */
+chrome.networkingPrivate.ManagedWiFiProperties;
+
+/**
+ * @typedef {{
  *   Security: string,
  *   SignalStrength: (number|undefined)
  * }}
@@ -485,6 +854,16 @@ chrome.networkingPrivate.WiMAXProperties;
 
 /**
  * @typedef {{
+ *   AutoConnect: (!chrome.networkingPrivate.ManagedBoolean|undefined),
+ *   EAP: (!chrome.networkingPrivate.ManagedEAPProperties|undefined),
+ *   SignalStrength: (number|undefined)
+ * }}
+ * @see https://developer.chrome.com/extensions/networkingPrivate#type-ManagedWiMAXProperties
+ */
+chrome.networkingPrivate.ManagedWiMAXProperties;
+
+/**
+ * @typedef {{
  *   SignalStrength: (number|undefined)
  * }}
  * @see https://developer.chrome.com/extensions/networkingPrivate#type-WiMAXStateProperties
@@ -513,26 +892,6 @@ chrome.networkingPrivate.NetworkConfigProperties;
 
 /**
  * @typedef {{
- *   Cellular: (!chrome.networkingPrivate.CellularStateProperties|undefined),
- *   Connectable: (boolean|undefined),
- *   ConnectionState: (!chrome.networkingPrivate.ConnectionStateType|undefined),
- *   Ethernet: (!chrome.networkingPrivate.EthernetStateProperties|undefined),
- *   ErrorState: (string|undefined),
- *   GUID: string,
- *   Name: (string|undefined),
- *   Priority: (number|undefined),
- *   Source: (string|undefined),
- *   Type: !chrome.networkingPrivate.NetworkType,
- *   VPN: (!chrome.networkingPrivate.VPNStateProperties|undefined),
- *   WiFi: (!chrome.networkingPrivate.WiFiStateProperties|undefined),
- *   WiMAX: (!chrome.networkingPrivate.WiMAXStateProperties|undefined)
- * }}
- * @see https://developer.chrome.com/extensions/networkingPrivate#type-NetworkStateProperties
- */
-chrome.networkingPrivate.NetworkStateProperties;
-
-/**
- * @typedef {{
  *   Cellular: (!chrome.networkingPrivate.CellularProperties|undefined),
  *   Connectable: (boolean|undefined),
  *   ConnectionState: (!chrome.networkingPrivate.ConnectionStateType|undefined),
@@ -561,6 +920,66 @@ chrome.networkingPrivate.NetworkProperties;
 
 /**
  * @typedef {{
+ *   Cellular: (!chrome.networkingPrivate.ManagedCellularProperties|undefined),
+ *   Connectable: (boolean|undefined),
+ *   ConnectionState: (!chrome.networkingPrivate.ConnectionStateType|undefined),
+ *   ErrorState: (string|undefined),
+ *   Ethernet: (!chrome.networkingPrivate.ManagedEthernetProperties|undefined),
+ *   GUID: string,
+ *   IPAddressConfigType: (!chrome.networkingPrivate.ManagedIPConfigType|undefined),
+ *   IPConfigs: (!Array<!chrome.networkingPrivate.IPConfigProperties>|undefined),
+ *   MacAddress: (string|undefined),
+ *   Name: (!chrome.networkingPrivate.ManagedDOMString|undefined),
+ *   NameServersConfigType: (!chrome.networkingPrivate.ManagedIPConfigType|undefined),
+ *   Priority: (!chrome.networkingPrivate.ManagedLong|undefined),
+ *   ProxySettings: (!chrome.networkingPrivate.ManagedProxySettings|undefined),
+ *   RestrictedConnectivity: (boolean|undefined),
+ *   StaticIPConfig: (!chrome.networkingPrivate.ManagedIPConfigProperties|undefined),
+ *   SavedIPConfig: (!chrome.networkingPrivate.IPConfigProperties|undefined),
+ *   Source: (string|undefined),
+ *   Type: !chrome.networkingPrivate.NetworkType,
+ *   VPN: (!chrome.networkingPrivate.ManagedVPNProperties|undefined),
+ *   WiFi: (!chrome.networkingPrivate.ManagedWiFiProperties|undefined),
+ *   WiMAX: (!chrome.networkingPrivate.ManagedWiMAXProperties|undefined)
+ * }}
+ * @see https://developer.chrome.com/extensions/networkingPrivate#type-ManagedProperties
+ */
+chrome.networkingPrivate.ManagedProperties;
+
+/**
+ * @typedef {{
+ *   Cellular: (!chrome.networkingPrivate.CellularStateProperties|undefined),
+ *   Connectable: (boolean|undefined),
+ *   ConnectionState: (!chrome.networkingPrivate.ConnectionStateType|undefined),
+ *   Ethernet: (!chrome.networkingPrivate.EthernetStateProperties|undefined),
+ *   ErrorState: (string|undefined),
+ *   GUID: string,
+ *   Name: (string|undefined),
+ *   Priority: (number|undefined),
+ *   Source: (string|undefined),
+ *   Type: !chrome.networkingPrivate.NetworkType,
+ *   VPN: (!chrome.networkingPrivate.VPNStateProperties|undefined),
+ *   WiFi: (!chrome.networkingPrivate.WiFiStateProperties|undefined),
+ *   WiMAX: (!chrome.networkingPrivate.WiMAXStateProperties|undefined)
+ * }}
+ * @see https://developer.chrome.com/extensions/networkingPrivate#type-NetworkStateProperties
+ */
+chrome.networkingPrivate.NetworkStateProperties;
+
+/**
+ * @typedef {{
+ *   Scanning: (boolean|undefined),
+ *   SimLockType: (string|undefined),
+ *   SimPresent: (boolean|undefined),
+ *   State: !chrome.networkingPrivate.DeviceStateType,
+ *   Type: !chrome.networkingPrivate.NetworkType
+ * }}
+ * @see https://developer.chrome.com/extensions/networkingPrivate#type-DeviceStateProperties
+ */
+chrome.networkingPrivate.DeviceStateProperties;
+
+/**
+ * @typedef {{
  *   certificate: string,
  *   intermediateCertificates: (!Array<string>|undefined),
  *   publicKey: string,
@@ -600,8 +1019,8 @@ chrome.networkingPrivate.getProperties = function(networkGuid, callback) {};
  * sources: User settings, shared settings, user policy, device policy and the
  * currently active settings.
  * @param {string} networkGuid The GUID of the network to get properties for.
- * @param {function(Object):void} callback Called with the managed network
- *     properties when received.
+ * @param {function(!chrome.networkingPrivate.ManagedProperties):void} callback
+ *     Called with the managed network properties when received.
  * @see https://developer.chrome.com/extensions/networkingPrivate#method-getManagedProperties
  */
 chrome.networkingPrivate.getManagedProperties = function(networkGuid, callback) {};
@@ -831,7 +1250,7 @@ chrome.networkingPrivate.getCaptivePortalStatus = function(networkGuid, callback
  * Unlocks a Cellular SIM card. * If the SIM is PIN locked, |pin| will be used
  * to unlock the SIM and   the |puk| argument will be ignored if provided. * If
  * the SIM is PUK locked, |puk| and |pin| must be provided. If the   operation
- * succeds (|puk| is valid), the PIN will be set to |pin|.   (If |pin| is empty
+ * succeeds (|puk| is valid), the PIN will be set to |pin|.   (If |pin| is empty
  * or invalid the operation will fail).
  * @param {string} networkGuid The GUID of the cellular network to unlock.
  * @param {string} pin The current SIM PIN, or the new PIN if PUK is provided.
diff --git a/ui/webui/resources/cr_elements/v1_0/network/cr_network_icon.js b/ui/webui/resources/cr_elements/v1_0/network/cr_network_icon.js
index ed5eb56..d6ee553 100644
--- a/ui/webui/resources/cr_elements/v1_0/network/cr_network_icon.js
+++ b/ui/webui/resources/cr_elements/v1_0/network/cr_network_icon.js
@@ -120,8 +120,7 @@ Polymer({
 
     this.networkType = null;
     this.iconType_ = getIconTypeFromNetworkType(this.networkState.Type);
-    var strength = /** @type {number} */ (
-        CrOnc.getActiveTypeValue(this.networkState, 'SignalStrength') || 0);
+    var strength = CrOnc.getSignalStrength(this.networkState);
     var params = /** @type {NetworkIconParamType} */ {
       showBadges: true,
       showDisconnected: !this.isListItem,
@@ -243,19 +242,18 @@ Polymer({
         (params.showBadges && networkState) ? networkState.Type : '';
     if (type == CrOnc.Type.WI_FI) {
       this.roaming_ = false;
-      var security = CrOnc.getActiveTypeValue(networkState, 'Security');
+      var security = networkState.WiFi ? networkState.WiFi.Security : '';
       this.secure_ = !!security && security != 'None';
       this.technology_ = '';
     } else if (type == CrOnc.Type.WI_MAX) {
       this.roaming_ = false;
       this.secure_ = false;
       this.technology_ = '4g';
-    } else if (type == CrOnc.Type.CELLULAR) {
-      this.roaming_ = CrOnc.getActiveTypeValue(networkState, 'RoamingState') ==
-                      CrOnc.RoamingState.ROAMING;
+    } else if (type == CrOnc.Type.CELLULAR && networkState.Cellular) {
+      this.roaming_ =
+          networkState.Cellular.RoamingState == CrOnc.RoamingState.ROAMING;
       this.secure_ = false;
-      var oncTechnology =
-          CrOnc.getActiveTypeValue(networkState, 'NetworkTechnology');
+      var oncTechnology = networkState.Cellular.NetworkTechnology;
       switch (oncTechnology) {
         case CrOnc.NetworkTechnology.CDMA1XRTT:
           this.technology_ = '1x';
diff --git a/ui/webui/resources/cr_elements/v1_0/network/cr_onc_types.js b/ui/webui/resources/cr_elements/v1_0/network/cr_onc_types.js
index cca3371..8ff05c4 100644
--- a/ui/webui/resources/cr_elements/v1_0/network/cr_onc_types.js
+++ b/ui/webui/resources/cr_elements/v1_0/network/cr_onc_types.js
@@ -20,31 +20,28 @@ var CrOnc = {};
 /** @typedef {chrome.networkingPrivate.NetworkStateProperties} */
 CrOnc.NetworkStateProperties;
 
-/** @typedef {chrome.networkingPrivate.NetworkProperties} */
+/** @typedef {chrome.networkingPrivate.ManagedProperties} */
 CrOnc.NetworkProperties;
 
 /** @typedef {string|number|boolean|Object|Array<Object>} */
 CrOnc.NetworkPropertyType;
 
 /**
- * TODO(stevenjb): Eliminate this when we switch to using
- * chrome.networkingPrivate.ManagedProperties once defined.
+ * Generic managed property type. This should match any of the basic managed
+ * types in chrome.networkingPrivate, e.g. networkingPrivate.ManagedBoolean.
  * @typedef {{
- *   Active: CrOnc.NetworkPropertyType,
- *   Effective: CrOnc.NetworkPropertyType,
- *   UserPolicy: CrOnc.NetworkPropertyType,
- *   DevicePolicy: CrOnc.NetworkPropertyType,
- *   UserSetting: CrOnc.NetworkPropertyType,
- *   SharedSetting: CrOnc.NetworkPropertyType,
- *   UserEditable: boolean,
- *   DeviceEditable: boolean
+ *   Active: (!CrOnc.NetworkPropertyType|undefined),
+ *   Effective: (string|undefined),
+ *   UserPolicy: (!CrOnc.NetworkPropertyType|undefined),
+ *   DevicePolicy: (!CrOnc.NetworkPropertyType|undefined),
+ *   UserSetting: (!CrOnc.NetworkPropertyType|undefined),
+ *   SharedSetting: (!CrOnc.NetworkPropertyType|undefined),
+ *   UserEditable: (boolean|undefined),
+ *   DeviceEditable: (boolean|undefined)
  * }}
  */
 CrOnc.ManagedProperty;
 
-/** @typedef {CrOnc.NetworkPropertyType|!CrOnc.ManagedProperty} */
-CrOnc.ManagedNetworkStateProperty;
-
 /** @typedef {chrome.networkingPrivate.SIMLockStatus} */
 CrOnc.SIMLockStatus;
 
@@ -144,9 +141,10 @@ CrOnc.Source = {
 };
 
 /**
- * Helper function to retrieve the active ONC property value.
- * @param {!CrOnc.ManagedNetworkStateProperty|undefined} property The property,
- *     which may be a managed dictionary or the property itself.
+ * Helper function to retrieve the active ONC property value from a managed
+ * dictionary.
+ * @param {!CrOnc.ManagedProperty|undefined} property The managed dictionary
+ *     for the property if it exists or undefined.
  * @return {!CrOnc.NetworkPropertyType|undefined} The active property value
  *     if it exists, otherwise undefined.
  */
@@ -154,11 +152,13 @@ CrOnc.getActiveValue = function(property) {
   if (property == undefined)
     return undefined;
 
-  // If this is not a dictionary, return the value.
-  if (Array.isArray(property) || typeof property != 'object')
-    return /** @type {!CrOnc.NetworkPropertyType} */ (property);
+  if (typeof property != 'object') {
+    console.error('getActiveValue called on non object: ' +
+                  JSON.stringify(property));
+    return undefined;
+  }
 
-  // Otherwise return the Active value if it exists.
+  // Return the Active value if it exists.
   if ('Active' in property)
     return property['Active'];
 
@@ -175,23 +175,29 @@ CrOnc.getActiveValue = function(property) {
 };
 
 /**
- * Calls getActiveValue with '{state.Type}.key', e.g. WiFi.AutoConnect.
- * @param {!CrOnc.NetworkProperties|!CrOnc.NetworkStateProperties|undefined}
- *     properties The ONC network properties or state properties.
- * @param {string} key The type property key, e.g. 'AutoConnect'.
- * @return {!CrOnc.ManagedNetworkStateProperty|undefined} The property value or
- *     dictionary if it exists, otherwise undefined.
+ * Converts a managed ONC dictionary into an unmanaged dictionary (i.e. a
+ * dictionary of active values).
+ * NOTE: This is not intended to be used with dictionaries that contain
+ * nested dictionaries. This will fail and return undefined in that case.
+ * @param {!Object|undefined} properties A managed ONC dictionary
+ * @return {!Object|undefined} An unmanaged version of |properties|.
  */
-CrOnc.getActiveTypeValue = function(properties, key) {
-  var typeDict = properties[properties.Type];
-  if (!typeDict) {
-    // An 'Ethernet' dictionary will only be present for EAP ethernet networks,
-    // so don't log an error when Type == Ethernet.
-    if (properties.Type != chrome.networkingPrivate.NetworkType.ETHERNET)
-      console.error('Network properties missing for:', properties.GUID);
+CrOnc.getSimpleActiveProperties = function(properties) {
+  'use strict';
+  if (!properties)
     return undefined;
+  var result = {};
+  var keys = Object.keys(properties);
+  for (let k of keys) {
+    var prop = CrOnc.getActiveValue(properties[k]);
+    if (prop == undefined) {
+      console.error('getSimpleActiveProperties called on invalid ONC object:',
+                    JSON.stringify(properties));
+      return undefined;
+    }
+    result[k] = prop;
   }
-  return CrOnc.getActiveValue(typeDict[key]);
+  return result;
 };
 
 /**
@@ -204,44 +210,82 @@ CrOnc.getActiveTypeValue = function(properties, key) {
  */
 CrOnc.getIPConfigForType = function(properties, type) {
   'use strict';
-  var result;
+  /** @type {!CrOnc.IPConfigProperties|undefined} */ var ipConfig = undefined;
   var ipConfigs = properties.IPConfigs;
   if (ipConfigs) {
     for (let i = 0; i < ipConfigs.length; ++i) {
-      let ipConfig = ipConfigs[i];
-      if (ipConfig.Type == type) {
-        result = ipConfig;
+      ipConfig = ipConfigs[i];
+      if (ipConfig.Type == type)
         break;
-      }
     }
   }
   if (type != CrOnc.IPType.IPV4)
-    return result;
+    return ipConfig;
 
-  var staticIpConfig = properties.StaticIPConfig;
+  var staticIpConfig =
+      /** @type {!CrOnc.IPConfigProperties|undefined} */(
+          CrOnc.getSimpleActiveProperties(properties.StaticIPConfig));
   if (!staticIpConfig)
-    return result;
+    return ipConfig;
 
   // If there is no entry in IPConfigs for |type|, return the static config.
-  if (!result)
+  if (!ipConfig)
     return staticIpConfig;
 
   // Otherwise, merge the appropriate static values into the result.
   if (staticIpConfig.IPAddress &&
       CrOnc.getActiveValue(properties.IPAddressConfigType) == 'Static') {
-    result.Gateway = staticIpConfig.Gateway;
-    result.IPAddress = staticIpConfig.IPAddress;
-    result.RoutingPrefix = staticIpConfig.RoutingPrefix;
-    result.Type = staticIpConfig.Type;
+    ipConfig.Gateway = staticIpConfig.Gateway;
+    ipConfig.IPAddress = staticIpConfig.IPAddress;
+    ipConfig.RoutingPrefix = staticIpConfig.RoutingPrefix;
+    ipConfig.Type = staticIpConfig.Type;
   }
   if (staticIpConfig.NameServers &&
       CrOnc.getActiveValue(properties.NameServersConfigType) == 'Static') {
-    result.NameServers = staticIpConfig.NameServers;
+    ipConfig.NameServers = staticIpConfig.NameServers;
   }
-  return result;
+  return ipConfig;
 };
 
 /**
+ * Gets the SignalStrength value from |properties| based on properties.Type.
+ * @param {!CrOnc.NetworkProperties|!CrOnc.NetworkStateProperties|undefined}
+ *     properties The ONC network properties or state properties.
+ * @return {number} The signal strength value if it exists or 0.
+ */
+CrOnc.getSignalStrength = function(properties) {
+  var type = properties.Type;
+  if (type == CrOnc.Type.CELLULAR && properties.Cellular)
+    return properties.Cellular.SignalStrength || 0;
+  else if (type == CrOnc.Type.WI_FI && properties.WiFi)
+    return properties.WiFi.SignalStrength || 0;
+  else if (type == CrOnc.Type.WI_MAX && properties.WiMAX)
+    return properties.WiMAX.SignalStrength || 0;
+  return 0;
+}
+
+/**
+ * Gets the AutoConnect value from |properties| based on properties.Type.
+ * @param {!CrOnc.NetworkProperties|undefined}
+ *     properties The ONC network properties or state properties.
+ * @return {boolean} The AutoConnect value if it exists or false.
+ */
+CrOnc.getAutoConnect = function(properties) {
+  var type = properties.Type;
+  /** @type {!chrome.networkingPrivate.ManagedBoolean|undefined} */
+  var autoconnect;
+  if (type == CrOnc.Type.CELLULAR && properties.Cellular)
+    autoconnect = properties.Cellular.AutoConnect;
+  else if (type == CrOnc.Type.VPN && properties.VPN)
+    autoconnect = properties.VPN.AutoConnect;
+  else if (type == CrOnc.Type.WI_FI && properties.WiFi)
+    autoconnect = properties.WiFi.AutoConnect;
+  else if (type == CrOnc.Type.WI_MAX && properties.WiMAX)
+    autoconnect = properties.WiMAX.AutoConnect;
+  return !!CrOnc.getActiveValue(autoconnect);
+}
+
+/**
  * @param {!CrOnc.NetworkProperties|!CrOnc.NetworkStateProperties|undefined}
  *   properties The ONC network properties or state properties.
  * @return {boolean} True if |properties| is a Cellular network with a