cros_network_config.mojom: Use unions for ConfigProperties

This CL uses a unuion for type specific properties in ConfigProperties.

Since the config properties are typically generated on the fly and
passed from UI -> the CrosNetworkConfig implementation, the union
type is used to specify the network type (i.e. no explicit type is
required).

Bug: 853953
Change-Id: I08ae054f8d5554727c4d9422ca325b284c3927e8
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1850724
Commit-Queue: Steven Bennetts <stevenjb@chromium.org>
Reviewed-by: Kyle Horimoto <khorimoto@chromium.org>
Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Cr-Commit-Position: refs/heads/master@{#704740}

chrome/browser/resources/chromeos/internet_detail_dialog/internet_detail_dialog.js

@@ -231,7 +231,7 @@ Polymer({
    * @private
    */
   getDefaultConfigProperties_: function() {
-    return {type: this.managedProperties_.type};
+    return OncMojo.getDefaultConfigProperties(this.managedProperties_.type);
   },
 
   /**
@@ -489,7 +489,7 @@ Polymer({
     }
     const config = this.getDefaultConfigProperties_();
     const apn = event.detail;
-    config.cellular = {apn: apn};
+    config.typeConfig.cellular = {apn: apn};
     this.setMojoNetworkProperties_(config);
   },
 

chrome/browser/resources/settings/internet_page/internet_detail_page.js

@@ -551,7 +551,7 @@ Polymer({
    * @private
    */
   getDefaultConfigProperties_: function() {
-    return {type: this.managedProperties_.type};
+    return OncMojo.getDefaultConfigProperties(this.managedProperties_.type);
   },
 
   /**
@@ -1169,14 +1169,14 @@ Polymer({
     OncMojo.setConfigProperty(config, field, value);
     // Ensure that any required configuration properties for partial
     // configurations are set.
-    if (config.vpn) {
-      config.vpn.type = this.managedProperties_.typeProperties.vpn.type;
-      if (config.vpn.openVpn &&
-          config.vpn.openVpn.saveCredentials == undefined) {
-        config.vpn.openVpn.saveCredentials = false;
+    const vpnConfig = config.typeConfig.vpn;
+    if (vpnConfig) {
+      vpnConfig.type = this.managedProperties_.typeProperties.vpn.type;
+      if (vpnConfig.openVpn && vpnConfig.openVpn.saveCredentials == undefined) {
+        vpnConfig.openVpn.saveCredentials = false;
       }
-      if (config.vpn.l2tp && config.vpn.l2tp.saveCredentials == undefined) {
-        config.vpn.l2tp.saveCredentials = false;
+      if (vpnConfig.l2tp && vpnConfig.l2tp.saveCredentials == undefined) {
+        vpnConfig.l2tp.saveCredentials = false;
       }
     }
     this.setMojoNetworkProperties_(config);
@@ -1192,7 +1192,7 @@ Polymer({
     }
     const config = this.getDefaultConfigProperties_();
     const apn = event.detail;
-    config.cellular = {apn: apn};
+    config.typeConfig.cellular = {apn: apn};
     this.setMojoNetworkProperties_(config);
   },
 

chrome/browser/resources/settings/internet_page/internet_known_networks_page.js

@@ -191,14 +191,18 @@ Polymer({
   /** @private */
   onRemovePreferredTap_: function() {
     assert(this.networkType !== undefined);
-    this.setProperties_({type: this.networkType, priority: {value: 0}});
+    const config = OncMojo.getDefaultConfigProperties(this.networkType);
+    config.priority = {value: 0};
+    this.setProperties_(config);
     /** @type {!CrActionMenuElement} */ (this.$.dotsMenu).close();
   },
 
   /** @private */
   onAddPreferredTap_: function() {
     assert(this.networkType !== undefined);
-    this.setProperties_({type: this.networkType, priority: {value: 1}});
+    const config = OncMojo.getDefaultConfigProperties(this.networkType);
+    config.priority = {value: 1};
+    this.setProperties_(config);
     /** @type {!CrActionMenuElement} */ (this.$.dotsMenu).close();
   },
 

chrome/test/data/webui/cr_components/network_config_test.js

@@ -234,6 +234,10 @@ suite('network-config', function() {
             'PEAP',
             networkConfig.managedProperties.typeProperties.ethernet.eap.outer
                 .activeValue);
+        assertEquals(
+            'PEAP',
+            networkConfig.configProperties_.typeConfig.ethernet.eap.outer);
+        assertEquals('PEAP', networkConfig.eapProperties_.outer);
         let outer = networkConfig.$$('#outer');
         assertTrue(!!outer);
         assertTrue(!outer.disabled);

chromeos/services/network_config/cros_network_config.cc

@@ -503,6 +503,14 @@ void SetString(const char* key,
   dict->SetStringKey(key, *property);
 }
 
+void SetStringIfNotEmpty(const char* key,
+                         const base::Optional<std::string>& property,
+                         base::Value* dict) {
+  if (!property || property->empty())
+    return;
+  dict->SetStringKey(key, *property);
+}
+
 void SetStringList(const char* key,
                    const base::Optional<std::vector<std::string>>& property,
                    base::Value* dict) {
@@ -1446,35 +1454,19 @@ base::Value GetEAPProperties(const mojom::EAPConfigProperties& eap) {
 
 std::unique_ptr<base::DictionaryValue> GetOncFromConfigProperties(
     const mojom::ConfigProperties* properties) {
-  std::string onc_type = MojoNetworkTypeToOnc(properties->type);
-  if (onc_type.empty()) {
-    NET_LOG(ERROR) << "Invalid NetworkConfig properties";
-    return nullptr;
-  }
   auto onc = std::make_unique<base::DictionaryValue>();
 
-  // kType is a required / intrinsic property.
-  SetString(::onc::network_config::kType, onc_type, onc.get());
-
-  // Configurations have only one type dictionary, set below (unless empty).
+  // Process |properties->network_type| and set |type|. Configurations have only
+  // one type dictionary.
+  mojom::NetworkType type = mojom::NetworkType::kAll;  // Invalid type
   base::Value type_dict(base::Value::Type::DICTIONARY);
 
-  // Process remaining |properties| members. Order matches the mojo struct.
-
-  if (properties->auto_connect) {
-    NetworkTypePattern type = MojoTypeToPattern(properties->type);
-    if (type.Equals(NetworkTypePattern::Cellular()) ||
-        type.Equals(NetworkTypePattern::VPN()) ||
-        type.Equals(NetworkTypePattern::WiFi())) {
-      // Note: All type dicts use the same kAutoConnect key.
-      type_dict.SetBoolKey(::onc::wifi::kAutoConnect,
-                           properties->auto_connect->value);
-    }
-  }
-
-  if (properties->cellular) {
-    if (properties->cellular->apn) {
-      const mojom::ApnProperties& apn = *properties->cellular->apn;
+  if (properties->type_config->is_cellular()) {
+    type = mojom::NetworkType::kCellular;
+    const mojom::CellularConfigProperties& cellular =
+        *properties->type_config->get_cellular();
+    if (cellular.apn) {
+      const mojom::ApnProperties& apn = *cellular.apn;
       base::Value apn_dict(base::Value::Type::DICTIONARY);
       apn_dict.SetStringKey(::onc::cellular_apn::kAccessPointName,
                             apn.access_point_name);
@@ -1488,72 +1480,19 @@ std::unique_ptr<base::DictionaryValue> GetOncFromConfigProperties(
       SetString(::onc::cellular_apn::kUsername, apn.username, &apn_dict);
       type_dict.SetKey(::onc::cellular::kAPN, std::move(apn_dict));
     }
-  }
-
-  if (properties->ethernet) {
-    const mojom::EthernetConfigProperties& ethernet = *properties->ethernet;
+  } else if (properties->type_config->is_ethernet()) {
+    type = mojom::NetworkType::kEthernet;
+    const mojom::EthernetConfigProperties& ethernet =
+        *properties->type_config->get_ethernet();
     SetString(::onc::ethernet::kAuthentication, ethernet.authentication,
               &type_dict);
     if (ethernet.eap) {
       type_dict.SetKey(::onc::ethernet::kEAP,
                        GetEAPProperties(*ethernet.eap.get()));
     }
-  }
-
-  if (properties->ip_address_config_type) {
-    onc->SetStringKey(::onc::network_config::kIPAddressConfigType,
-                      *properties->ip_address_config_type);
-  }
-
-  SetString(::onc::network_config::kName, properties->name, onc.get());
-
-  SetString(::onc::network_config::kNameServersConfigType,
-            properties->name_servers_config_type, onc.get());
-
-  if (properties->priority) {
-    onc->SetIntKey(::onc::network_config::kPriority,
-                   properties->priority->value);
-  }
-
-  if (properties->proxy_settings) {
-    const mojom::ProxySettings& proxy = *properties->proxy_settings;
-    base::Value proxy_dict(base::Value::Type::DICTIONARY);
-    proxy_dict.SetStringKey(::onc::proxy::kType, proxy.type);
-    if (proxy.manual) {
-      const mojom::ManualProxySettings& manual = *proxy.manual;
-      base::Value manual_dict(base::Value::Type::DICTIONARY);
-      SetProxyLocation(::onc::proxy::kHttp, manual.http_proxy, &manual_dict);
-      SetProxyLocation(::onc::proxy::kHttps, manual.secure_http_proxy,
-                       &manual_dict);
-      SetProxyLocation(::onc::proxy::kFtp, manual.ftp_proxy, &manual_dict);
-      SetProxyLocation(::onc::proxy::kSocks, manual.socks, &manual_dict);
-      proxy_dict.SetKey(::onc::proxy::kManual, std::move(manual_dict));
-    }
-    SetStringList(::onc::proxy::kExcludeDomains, proxy.exclude_domains,
-                  &proxy_dict);
-    SetString(::onc::proxy::kPAC, proxy.pac, &proxy_dict);
-    onc->SetKey(::onc::network_config::kProxySettings, std::move(proxy_dict));
-  }
-
-  if (properties->static_ip_config) {
-    const mojom::IPConfigProperties& ip_config = *properties->static_ip_config;
-    base::Value ip_config_dict(base::Value::Type::DICTIONARY);
-    SetString(::onc::ipconfig::kGateway, ip_config.gateway, &ip_config_dict);
-    SetString(::onc::ipconfig::kIPAddress, ip_config.ip_address,
-              &ip_config_dict);
-    SetStringList(::onc::ipconfig::kNameServers, ip_config.name_servers,
-                  &ip_config_dict);
-    ip_config_dict.SetIntKey(::onc::ipconfig::kRoutingPrefix,
-                             ip_config.routing_prefix);
-    SetString(::onc::ipconfig::kType, ip_config.type, &ip_config_dict);
-    SetString(::onc::ipconfig::kWebProxyAutoDiscoveryUrl,
-              ip_config.web_proxy_auto_discovery_url, &ip_config_dict);
-    onc->SetKey(::onc::network_config::kStaticIPConfig,
-                std::move(ip_config_dict));
-  }
-
-  if (properties->vpn) {
-    const mojom::VPNConfigProperties& vpn = *properties->vpn;
+  } else if (properties->type_config->is_vpn()) {
+    type = mojom::NetworkType::kVPN;
+    const mojom::VPNConfigProperties& vpn = *properties->type_config->get_vpn();
     SetString(::onc::vpn::kHost, vpn.host, &type_dict);
     if (vpn.ip_sec) {
       const mojom::IPSecConfigProperties& ip_sec = *vpn.ip_sec;
@@ -1609,12 +1548,12 @@ std::unique_ptr<base::DictionaryValue> GetOncFromConfigProperties(
       type_dict.SetKey(::onc::vpn::kOpenVPN, std::move(open_vpn_dict));
     }
     SetString(::onc::vpn::kType, MojoVpnTypeToOnc(vpn.type), &type_dict);
-  }
-
-  if (properties->wifi) {
-    const mojom::WiFiConfigProperties& wifi = *properties->wifi;
+  } else if (properties->type_config->is_wifi()) {
+    type = mojom::NetworkType::kWiFi;
+    const mojom::WiFiConfigProperties& wifi =
+        *properties->type_config->get_wifi();
     SetString(::onc::wifi::kPassphrase, wifi.passphrase, &type_dict);
-    SetString(::onc::wifi::kSSID, wifi.ssid, &type_dict);
+    SetStringIfNotEmpty(::onc::wifi::kSSID, wifi.ssid, &type_dict);
     SetString(::onc::wifi::kPassphrase, wifi.passphrase, &type_dict);
     SetString(::onc::wifi::kSecurity, MojoSecurityTypeToOnc(wifi.security),
               &type_dict);
@@ -1623,6 +1562,78 @@ std::unique_ptr<base::DictionaryValue> GetOncFromConfigProperties(
     }
   }
 
+  std::string onc_type = MojoNetworkTypeToOnc(type);
+  if (onc_type.empty()) {
+    NET_LOG(ERROR) << "Invalid NetworkConfig properties";
+    return nullptr;
+  }
+  SetString(::onc::network_config::kType, onc_type, onc.get());
+
+  // Process other |properties| members. Order matches the mojo struct.
+
+  if (properties->ip_address_config_type) {
+    onc->SetStringKey(::onc::network_config::kIPAddressConfigType,
+                      *properties->ip_address_config_type);
+  }
+
+  SetString(::onc::network_config::kName, properties->name, onc.get());
+
+  SetString(::onc::network_config::kNameServersConfigType,
+            properties->name_servers_config_type, onc.get());
+
+  if (properties->priority) {
+    onc->SetIntKey(::onc::network_config::kPriority,
+                   properties->priority->value);
+  }
+
+  if (properties->proxy_settings) {
+    const mojom::ProxySettings& proxy = *properties->proxy_settings;
+    base::Value proxy_dict(base::Value::Type::DICTIONARY);
+    proxy_dict.SetStringKey(::onc::proxy::kType, proxy.type);
+    if (proxy.manual) {
+      const mojom::ManualProxySettings& manual = *proxy.manual;
+      base::Value manual_dict(base::Value::Type::DICTIONARY);
+      SetProxyLocation(::onc::proxy::kHttp, manual.http_proxy, &manual_dict);
+      SetProxyLocation(::onc::proxy::kHttps, manual.secure_http_proxy,
+                       &manual_dict);
+      SetProxyLocation(::onc::proxy::kFtp, manual.ftp_proxy, &manual_dict);
+      SetProxyLocation(::onc::proxy::kSocks, manual.socks, &manual_dict);
+      proxy_dict.SetKey(::onc::proxy::kManual, std::move(manual_dict));
+    }
+    SetStringList(::onc::proxy::kExcludeDomains, proxy.exclude_domains,
+                  &proxy_dict);
+    SetString(::onc::proxy::kPAC, proxy.pac, &proxy_dict);
+    onc->SetKey(::onc::network_config::kProxySettings, std::move(proxy_dict));
+  }
+
+  if (properties->static_ip_config) {
+    const mojom::IPConfigProperties& ip_config = *properties->static_ip_config;
+    base::Value ip_config_dict(base::Value::Type::DICTIONARY);
+    SetString(::onc::ipconfig::kGateway, ip_config.gateway, &ip_config_dict);
+    SetString(::onc::ipconfig::kIPAddress, ip_config.ip_address,
+              &ip_config_dict);
+    SetStringList(::onc::ipconfig::kNameServers, ip_config.name_servers,
+                  &ip_config_dict);
+    ip_config_dict.SetIntKey(::onc::ipconfig::kRoutingPrefix,
+                             ip_config.routing_prefix);
+    SetString(::onc::ipconfig::kType, ip_config.type, &ip_config_dict);
+    SetString(::onc::ipconfig::kWebProxyAutoDiscoveryUrl,
+              ip_config.web_proxy_auto_discovery_url, &ip_config_dict);
+    onc->SetKey(::onc::network_config::kStaticIPConfig,
+                std::move(ip_config_dict));
+  }
+
+  if (properties->auto_connect) {
+    NetworkTypePattern type_pattern = MojoTypeToPattern(type);
+    if (type_pattern.Equals(NetworkTypePattern::Cellular()) ||
+        type_pattern.Equals(NetworkTypePattern::VPN()) ||
+        type_pattern.Equals(NetworkTypePattern::WiFi())) {
+      // Note: All type dicts use the same kAutoConnect key.
+      type_dict.SetBoolKey(::onc::wifi::kAutoConnect,
+                           properties->auto_connect->value);
+    }
+  }
+
   if (!type_dict.DictEmpty()) {
     onc->SetKey(onc_type, std::move(type_dict));
   }
@@ -1937,8 +1948,9 @@ void CrosNetworkConfig::SetProperties(const std::string& guid,
   // apply the configuration to the EthernetEAP service. Currently we only
   // support configuration of EAP properties or other properties (e.g IP
   // Config), not both.
-  if (network->type() == shill::kTypeEthernet && properties->ethernet &&
-      properties->ethernet->eap) {
+  if (network->type() == shill::kTypeEthernet &&
+      properties->type_config->is_ethernet() &&
+      properties->type_config->get_ethernet()->eap) {
     const NetworkState* eap_state = network_state_handler_->GetEAPForEthernet(
         network->path(), /*connected_only=*/false);
     if (!eap_state) {

chromeos/services/network_config/cros_network_config_unittest.cc

@@ -740,7 +740,8 @@ TEST_F(CrosNetworkConfigTest, SetProperties) {
 
   // Set priority.
   auto config = mojom::ConfigProperties::New();
-  config->type = mojom::NetworkType::kWiFi;
+  config->type_config = mojom::NetworkTypeConfigProperties::NewWifi(
+      mojom::WiFiConfigProperties::New());
   config->priority = mojom::PriorityConfig::New();
   config->priority->value = 1;
   bool success = SetProperties(kGUID, std::move(config));
@@ -757,7 +758,8 @@ TEST_F(CrosNetworkConfigTest, SetProperties) {
 
   // Set auto connect only. Priority should remain unchanged.
   config = mojom::ConfigProperties::New();
-  config->type = mojom::NetworkType::kWiFi;
+  config->type_config = mojom::NetworkTypeConfigProperties::NewWifi(
+      mojom::WiFiConfigProperties::New());
   config->auto_connect = mojom::AutoConnectConfig::New();
   config->auto_connect->value = true;
   success = SetProperties(kGUID, std::move(config));
@@ -780,9 +782,10 @@ TEST_F(CrosNetworkConfigTest, ConfigureNetwork) {
   const std::string ssid = "new_wifi_ssid";
   // Configure a new wifi network.
   auto config = mojom::ConfigProperties::New();
-  config->type = mojom::NetworkType::kWiFi;
-  config->wifi = mojom::WiFiConfigProperties::New();
-  config->wifi->ssid = ssid;
+  auto wifi = mojom::WiFiConfigProperties::New();
+  wifi->ssid = ssid;
+  config->type_config =
+      mojom::NetworkTypeConfigProperties::NewWifi(std::move(wifi));
   std::string guid = ConfigureNetwork(std::move(config), shared);
   EXPECT_FALSE(guid.empty());
 

chromeos/services/network_config/public/mojom/cros_network_config.mojom

@@ -758,10 +758,15 @@ struct WiFiConfigProperties {
   SecurityType security = kNone;
 };
 
+union NetworkTypeConfigProperties {
+  CellularConfigProperties cellular;
+  EthernetConfigProperties ethernet;
+  VPNConfigProperties vpn;
+  WiFiConfigProperties wifi;
+};
+
 struct ConfigProperties {
   AutoConnectConfig? auto_connect;
-  CellularConfigProperties? cellular;
-  EthernetConfigProperties? ethernet;
   string? ip_address_config_type;
   // Name is only required for new configurations.
   string? name;
@@ -769,10 +774,8 @@ struct ConfigProperties {
   PriorityConfig? priority;
   ProxySettings? proxy_settings;
   IPConfigProperties? static_ip_config;
-  // |type| must match the existing configuration when used with SetProperties.
-  NetworkType type;
-  VPNConfigProperties? vpn;
-  WiFiConfigProperties? wifi;
+  // NetworkType is inferred from |type_config|.
+  NetworkTypeConfigProperties type_config;
 };
 
 // Properties provided to SetCellularSimState.

ui/webui/resources/cr_components/chromeos/network/network_config.html

@@ -35,7 +35,7 @@
       <!-- SSID (WiFi) -->
       <template is="dom-if" if="[[isWiFi_(mojoType_)]]" restamp>
         <network-config-input id="ssid" label="[[i18n('OncWiFi-SSID')]]"
-            value="{{configProperties_.wifi.ssid}}"
+            value="{{configProperties_.typeConfig.wifi.ssid}}"
             readonly="[[hasGuid_(guid)]]"
             on-enter="onEnterPressedInInput_">
         </network-config-input>
@@ -58,7 +58,7 @@
           if="[[configRequiresPassphrase_(mojoType_, securityType)]]">
         <network-password-input id="wifi-passphrase"
             label="[[i18n('OncWiFi-Passphrase')]]"
-            value="{{configProperties_.wifi.passphrase}}"
+            value="{{configProperties_.typeConfig.wifi.passphrase}}"
             on-enter="onEnterPressedInInput_"
             property="[[managedProperties_.typeProperties.wifi.passphrase]]">
         </network-password-input>
@@ -67,7 +67,7 @@
       <!-- VPN -->
       <template is="dom-if" if="[[showVpn_]]" restamp>
         <network-config-input label="[[i18n('OncVPN-Host')]]"
-            value="{{configProperties_.vpn.host}}"
+            value="{{configProperties_.typeConfig.vpn.host}}"
             property="[[managedProperties_.typeProperties.vpn.host]]">
         </network-config-input>
         <network-config-input label="[[i18n('OncName')]]"
@@ -81,37 +81,37 @@
         </network-config-select>
         <template is="dom-if" if="[[!showVpn_.OpenVPN]]">
           <network-config-input label="[[i18n('OncVPN-L2TP-Username')]]"
-              value="{{configProperties_.vpn.l2tp.username}}"
+              value="{{configProperties_.typeConfig.vpn.l2tp.username}}"
               property="[[managedProperties_.typeProperties.vpn.l2tp.username]]"
           >
           </network-config-input>
           <network-password-input label="[[i18n('OncVPN-L2TP-Password')]]"
-              value="{{configProperties_.vpn.l2tp.password}}"
+              value="{{configProperties_.typeConfig.vpn.l2tp.password}}"
               property="[[managedProperties_.typeProperties.vpn.l2tp.password]]"
           >
           </network-password-input>
           <network-config-input label="[[i18n('OncVPN-IPsec-Group')]]"
-              value="{{configProperties_.vpn.ipSec.group}}"
+              value="{{configProperties_.typeConfig.vpn.ipSec.group}}"
               property="[[managedProperties_.typeProperties.vpn.ipSec.group]]">
           </network-config-input>
           <template is="dom-if" if="[[!showVpn_.Cert]]">
             <network-password-input label="[[i18n('OncVPN-IPsec-PSK')]]"
-                value="{{configProperties_.vpn.ipSec.psk}}"
+                value="{{configProperties_.typeConfig.vpn.ipSec.psk}}"
                 property="[[managedProperties_.typeProperties.vpn.ipSec.psk]]">
             </network-password-input>
           </template>
         </template>
         <template is="dom-if" if="[[showVpn_.OpenVPN]]">
           <network-config-input label="[[i18n('OncVPN-OpenVPN-Username')]]"
-              value="{{configProperties_.vpn.openVpn.username}}"
+              value="{{configProperties_.typeConfig.vpn.openVpn.username}}"
               property="[[managedProperties_.typeProperties.vpn.openVpn.username]]">
           </network-config-input>
           <network-password-input label="[[i18n('OncVPN-OpenVPN-Password')]]"
-              value="{{configProperties_.vpn.openVpn.password}}"
+              value="{{configProperties_.typeConfig.vpn.openVpn.password}}"
               property="[[managedProperties_.typeProperties.vpn.openVpn.password]]">
           </network-password-input>
           <network-config-input label="[[i18n('OncVPN-OpenVPN-OTP')]]"
-              value="{{configProperties_.vpn.openVpn.otp}}"
+              value="{{configProperties_.typeConfig.vpn.openVpn.otp}}"
               property="[[managedProperties_.typeProperties.vpn.openVpn.otp]]">
           </network-config-input>
         </template>

ui/webui/resources/cr_components/chromeos/network/network_config.js

@@ -315,13 +315,13 @@ Polymer({
     'updateEapCerts_(eapProperties_.*, serverCaCerts_, userCerts_)',
     'updateShowEap_(configProperties_.*, eapProperties_.*, securityType)',
     'updateVpnType_(configProperties_, vpnType_)',
-    'updateVpnIPsecCerts_(vpnType_, configProperties_.vpn.ipSec.*)',
-    'updateOpenVPNCerts_(vpnType_, configProperties_.vpn.openVpn.*)',
+    'updateVpnIPsecCerts_(vpnType_, configProperties_.typeConfig.vpn.ipSec.*)',
+    'updateOpenVPNCerts_(vpnType_, configProperties_.typeConfig.vpn.openVpn.*)',
     // Multiple updateIsConfigured observers for different configurations.
     'updateIsConfigured_(configProperties_.*, securityType)',
     'updateIsConfigured_(configProperties_, eapProperties_.*)',
-    'updateIsConfigured_(configProperties_.wifi.*)',
-    'updateIsConfigured_(configProperties_.vpn.*, vpnType_)',
+    'updateIsConfigured_(configProperties_.typeConfig.wifi.*)',
+    'updateIsConfigured_(configProperties_.typeConfig.vpn.*, vpnType_)',
     'updateIsConfigured_(selectedUserCertHash_)',
   ],
 
@@ -480,7 +480,7 @@ Polymer({
   onNetworkCertificatesChanged: function() {
     this.networkConfig_.getNetworkCertificates().then(response => {
       const isOpenVpn = this.configProperties_.type == mojom.NetworkType.kVPN &&
-          this.configProperties_.vpn.type == mojom.VpnType.kOpenVPN;
+          this.configProperties_.typeConfig.vpn.type == mojom.VpnType.kOpenVPN;
 
       const caCerts = response.serverCas.slice();
       if (!isOpenVpn) {
@@ -742,28 +742,25 @@ Polymer({
     this.vpnType_ = undefined;
 
     const managedProperties = this.managedProperties_;
-    const configProperties = {
-      name: OncMojo.getActiveString(managedProperties.name),
-      type: managedProperties.type,
-    };
+    const configProperties =
+        OncMojo.getDefaultConfigProperties(managedProperties.type);
+    configProperties.name = OncMojo.getActiveString(managedProperties.name);
+
     let autoConnect;
     let security = mojom.SecurityType.kNone;
     switch (managedProperties.type) {
       case mojom.NetworkType.kWiFi:
-        autoConnect = this.getActiveBoolean_(
-            managedProperties.typeProperties.wifi.autoConnect);
-        configProperties.wifi = {
-          passphrase: '',
-          ssid: OncMojo.getActiveString(
-              managedProperties.typeProperties.wifi.ssid),
-          security: managedProperties.typeProperties.wifi.security,
-        };
-        if (managedProperties.typeProperties.wifi.eap) {
-          configProperties.wifi.eap = this.getEAPConfigProperties_(
-              managedProperties.typeProperties.wifi.eap);
+        const wifi = managedProperties.typeProperties.wifi;
+        const configWifi = configProperties.typeConfig.wifi;
+        autoConnect = this.getActiveBoolean_(wifi.autoConnect);
+        configWifi.passphrase = '';
+        configWifi.ssid = OncMojo.getActiveString(wifi.ssid);
+        if (wifi.eap) {
+          configWifi.eap = this.getEAPConfigProperties_(wifi.eap);
         }
-        security = configProperties.wifi.security;
         // updateSecurity_ will ensure that EAP properties are set correctly.
+        security = wifi.security;
+        configWifi.security = security;
         break;
       case mojom.NetworkType.kEthernet:
         autoConnect = this.getActiveBoolean_(
@@ -774,29 +771,24 @@ Polymer({
             undefined;
         security = eap ? mojom.SecurityType.kWpaEap : mojom.SecurityType.kNone;
         const auth = security == mojom.SecurityType.kWpaEap ? '8021X' : 'None';
-        configProperties.ethernet = {
-          authentication: auth,
-          eap: eap,
-        };
+        configProperties.typeConfig.ethernet.authentication = auth;
+        configProperties.typeConfig.ethernet.eap = eap;
         break;
       case mojom.NetworkType.kVPN:
         const vpn = managedProperties.typeProperties.vpn;
         const vpnType = vpn.type;
-        configProperties.vpn = {
-          host: OncMojo.getActiveString(vpn.host),
-          type: vpnType,
-        };
+        const configVpn = configProperties.typeConfig.vpn;
+        configVpn.host = OncMojo.getActiveString(vpn.host);
+        configVpn.type = vpnType;
         if (vpnType == mojom.VpnType.kL2TPIPsec) {
           assert(vpn.ipSec);
-          configProperties.vpn.ipSec =
-              this.getIPSecConfigProperties_(vpn.ipSec);
+          configVpn.ipSec = this.getIPSecConfigProperties_(vpn.ipSec);
           assert(vpn.l2tp);
-          configProperties.vpn.l2tp = this.getL2TPConfigProperties_(vpn.l2tp);
+          configVpn.l2tp = this.getL2TPConfigProperties_(vpn.l2tp);
         } else {
           assert(vpnType == mojom.VpnType.kOpenVPN);
           assert(vpn.openVpn);
-          configProperties.vpn.openVpn =
-              this.getOpenVPNConfigProperties_(vpn.openVpn);
+          configVpn.openVpn = this.getOpenVPNConfigProperties_(vpn.openVpn);
         }
         security = mojom.SecurityType.kNone;
         break;
@@ -827,10 +819,10 @@ Polymer({
     const type = this.mojoType_;
     const security = this.securityType;
     if (type == mojom.NetworkType.kWiFi) {
-      this.configProperties_.wifi.security = security;
+      this.configProperties_.typeConfig.wifi.security = security;
     } else if (type == mojom.NetworkType.kEthernet) {
       const auth = security == mojom.SecurityType.kWpaEap ? '8021X' : 'None';
-      this.configProperties_.ethernet.authentication = auth;
+      this.configProperties_.typeConfig.ethernet.authentication = auth;
     }
     let eap;
     if (security == mojom.SecurityType.kWpaEap) {
@@ -907,13 +899,10 @@ Polymer({
    */
   getEap_: function(properties, opt_create) {
     let eap;
-    switch (properties.type) {
-      case mojom.NetworkType.kWiFi:
-        eap = properties.wifi.eap;
-        break;
-      case mojom.NetworkType.kEthernet:
-        eap = properties.ethernet.eap;
-        break;
+    if (properties.typeConfig.wifi) {
+      eap = properties.typeConfig.wifi.eap;
+    } else if (properties.typeConfig.ethernet) {
+      eap = properties.typeConfig.ethernet.eap;
     }
     if (opt_create) {
       return eap || {
@@ -931,10 +920,10 @@ Polymer({
   setEap_: function(eapProperties) {
     switch (this.mojoType_) {
       case mojom.NetworkType.kWiFi:
-        this.configProperties_.wifi.eap = eapProperties;
+        this.configProperties_.typeConfig.wifi.eap = eapProperties;
         break;
       case mojom.NetworkType.kEthernet:
-        this.configProperties_.ethernet.eap = eapProperties;
+        this.configProperties_.typeConfig.ethernet.eap = eapProperties;
         break;
     }
     this.set('eapProperties_', eapProperties);
@@ -964,7 +953,7 @@ Polymer({
    * @private
    */
   getVpnTypeFromProperties_: function(properties) {
-    const vpn = properties.vpn;
+    const vpn = properties.typeConfig.vpn;
     assert(vpn);
     if (vpn.type == mojom.VpnType.kL2TPIPsec) {
       return vpn.ipSec.authenticationType == 'Cert' ?
@@ -980,7 +969,7 @@ Polymer({
       return;
     }
 
-    const vpn = this.configProperties_.vpn;
+    const vpn = this.configProperties_.typeConfig.vpn;
     if (!vpn) {
       this.showVpn_ = null;
       this.updateCertError_();
@@ -1039,7 +1028,7 @@ Polymer({
     if (this.vpnType_ != VPNConfigType.L2TP_IPSEC_CERT) {
       return;
     }
-    const ipSec = this.configProperties_.vpn.ipSec;
+    const ipSec = this.configProperties_.typeConfig.vpn.ipSec;
     const pem = ipSec.serverCaPems ? ipSec.serverCaPems[0] : undefined;
     const certId =
         ipSec.clientCertType == 'PKCS11Id' ? ipSec.clientCertPkcs11Id : '';
@@ -1051,7 +1040,7 @@ Polymer({
     if (this.vpnType_ != VPNConfigType.OPEN_VPN) {
       return;
     }
-    const openVpn = this.configProperties_.vpn.openVpn;
+    const openVpn = this.configProperties_.typeConfig.vpn.openVpn;
     const pem = openVpn.serverCaPems ? openVpn.serverCaPems[0] : undefined;
     const certId =
         openVpn.clientCertType == 'PKCS11Id' ? openVpn.clientCertPkcs11Id : '';
@@ -1210,11 +1199,11 @@ Polymer({
     }
 
     if (type == mojom.NetworkType.kWiFi) {
-      if (!this.configProperties_.wifi.ssid) {
+      if (!this.configProperties_.typeConfig.wifi.ssid) {
         return false;
       }
       if (this.configRequiresPassphrase_(type, this.securityType)) {
-        const passphrase = this.configProperties_.wifi.passphrase;
+        const passphrase = this.configProperties_.typeConfig.wifi.passphrase;
         if (!passphrase || passphrase.length < this.MIN_PASSPHRASE_LENGTH) {
           return false;
         }
@@ -1390,7 +1379,7 @@ Polymer({
    * @private
    */
   vpnIsConfigured_: function() {
-    const vpn = this.configProperties_.vpn;
+    const vpn = this.configProperties_.typeConfig.vpn;
     if (!this.configProperties_.name || !vpn || !vpn.host) {
       return false;
     }
@@ -1425,16 +1414,17 @@ Polymer({
       this.setEapProperties_(eap);
     }
     if (this.mojoType_ == mojom.NetworkType.kVPN) {
+      const vpnConfig = propertiesToSet.typeConfig.vpn;
       // VPN.Host can be an IP address but will not be recognized as such if
       // there is initial whitespace, so trim it.
-      if (propertiesToSet.vpn.host != undefined) {
-        propertiesToSet.vpn.host = propertiesToSet.vpn.host.trim();
+      if (vpnConfig.host != undefined) {
+        vpnConfig.host = vpnConfig.host.trim();
       }
-      if (propertiesToSet.vpn.type == mojom.VpnType.kOpenVPN) {
+      if (vpnConfig.type == mojom.VpnType.kOpenVPN) {
         this.setOpenVPNProperties_(propertiesToSet);
         delete propertiesToSet.ipSec;
         delete propertiesToSet.l2tp;
-      } else if (propertiesToSet.vpn.type == mojom.VpnType.kL2TPIPsec) {
+      } else if (vpnConfig.type == mojom.VpnType.kL2TPIPsec) {
         this.setVpnIPsecProperties_(propertiesToSet);
         delete propertiesToSet.openVpn;
       }
@@ -1488,7 +1478,7 @@ Polymer({
    * @private
    */
   setOpenVPNProperties_: function(propertiesToSet) {
-    const openVpn = propertiesToSet.vpn.openVpn;
+    const openVpn = propertiesToSet.typeConfig.vpn.openVpn;
     assert(!!openVpn);
 
     openVpn.serverCaPems = this.getServerCaPems_();
@@ -1507,7 +1497,7 @@ Polymer({
     }
 
     openVpn.saveCredentials = this.vpnSaveCredentials_;
-    propertiesToSet.vpn.openVpn = openVpn;
+    propertiesToSet.typeConfig.vpn.openVpn = openVpn;
   },
 
   /**
@@ -1515,7 +1505,7 @@ Polymer({
    * @private
    */
   setVpnIPsecProperties_: function(propertiesToSet) {
-    const vpn = propertiesToSet.vpn;
+    const vpn = propertiesToSet.typeConfig.vpn;
     assert(vpn.ipSec);
     assert(vpn.l2tp);
 

ui/webui/resources/js/chromeos/onc_mojo.js

@@ -663,7 +663,7 @@ class OncMojo {
    * @param {!chromeos.networkConfig.mojom.NetworkType} type
    * @param {string} guid
    * @param {string} name
-   * @return {chromeos.networkConfig.mojom.ManagedProperties}
+   * @return {!chromeos.networkConfig.mojom.ManagedProperties}
    */
   static getDefaultManagedProperties(type, guid, name) {
     const mojom = chromeos.networkConfig.mojom;
@@ -728,6 +728,34 @@ class OncMojo {
     return result;
   }
 
+  /**
+   * Returns a ConfigProperties object with a default networkType struct
+   * based on |type|.
+   * @param {!chromeos.networkConfig.mojom.NetworkType} type
+   * @return {!chromeos.networkConfig.mojom.ConfigProperties}
+   */
+  static getDefaultConfigProperties(type) {
+    const mojom = chromeos.networkConfig.mojom;
+    switch (type) {
+      case mojom.NetworkType.kCellular:
+        return {typeConfig: {cellular: {}}};
+        break;
+      case mojom.NetworkType.kEthernet:
+        return {typeConfig: {ethernet: {authentication: 'None'}}};
+        break;
+      case mojom.NetworkType.kVPN:
+        return {typeConfig: {vpn: {type: mojom.VpnType.kOpenVPN}}};
+        break;
+      case mojom.NetworkType.kWiFi:
+        return {
+          typeConfig: {wifi: {ssid: '', security: mojom.SecurityType.kNone}}
+        };
+        break;
+    }
+    assertNotReached('Unexpected type: ' + type.toString());
+    return {typeConfig: {}};
+  }
+
   /**
    * Sets the value of a property in an mojo config dictionary.
    * @param {!chromeos.networkConfig.mojom.ConfigProperties} config
@@ -931,7 +959,7 @@ class OncMojo {
     }
 
     // Set ONC IP config properties to existing values + new values.
-    const config = {type: managedProperties.type};
+    const config = OncMojo.getDefaultConfigProperties(managedProperties.type);
     config.ipAddressConfigType = ipConfigType;
     config.nameServersConfigType = nsConfigType;
     if (ipConfigType == 'Static') {