Use GetManagedProperties in InternetOptionsHandler

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 95 matching lines @@
   // base signatures.
   void CopyPropertiesAccordingToSignature(
       const OncValueSignature* value_signature);
 
   // Applies function CopyProperty to each field of |onc_signature_| and its
   // base signatures.
   void CopyPropertiesAccordingToSignature();
 
   // If |shill_property_name| is defined in |field_signature|, copies this
   // entry from |shill_dictionary_| to |onc_object_| if it exists.
   void CopyProperty(const OncFieldSignature* field_signature);

[armansito, 2014/09/03 21:45:02]

Can you include the new fields below in the unit tests?

[stevenjb, 2014/09/08 18:14:11]

Addressed in a separate CL.

 
+  // If |shill_property_name| exists in |shill_dictionary_|, copy it to
+  // |onc_field_name| in |dictionary|.
+  void CopyPropertyToDictionary(const std::string& shill_property_name,
+                                const std::string& onc_field_name,
+                                base::DictionaryValue* dictionary);
+
   // If existent, translates the entry at |shill_property_name| in
   // |shill_dictionary_| using |table|. It is an error if no matching table
   // entry is found. Writes the result as entry at |onc_field_name| in
   // |onc_object_|.
   void TranslateWithTableAndSet(const std::string& shill_property_name,
                                 const StringTranslationEntry table[],
                                 const std::string& onc_field_name);
 
   // Returns the name of the Shill service provided in |shill_dictionary_|
   // for debugging.
@@ skipping 289 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);
   }
+
+  // Convert StaticIP and SavedIP properties to dictionary format.
+  scoped_ptr<base::DictionaryValue> static_ip(new base::DictionaryValue);
+  CopyPropertyToDictionary(shill::kStaticIPAddressProperty,
+                           ::onc::ipconfig::kIPAddress,
+                           static_ip.get());
+  CopyPropertyToDictionary(shill::kStaticIPGatewayProperty,
+                           ::onc::ipconfig::kGateway,
+                           static_ip.get());
+  CopyPropertyToDictionary(shill::kStaticIPNameServersProperty,
+                           ::onc::ipconfig::kNameServers,
+                           static_ip.get());
+  CopyPropertyToDictionary(shill::kStaticIPPrefixlenProperty,
+                           ::onc::ipconfig::kRoutingPrefix,
+                           static_ip.get());
+  if (!static_ip->empty()) {
+    onc_object_->SetWithoutPathExpansion(::onc::network_config::kStaticIPConfig,
+                                         static_ip.release());
+  }
+
+  scoped_ptr<base::DictionaryValue> saved_ip(new base::DictionaryValue);
+  CopyPropertyToDictionary(shill::kSavedIPAddressProperty,
+                           ::onc::ipconfig::kIPAddress,
+                           saved_ip.get());
+  CopyPropertyToDictionary(shill::kSavedIPGatewayProperty,
+                           ::onc::ipconfig::kGateway,
+                           saved_ip.get());
+  CopyPropertyToDictionary(shill::kSavedIPNameServersProperty,
+                           ::onc::ipconfig::kNameServers,
+                           saved_ip.get());
+  CopyPropertyToDictionary(shill::kSavedIPPrefixlenProperty,
+                           ::onc::ipconfig::kRoutingPrefix,
+                           saved_ip.get());
+  if (!saved_ip->empty()) {
+    onc_object_->SetWithoutPathExpansion(::onc::network_config::kSavedIPConfig,
+                                         saved_ip.release());
+  }
 }
 
 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) {
@@ skipping 113 matching lines @@
                << "' requires type "
                << field_signature->value_signature->onc_type
                << ": " << GetName();
     return;
   }
 
  onc_object_->SetWithoutPathExpansion(field_signature->onc_field_name,
                                       shill_value->DeepCopy());
 }
 
+void ShillToONCTranslator::CopyPropertyToDictionary(
+    const std::string& shill_property_name,
+    const std::string& onc_field_name,
+    base::DictionaryValue* dictionary) {
+  const base::Value* shill_value;
+  if (!shill_dictionary_->GetWithoutPathExpansion(shill_property_name,
+                                                  &shill_value)) {
+    return;
+  }
+  dictionary->SetWithoutPathExpansion(onc_field_name,
+                                      shill_value->DeepCopy());
+}
+
 void ShillToONCTranslator::TranslateWithTableAndSet(
     const std::string& shill_property_name,
     const StringTranslationEntry table[],
     const std::string& onc_field_name) {
   std::string shill_value;
   if (!shill_dictionary_->GetStringWithoutPathExpansion(shill_property_name,
                                                         &shill_value)) {
     return;
   }
   std::string onc_value;
@@ skipping 18 matching lines @@
     const base::DictionaryValue& shill_dictionary,
     const OncValueSignature* onc_signature) {
   CHECK(onc_signature != NULL);
 
   ShillToONCTranslator translator(shill_dictionary, *onc_signature);
   return translator.CreateTranslatedONCObject();
 }
 
 }  // namespace onc
 }  // namespace chromeos