ONC: Fix Static-/Saved-/IPConfig.

chromeos/network/onc/onc_translator_onc_to_shill.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.
 
 // The implementation of TranslateONCObjectToShill is structured in two parts:
 // - The recursion through the existing ONC hierarchy
 //     see TranslateONCHierarchy
 // - The local translation of an object depending on the associated signature
 //     see LocalTranslator::TranslateFields
 
 #include "chromeos/network/onc/onc_translator.h"
 
 #include <string>
 
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
+#include "base/strings/string_util.h"
 #include "base/values.h"
 #include "chromeos/network/onc/onc_signature.h"
 #include "chromeos/network/onc/onc_translation_tables.h"
 #include "chromeos/network/shill_property_util.h"
 #include "components/onc/onc_constants.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace chromeos {
 namespace onc {
 
 namespace {
 
+bool ConvertListValueToStringVector(const base::ListValue& string_list,
+                                    std::vector<std::string>* result) {
+  for (size_t i = 0; i < string_list.GetSize(); ++i) {
+    std::string str;
+    if (!string_list.GetString(i, &str))
+      return false;
+    result->push_back(str);
+  }
+  return true;
+}
+
 scoped_ptr<base::StringValue> ConvertValueToString(const base::Value& value) {
   std::string str;
   if (!value.GetAsString(&str))
     base::JSONWriter::Write(&value, &str);
   return make_scoped_ptr(new base::StringValue(str));
 }
 
 // This class is responsible to translate the local fields of the given
 // |onc_object| according to |onc_signature| into |shill_dictionary|. This
 // translation should consider (if possible) only fields of this ONC object and
@@ skipping 12 matching lines @@
 
   void TranslateFields();
 
  private:
   void TranslateEthernet();
   void TranslateOpenVPN();
   void TranslateIPsec();
   void TranslateVPN();
   void TranslateWiFi();
   void TranslateEAP();
+  void TranslateStaticIPConfig();
   void TranslateNetworkConfiguration();
 
   // Copies all entries from |onc_object_| to |shill_dictionary_| for which a
   // translation (shill_property_name) is defined by |onc_signature_|.
   void CopyFieldsAccordingToSignature();
 
   // Adds |value| to |shill_dictionary| at the field shill_property_name given
   // by the associated signature. Takes ownership of |value|. Does nothing if
   // |value| is NULL or the property name cannot be read from the signature.
   void AddValueAccordingToSignature(const std::string& onc_field_name,
@@ skipping 10 matching lines @@
   const FieldTranslationEntry* field_translation_table_;
   const base::DictionaryValue* onc_object_;
   base::DictionaryValue* shill_dictionary_;
 
   DISALLOW_COPY_AND_ASSIGN(LocalTranslator);
 };
 
 void LocalTranslator::TranslateFields() {
   if (onc_signature_ == &kNetworkConfigurationSignature)
     TranslateNetworkConfiguration();
+  else if (onc_signature_ == &kStaticIPConfigSignature)
+    TranslateStaticIPConfig();
   else if (onc_signature_ == &kEthernetSignature)
     TranslateEthernet();
   else if (onc_signature_ == &kVPNSignature)
     TranslateVPN();
   else if (onc_signature_ == &kOpenVPNSignature)
     TranslateOpenVPN();
   else if (onc_signature_ == &kIPsecSignature)
     TranslateIPsec();
   else if (onc_signature_ == &kWiFiSignature)
     TranslateWiFi();
@@ skipping 10 matching lines @@
 
   const char* shill_type = shill::kTypeEthernet;
   if (authentication == ::onc::ethernet::k8021X)
     shill_type = shill::kTypeEthernetEap;
   shill_dictionary_->SetStringWithoutPathExpansion(shill::kTypeProperty,
                                                    shill_type);
 
   CopyFieldsAccordingToSignature();
 }
 
+
+void LocalTranslator::TranslateStaticIPConfig() {
+  const base::ListValue* onc_nameservers = NULL;
+  if (onc_object_->GetListWithoutPathExpansion(::onc::ipconfig::kNameServers,
+                                               &onc_nameservers)) {
+    std::vector<std::string> onc_nameservers_vector;
+    ConvertListValueToStringVector(*onc_nameservers, &onc_nameservers_vector);
+    std::string shill_nameservers = JoinString(onc_nameservers_vector, ',');
+    shill_dictionary_->SetStringWithoutPathExpansion(
+        shill::kStaticIPNameServersProperty, shill_nameservers);
+  }
+
+  CopyFieldsAccordingToSignature();
+}
+
 void LocalTranslator::TranslateOpenVPN() {
   // SaveCredentials needs special handling when translating from Shill -> ONC
   // so handle it explicitly here.
   bool save_credentials;
   if (onc_object_->GetBooleanWithoutPathExpansion(
           ::onc::vpn::kSaveCredentials, &save_credentials)) {
     shill_dictionary_->SetBooleanWithoutPathExpansion(
         shill::kSaveCredentialsProperty, save_credentials);
   }
   // Shill supports only one RemoteCertKU but ONC a list.
@@ skipping 195 matching lines @@
     const OncValueSignature* onc_signature,
     const base::DictionaryValue& onc_object) {
   CHECK(onc_signature != NULL);
   scoped_ptr<base::DictionaryValue> shill_dictionary(new base::DictionaryValue);
   TranslateONCHierarchy(*onc_signature, onc_object, shill_dictionary.get());
   return shill_dictionary.Pass();
 }
 
 }  // namespace onc
 }  // namespace chromeos