Correctly translate Cellular Device properties to ONC

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 @@
   // given signature.
   scoped_ptr<base::DictionaryValue> CreateTranslatedONCObject();
 
  private:
   void TranslateEthernet();
   void TranslateOpenVPN();
   void TranslateIPsec();
   void TranslateVPN();
   void TranslateWiFiWithState();
   void TranslateCellularWithState();
+  void TranslateCellularDevice();
   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
@@ skipping 47 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_ == &kCellularDeviceSignature) {
+    TranslateCellularDevice();
   } else if (onc_signature_ == &kIPConfigSignature) {
     TranslateIPConfig();
   } else {
     CopyPropertiesAccordingToSignature();
   }
   return onc_object_.Pass();
 }
 
 void ShillToONCTranslator::TranslateEthernet() {
   std::string shill_network_type;
@@ skipping 105 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);
   }
+  // Merge the Device dictionary with this one (Cellular) using the
+  // CellularDevice signiture.

[pneubeck (no reviews), 2014/07/21 08:21:53]

typo: signiture -> signature

[stevenjb, 2014/07/22 18:29:33]

Done.

+  const base::DictionaryValue* device_dictionary = NULL;
+  if (!shill_dictionary_->GetDictionaryWithoutPathExpansion(
+          shill::kDeviceProperty, &device_dictionary)) {
+    return;
+  }
+  ShillToONCTranslator nested_translator(*device_dictionary,
+                                         kCellularDeviceSignature);

[pneubeck (no reviews), 2014/07/21 08:31:04]

how about using kCellularWithStateSignature here again
but additionally passing it the translation table |cellular_device_fields| to
use (you will have to adapt the constructor to set a custom translation table) ?

[stevenjb, 2014/07/22 18:29:33]

I'm not sure I follow.

+  scoped_ptr<base::DictionaryValue> nested_object =
+      nested_translator.CreateTranslatedONCObject();
+  onc_object_->MergeDictionary(nested_object.get());
+}
+
+void ShillToONCTranslator::TranslateCellularDevice() {
+  CopyPropertiesAccordingToSignature();
+  const base::DictionaryValue* dictionary = NULL;

[pneubeck (no reviews), 2014/07/21 08:21:53]

nit: dictionary -> shill_sim_lock

[stevenjb, 2014/07/22 18:29:33]

Done.

+  if (shill_dictionary_->GetDictionaryWithoutPathExpansion(
+          shill::kSIMLockStatusProperty, &dictionary)) {
+    TranslateAndAddNestedObject(::onc::cellular::kSIMLockStatus, *dictionary);
+  }
   const base::ListValue* shill_apns = NULL;
   if (shill_dictionary_->GetListWithoutPathExpansion(
           shill::kCellularApnListProperty, &shill_apns)) {
     TranslateAndAddListOfObjects(::onc::cellular::kAPNList, *shill_apns);
   }
-
-  const base::DictionaryValue* device_dictionary = NULL;
-  if (!shill_dictionary_->GetDictionaryWithoutPathExpansion(
-          shill::kDeviceProperty, &device_dictionary)) {
-    return;
-  }
-
-  // Iterate through all fields of the CellularWithState signature and copy
-  // values from the device properties according to the separate
-  // CellularDeviceTable.
-  for (const OncFieldSignature* field_signature = onc_signature_->fields;
-       field_signature->onc_field_name != NULL; ++field_signature) {
-    const std::string& onc_field_name = field_signature->onc_field_name;
-
-    std::string shill_property_name;
-    const base::Value* shill_value = NULL;
-    if (!GetShillPropertyName(field_signature->onc_field_name,
-                              kCellularDeviceTable,
-                              &shill_property_name) ||
-        !device_dictionary->GetWithoutPathExpansion(shill_property_name,
-                                                    &shill_value)) {
-      continue;
-    }
-    onc_object_->SetWithoutPathExpansion(onc_field_name,
-                                         shill_value->DeepCopy());
+  const base::ListValue* shill_found_networks = NULL;
+  if (shill_dictionary_->GetListWithoutPathExpansion(
+          shill::kFoundNetworksProperty, &shill_found_networks)) {
+    TranslateAndAddListOfObjects(::onc::cellular::kFoundNetworks,
+                                 *shill_found_networks);
   }
 }
 
 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 192 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