Add Shill to ONC translation of IPConfig.

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 48 matching lines @@
   scoped_ptr<base::DictionaryValue> CreateTranslatedONCObject();
 
  private:
   void TranslateEthernet();
   void TranslateOpenVPN();
   void TranslateIPsec();
   void TranslateVPN();
   void TranslateWiFiWithState();
   void TranslateCellularWithState();
   void TranslateNetworkWithState();
+  void TranslateIPConfig();
 
   // 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
   // associated to |onc_field_name| and adds it to |onc_object_| at
   // |onc_field_name|.
@@ skipping 45 matching lines @@
   } else if (onc_signature_ == &kVPNSignature) {
     TranslateVPN();
   } else if (onc_signature_ == &kOpenVPNSignature) {
     TranslateOpenVPN();
   } else if (onc_signature_ == &kIPsecSignature) {
     TranslateIPsec();
   } else if (onc_signature_ == &kWiFiWithStateSignature) {
     TranslateWiFiWithState();
   } else if (onc_signature_ == &kCellularWithStateSignature) {
     TranslateCellularWithState();
+  } else if (onc_signature_ == &kIPConfigSignature) {
+    TranslateIPConfig();
   } else {
     CopyPropertiesAccordingToSignature();
   }
   return onc_object_.Pass();
 }
 
 void ShillToONCTranslator::TranslateEthernet() {
   std::string shill_network_type;
   shill_dictionary_->GetStringWithoutPathExpansion(shill::kTypeProperty,
                                                    &shill_network_type);
@@ skipping 103 matching lines @@
   CopyPropertiesAccordingToSignature();
   const base::DictionaryValue* dictionary = NULL;
   if (shill_dictionary_->GetDictionaryWithoutPathExpansion(
         shill::kServingOperatorProperty, &dictionary)) {
     TranslateAndAddNestedObject(::onc::cellular::kServingOperator, *dictionary);
   }
   if (shill_dictionary_->GetDictionaryWithoutPathExpansion(
         shill::kCellularApnProperty, &dictionary)) {
     TranslateAndAddNestedObject(::onc::cellular::kAPN, *dictionary);
   }
-  const base::ListValue* list = NULL;
+  const base::ListValue* shill_apns = NULL;
   if (shill_dictionary_->GetListWithoutPathExpansion(
-          shill::kCellularApnListProperty, &list)) {
-    TranslateAndAddListOfObjects(::onc::cellular::kAPNList, *list);
+          shill::kCellularApnListProperty, &shill_apns)) {
+    TranslateAndAddListOfObjects(::onc::cellular::kAPNList, *shill_apns);
   }
 }
 
 void ShillToONCTranslator::TranslateNetworkWithState() {
   CopyPropertiesAccordingToSignature();
 
   std::string shill_network_type;
   shill_dictionary_->GetStringWithoutPathExpansion(shill::kTypeProperty,
                                                    &shill_network_type);
   std::string onc_network_type = ::onc::network_type::kEthernet;
@@ skipping 21 matching lines @@
                                                        &state)) {
     std::string onc_state = ::onc::connection_state::kNotConnected;
     if (NetworkState::StateIsConnected(state)) {
       onc_state = ::onc::connection_state::kConnected;
     } else if (NetworkState::StateIsConnecting(state)) {
       onc_state = ::onc::connection_state::kConnecting;
     }
     onc_object_->SetStringWithoutPathExpansion(
         ::onc::network_config::kConnectionState, onc_state);
   }
+
+  // Shill's Service has an IPConfig property (note the singular, and not a
+  // 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);
+  }
+}
+
+void ShillToONCTranslator::TranslateIPConfig() {
+  CopyPropertiesAccordingToSignature();
+  std::string shill_ip_method;
+  shill_dictionary_->GetStringWithoutPathExpansion(shill::kMethodProperty,
+                                                   &shill_ip_method);
+  if (shill_ip_method != shill::kTypeIPv4 &&
+      shill_ip_method != shill::kTypeIPv6) {
+    LOG(ERROR) << "Unhandled IPConfig Method value " << shill_ip_method;
+    return;
+  }
+
+  std::string type = ::onc::ipconfig::kIPv4;
+  if (shill_ip_method == shill::kTypeIPv6)
+    type = ::onc::ipconfig::kIPv6;
+  onc_object_->SetStringWithoutPathExpansion(::onc::ipconfig::kType, type);
 }
 
 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 26 matching lines @@
   for (base::ListValue::const_iterator it = list.begin();
        it != list.end(); ++it) {
     const base::DictionaryValue* shill_value = NULL;
     if (!(*it)->GetAsDictionary(&shill_value))
       continue;
     ShillToONCTranslator nested_translator(
         *shill_value,
         *field_signature->value_signature->onc_array_entry_signature);
     scoped_ptr<base::DictionaryValue> nested_object =
         nested_translator.CreateTranslatedONCObject();
+    // If the nested object couldn't be parsed, simply omit it.
     if (nested_object->empty())
-      // The nested object couldn't be parsed, so simply omit it.
       continue;
     result->Append(nested_object.release());
   }
+  // If there are no entries in the list, there is no need to expose this field.
   if (result->empty())
-    // There are no entries in the list, so there is no need to expose this
-    // field.
     return;
   onc_object_->SetWithoutPathExpansion(onc_field_name, result.release());
 }
 
 void ShillToONCTranslator::CopyPropertiesAccordingToSignature() {
   CopyPropertiesAccordingToSignature(onc_signature_);
 }
 
 void ShillToONCTranslator::CopyPropertiesAccordingToSignature(
     const OncValueSignature* value_signature) {
@@ skipping 56 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