This adds Cellular to the Shill to ONC translation.

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
 
@@ skipping 104 matching lines @@
     } else {
       // Shill wants all Provider/VPN fields to be strings.
       translated = ConvertValueToString(it.value());
     }
     AddValueAccordingToSignature(it.key(), translated.Pass());
   }
 }
 
 void LocalTranslator::TranslateVPN() {
   std::string type;
-  onc_object_->GetStringWithoutPathExpansion(kType, &type);
+  onc_object_->GetStringWithoutPathExpansion(network_config::kType, &type);

[pneubeck (no reviews), 2013/01/18 10:27:41]

vpn::kType

[Greg Spencer (Chromium), 2013/01/18 22:27:44]

Done.

   TranslateWithTableAndSet(type, kVPNTypeTable,
                            flimflam::kProviderTypeProperty);
 
   CopyFieldsAccordingToSignature();
 }
 
 void LocalTranslator::TranslateWiFi() {
   std::string security;
   onc_object_->GetStringWithoutPathExpansion(wifi::kSecurity, &security);
   TranslateWithTableAndSet(security, kWiFiSecurityTable,
@@ skipping 19 matching lines @@
           outer == eap::kPEAP ? kEAP_PEAP_InnerTable : kEAP_TTLS_InnerTable;
       TranslateWithTableAndSet(inner, table, flimflam::kEapPhase2AuthProperty);
     }
   }
 
   CopyFieldsAccordingToSignature();
 }
 
 void LocalTranslator::TranslateNetworkConfiguration() {
   std::string type;
-  onc_object_->GetStringWithoutPathExpansion(kType, &type);
+  onc_object_->GetStringWithoutPathExpansion(network_config::kType, &type);
   TranslateWithTableAndSet(type, kNetworkTypeTable, flimflam::kTypeProperty);
 
   // Shill doesn't allow setting the name for non-VPN networks.
-  if (type == kVPN) {
+  if (type == network_type::kVPN) {
     std::string name;
-    onc_object_->GetStringWithoutPathExpansion(kName, &name);
+    onc_object_->GetStringWithoutPathExpansion(network_config::kName, &name);
     shill_dictionary_->SetStringWithoutPathExpansion(
         flimflam::kNameProperty, name);
   }
 
   CopyFieldsAccordingToSignature();
 }
 
 void LocalTranslator::CopyFieldsAccordingToSignature() {
   for (base::DictionaryValue::Iterator it(*onc_object_); it.HasNext();
        it.Advance()) {
@@ skipping 14 matching lines @@
     return;
 
   shill_dictionary_->SetWithoutPathExpansion(
       field_signature->shill_property_name, value.release());
 }
 
 void LocalTranslator::TranslateWithTableAndSet(
     const std::string& onc_value,
     const StringTranslationEntry table[],
     const std::string& shill_property_name) {
-  for (int i = 0; table[i].onc_value != NULL; ++i) {
-    if (onc_value != table[i].onc_value)
-      continue;
+  std::string shill_value;
+  if (TranslateStringToShill(table, onc_value, &shill_value)) {
     shill_dictionary_->SetStringWithoutPathExpansion(shill_property_name,
-                                                     table[i].shill_value);
+                                                     shill_value);
     return;
   }
   // As we previously validate ONC, this case should never occur. If it still
   // occurs, we should check here. Otherwise the failure will only show up much
   // later in Shill.
-  LOG(ERROR) << "Value '" << onc_value << "cannot be translated to Shill";
+  LOG(ERROR) << "Value '" << onc_value
+             << " cannot be translated to Shill property "
+             << shill_property_name;
 }
 
 // Iterates recursively over |onc_object| and its |signature|. At each object
 // applies the local translation using LocalTranslator::TranslateFields. The
 // results are written to |shill_dictionary|.
 void TranslateONCHierarchy(const OncValueSignature& signature,
                            const base::DictionaryValue& onc_object,
                            base::DictionaryValue* shill_dictionary) {
   // Translates fields of |onc_object| and writes them to |shill_dictionary_|.
   LocalTranslator translator(signature, onc_object, shill_dictionary);
@@ skipping 20 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