Resubmit CL. See 8429004.

chrome/browser/chromeos/cros/onc_network_parser.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/chromeos/cros/onc_network_parser.h"
 
 #include "base/base64.h"
 #include "base/json/json_value_serializer.h"
 #include "base/stringprintf.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/cros/native_network_constants.h"
+#include "chrome/browser/chromeos/cros/native_network_parser.h"
 #include "chrome/browser/chromeos/cros/network_library.h"
 #include "net/base/cert_database.h"
 #include "net/base/crypto_module.h"
 #include "net/base/net_errors.h"
 #include "net/base/x509_certificate.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace chromeos {
 
 // Local constants.
 namespace {
 
 EnumMapper<PropertyIndex>::Pair property_index_table[] = {
     { "GUID", PROPERTY_INDEX_GUID },
     { "Name", PROPERTY_INDEX_NAME },
     { "Remove", PROPERTY_INDEX_REMOVE },
     { "ProxyURL", PROPERTY_INDEX_PROXY_CONFIG },
     { "Type", PROPERTY_INDEX_TYPE },
-    { "SSID", PROPERTY_INDEX_NAME },
+    { "SSID", PROPERTY_INDEX_SSID },
     { "Passphrase", PROPERTY_INDEX_PASSPHRASE },
     { "AutoConnect", PROPERTY_INDEX_AUTO_CONNECT },
     { "HiddenSSID", PROPERTY_INDEX_HIDDEN_SSID },
     { "Security", PROPERTY_INDEX_SECURITY },
     { "EAP", PROPERTY_INDEX_EAP },
     { "Outer", PROPERTY_INDEX_EAP_METHOD },
     { "Inner", PROPERTY_INDEX_EAP_PHASE_2_AUTH },
     { "UseSystemCAs", PROPERTY_INDEX_EAP_USE_SYSTEM_CAS },
     { "ServerCARef", PROPERTY_INDEX_EAP_CA_CERT },
     { "ClientCARef", PROPERTY_INDEX_EAP_CLIENT_CERT },
@@ skipping 101 matching lines @@
   if (cert_type == "Client") {
     return ParseClientCertificate(cert_index, certificate);
   }
 
   LOG(WARNING) << "ONC File: certificate of unknown type: " << cert_type
                << " at index " << cert_index;
   return false;
 }
 
 Network* OncNetworkParser::ParseNetwork(int n) {
-  // TODO(chocobo): Change this to parse network into a dictionary.
   if (!network_configs_)
     return NULL;
   DictionaryValue* info = NULL;
   if (!network_configs_->GetDictionary(n, &info))
     return NULL;
   // Parse Open Network Configuration blob into a temporary Network object.
   return CreateNetworkFromInfo(std::string(), *info);
 }
 
 Network* OncNetworkParser::CreateNetworkFromInfo(
     const std::string& service_path,
     const DictionaryValue& info) {
   ConnectionType type = ParseTypeFromDictionary(info);
   if (type == TYPE_UNKNOWN)  // Return NULL if cannot parse network type.
     return NULL;
   scoped_ptr<Network> network(CreateNewNetwork(type, service_path));
+  // Update property with native value for type.
+  std::string str = NativeNetworkParser::network_type_mapper()->GetKey(type);
+  scoped_ptr<StringValue> val(Value::CreateStringValue(str));
+  network->UpdatePropertyMap(PROPERTY_INDEX_TYPE, *val.get());
 
   // Get the child dictionary with properties for the network.
   // And copy all the values from this network type dictionary to parent.
   DictionaryValue* dict;
   if (!info.GetDictionary(GetTypeFromDictionary(info), &dict))
     return NULL;
 
+  // Add GUID from the parent dictionary.
+  dict->SetString("GUID", GetGuidFromDictionary(info));
+
   UpdateNetworkFromInfo(*dict, network.get());
   VLOG(2) << "Created Network '" << network->name()
           << "' from info. Path:" << service_path
           << " Type:" << ConnectionTypeToString(type);
   return network.release();
 }
 
 Network* OncNetworkParser::CreateNewNetwork(
     ConnectionType type, const std::string& service_path) {
   Network* network = NetworkParser::CreateNewNetwork(type, service_path);
@@ skipping 15 matching lines @@
   return ParseType(GetTypeFromDictionary(info));
 }
 
 std::string OncNetworkParser::GetTypeFromDictionary(
     const base::DictionaryValue& info) {
   std::string type_string;
   info.GetString("Type", &type_string);
   return type_string;
 }
 
+std::string OncNetworkParser::GetGuidFromDictionary(
+    const base::DictionaryValue& info) {
+  std::string guid_string;
+  info.GetString("GUID", &guid_string);
+  return guid_string;
+}
+
 bool OncNetworkParser::ParseServerOrCaCertificate(
     int cert_index,
     const std::string& cert_type,
     base::DictionaryValue* certificate) {
   net::CertDatabase cert_database;
   bool web_trust = false;
   base::ListValue* trust_list = NULL;
   if (certificate->GetList("Trust", &trust_list)) {
     for (size_t i = 0; i < trust_list->GetSize(); ++i) {
       std::string trust_type;
@@ skipping 111 matching lines @@
 
 OncWifiNetworkParser::OncWifiNetworkParser() {}
 OncWifiNetworkParser::~OncWifiNetworkParser() {}
 
 bool OncWifiNetworkParser::ParseValue(PropertyIndex index,
                                       const base::Value& value,
                                       Network* network) {
   DCHECK_EQ(TYPE_WIFI, network->type());
   WifiNetwork* wifi_network = static_cast<WifiNetwork*>(network);
   switch (index) {
-    case PROPERTY_INDEX_NAME: {
-      return OncWirelessNetworkParser::ParseValue(index, value, network);
+    case PROPERTY_INDEX_SSID: {
+      std::string ssid;
+      if (!value.GetAsString(&ssid))
+        break;
+      wifi_network->SetName(ssid);
+      return true;
     }
     case PROPERTY_INDEX_GUID: {
       std::string unique_id;
       if (!value.GetAsString(&unique_id))
         break;
       wifi_network->set_unique_id(unique_id);
       return true;
     }
     case PROPERTY_INDEX_SECURITY: {
       std::string security_string;
       if (!value.GetAsString(&security_string))
         break;
-      wifi_network->set_encryption(ParseSecurity(security_string));
+      ConnectionSecurity security = ParseSecurity(security_string);
+      wifi_network->set_encryption(security);
+      // Also update property with native value for security.
+      std::string str =
+          NativeNetworkParser::network_security_mapper()->GetKey(security);
+      scoped_ptr<StringValue> val(Value::CreateStringValue(str));
+      wifi_network->UpdatePropertyMap(index, *val.get());
       return true;
     }
     case PROPERTY_INDEX_PASSPHRASE: {
       std::string passphrase;
       if (!value.GetAsString(&passphrase))
         break;
       wifi_network->set_passphrase(passphrase);
       return true;
     }
     case PROPERTY_INDEX_IDENTITY: {
       std::string identity;
       if (!value.GetAsString(&identity))
         break;
       wifi_network->set_identity(identity);
       return true;
     }
     case PROPERTY_INDEX_EAP: {
       DCHECK_EQ(value.GetType(), Value::TYPE_DICTIONARY);
       const DictionaryValue& dict = static_cast<const DictionaryValue&>(value);
       for (DictionaryValue::key_iterator iter = dict.begin_keys();
            iter != dict.end_keys(); ++iter) {
         const std::string& key = *iter;
         base::Value* eap_value;
         bool res = dict.GetWithoutPathExpansion(key, &eap_value);
         DCHECK(res);
         if (res) {
           PropertyIndex index = mapper().Get(key);
+          wifi_network->UpdatePropertyMap(index, *eap_value);
           if (!ParseEAPValue(index, *eap_value, wifi_network))
             VLOG(1) << network->name() << ": EAP unhandled key: " << key
                     << " Type: " << eap_value->GetType();
         }
       }
       return true;
     }
     default:
       return OncWirelessNetworkParser::ParseValue(index, value, network);
   }
   return false;
 }
 
 
 bool OncWifiNetworkParser::ParseEAPValue(PropertyIndex index,
                                          const base::Value& value,
                                          WifiNetwork* wifi_network) {
   switch (index) {
     case PROPERTY_INDEX_EAP_IDENTITY: {
       std::string eap_identity;
       if (!value.GetAsString(&eap_identity))
         break;
       wifi_network->set_eap_identity(eap_identity);
       return true;
     }
     case PROPERTY_INDEX_EAP_METHOD: {
-      std::string eap_method;
-      if (!value.GetAsString(&eap_method))
+      std::string eap_method_str;
+      if (!value.GetAsString(&eap_method_str))
         break;
-      wifi_network->set_eap_method(ParseEAPMethod(eap_method));
+      EAPMethod eap_method = ParseEAPMethod(eap_method_str);
+      wifi_network->set_eap_method(eap_method);
+      // Also update property with native value for EAP method.
+      std::string str =
+          NativeNetworkParser::network_eap_method_mapper()->GetKey(eap_method);
+      scoped_ptr<StringValue> val(Value::CreateStringValue(str));
+      wifi_network->UpdatePropertyMap(index, *val.get());
       return true;
     }
     case PROPERTY_INDEX_EAP_PHASE_2_AUTH: {
-      std::string eap_phase_2_auth;
-      if (!value.GetAsString(&eap_phase_2_auth))
+      std::string eap_phase_2_auth_str;
+      if (!value.GetAsString(&eap_phase_2_auth_str))
         break;
-      wifi_network->set_eap_phase_2_auth(ParseEAPPhase2Auth(eap_phase_2_auth));
+      EAPPhase2Auth eap_phase_2_auth = ParseEAPPhase2Auth(eap_phase_2_auth_str);
+      wifi_network->set_eap_phase_2_auth(eap_phase_2_auth);
+      // Also update property with native value for EAP phase 2 auth.
+      std::string str = NativeNetworkParser::network_eap_auth_mapper()->GetKey(
+          eap_phase_2_auth);
+      scoped_ptr<StringValue> val(Value::CreateStringValue(str));
+      wifi_network->UpdatePropertyMap(index, *val.get());
       return true;
     }
     case PROPERTY_INDEX_EAP_ANONYMOUS_IDENTITY: {
       std::string eap_anonymous_identity;
       if (!value.GetAsString(&eap_anonymous_identity))
         break;
       wifi_network->set_eap_anonymous_identity(eap_anonymous_identity);
       return true;
     }
     case PROPERTY_INDEX_EAP_CERT_ID: {
@@ skipping 202 matching lines @@
   static EnumMapper<ProviderType>::Pair table[] = {
     { flimflam::kProviderL2tpIpsec, PROVIDER_TYPE_L2TP_IPSEC_PSK },
     { flimflam::kProviderOpenVpn, PROVIDER_TYPE_OPEN_VPN },
   };
   CR_DEFINE_STATIC_LOCAL(EnumMapper<ProviderType>, parser,
       (table, arraysize(table), PROVIDER_TYPE_MAX));
   return parser.Get(type);
 }
 
 }  // namespace chromeos