Change to Shill's IPConfig objects.

chromeos/network/onc/onc_translator_shill_to_onc.cc

 // Copyright (c) 2012 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 "chromeos/network/onc/onc_translator.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/json/json_reader.h"
@@ skipping 66 matching lines @@
   void TranslateEthernet();
   void TranslateOpenVPN();
   void TranslateIPsec();
   void TranslateVPN();
   void TranslateWiFiWithState();
   void TranslateWiMAXWithState();
   void TranslateCellularWithState();
   void TranslateCellularDevice();
   void TranslateNetworkWithState();
   void TranslateIPConfig();
-  void TranslateSavedOrStaticIPConfig(const std::string& nameserver_property);
+  void TranslateSavedOrStaticIPConfig();
   void TranslateSavedIPConfig();
   void TranslateStaticIPConfig();
 
   // Creates an ONC object from |dictionary| according to the signature
   // associated to |onc_field_name| and adds it to |onc_object_| at
   // |onc_field_name|.
   void TranslateAndAddNestedObject(const std::string& onc_field_name,
                                    const base::DictionaryValue& dictionary);
 
   // Creates an ONC object from |shill_dictionary_| according to the signature
@@ skipping 374 matching lines @@
   // Shill's Service has an IPConfig property (note the singular), not an
   // IPConfigs property. However, we require the caller of the translation to
   // patch the Shill dictionary before passing it to the translator.
   const base::ListValue* shill_ipconfigs = NULL;
   if (shill_dictionary_->GetListWithoutPathExpansion(shill::kIPConfigsProperty,
                                                      &shill_ipconfigs)) {
     TranslateAndAddListOfObjects(::onc::network_config::kIPConfigs,
                                  *shill_ipconfigs);
   }
 
-  TranslateAndAddNestedObject(::onc::network_config::kSavedIPConfig);
-  TranslateAndAddNestedObject(::onc::network_config::kStaticIPConfig);
+  const base::DictionaryValue* saved_ipconfig = nullptr;
+  if (shill_dictionary_->GetDictionaryWithoutPathExpansion(
+        shill::kSavedIPConfigProperty, &saved_ipconfig)) {
+    TranslateAndAddNestedObject(::onc::network_config::kSavedIPConfig,
+                                *saved_ipconfig);
+  }
+
+  const base::DictionaryValue* static_ipconfig = nullptr;
+  if (shill_dictionary_->GetDictionaryWithoutPathExpansion(
+        shill::kStaticIPConfigProperty, &static_ipconfig)) {
+    TranslateAndAddNestedObject(::onc::network_config::kStaticIPConfig,
+                                *static_ipconfig);
+  }
 }
 
 void ShillToONCTranslator::TranslateIPConfig() {
   CopyPropertiesAccordingToSignature();
   std::string shill_ip_method;
   shill_dictionary_->GetStringWithoutPathExpansion(shill::kMethodProperty,
                                                    &shill_ip_method);
   std::string type;
   if (shill_ip_method == shill::kTypeIPv4 ||
       shill_ip_method == shill::kTypeDHCP) {
     type = ::onc::ipconfig::kIPv4;
   } else if (shill_ip_method == shill::kTypeIPv6 ||
              shill_ip_method == shill::kTypeDHCP6) {
     type = ::onc::ipconfig::kIPv6;
   } else {
     return;  // Ignore unhandled IPConfig types, e.g. bootp, zeroconf, ppp
   }
 
   onc_object_->SetStringWithoutPathExpansion(::onc::ipconfig::kType, type);
 }
 
-void ShillToONCTranslator::TranslateSavedOrStaticIPConfig(
-    const std::string& nameserver_property) {
+void ShillToONCTranslator::TranslateSavedOrStaticIPConfig() {
   CopyPropertiesAccordingToSignature();
-  // Saved/Static IP config nameservers are stored as a comma separated list.
-  std::string shill_nameservers;
-  shill_dictionary_->GetStringWithoutPathExpansion(
-      nameserver_property, &shill_nameservers);
-  std::vector<std::string> onc_nameserver_vector;
-  if (Tokenize(shill_nameservers, ",", &onc_nameserver_vector) > 0) {
-    scoped_ptr<base::ListValue> onc_nameservers(new base::ListValue);
-    for (std::vector<std::string>::iterator iter =
-             onc_nameserver_vector.begin();
-         iter != onc_nameserver_vector.end(); ++iter) {
-      onc_nameservers->AppendString(*iter);
-    }
-    onc_object_->SetWithoutPathExpansion(::onc::ipconfig::kNameServers,
-                                         onc_nameservers.release());
-  }
+
   // Static and Saved IPConfig in Shill are always of type IPv4. Set this type
   // in ONC, but not if the object would be empty except the type.
   if (!onc_object_->empty()) {
     onc_object_->SetStringWithoutPathExpansion(::onc::ipconfig::kType,
                                                ::onc::ipconfig::kIPv4);
   }
 }
 
 void ShillToONCTranslator::TranslateSavedIPConfig() {
-  TranslateSavedOrStaticIPConfig(shill::kSavedIPNameServersProperty);
+  TranslateSavedOrStaticIPConfig();
 }
 
 void ShillToONCTranslator::TranslateStaticIPConfig() {
-  TranslateSavedOrStaticIPConfig(shill::kStaticIPNameServersProperty);
+  TranslateSavedOrStaticIPConfig();
 }
 
 void ShillToONCTranslator::TranslateAndAddNestedObject(
     const std::string& onc_field_name) {
   TranslateAndAddNestedObject(onc_field_name, *shill_dictionary_);
 }
 
 void ShillToONCTranslator::TranslateAndAddNestedObject(
     const std::string& onc_field_name,
     const base::DictionaryValue& dictionary) {
@@ skipping 136 matching lines @@
     ::onc::ONCSource onc_source,
     const OncValueSignature* onc_signature) {
   CHECK(onc_signature != NULL);
 
   ShillToONCTranslator translator(shill_dictionary, onc_source, *onc_signature);
   return translator.CreateTranslatedONCObject();
 }
 
 }  // namespace onc
 }  // namespace chromeos