Separating ONC<->Shill translation from the ONC signature.

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 28 matching lines @@
 // not nested objects because recursion is handled by the calling function
 // TranslateONCHierarchy.
 class LocalTranslator {
  public:
   LocalTranslator(const OncValueSignature& onc_signature,
                   const base::DictionaryValue& onc_object,
                   base::DictionaryValue* shill_dictionary)
       : onc_signature_(&onc_signature),
         onc_object_(&onc_object),
         shill_dictionary_(shill_dictionary) {
+    field_translation_table_ = GetFieldTranslationTable(onc_signature);
   }
 
   void TranslateFields();
 
  private:
   void TranslateOpenVPN();
   void TranslateVPN();
   void TranslateWiFi();
   void TranslateEAP();
   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,
                                     scoped_ptr<base::Value> value);
 
   // If existent, translates the entry at |onc_field_name| in |onc_object_|
   // using |table|. It is an error if no matching table entry is found. Writes
   // the result as entry at |shill_property_name| in |shill_dictionary_|.
   void TranslateWithTableAndSet(const std::string& onc_field_name,
                                 const StringTranslationEntry table[],
                                 const std::string& shill_property_name);
 
   const OncValueSignature* onc_signature_;
+  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_ == &kVPNSignature)
@@ skipping 95 matching lines @@
   for (base::DictionaryValue::Iterator it(*onc_object_); it.HasNext();
        it.Advance()) {
     AddValueAccordingToSignature(it.key(),
                                  make_scoped_ptr(it.value().DeepCopy()));
   }
 }
 
 void LocalTranslator::AddValueAccordingToSignature(
     const std::string& onc_name,
     scoped_ptr<base::Value> value) {
-  if (value.get() == NULL)
-    return;
-  const OncFieldSignature* field_signature =
-      GetFieldSignature(*onc_signature_, onc_name);
-  DCHECK(field_signature != NULL);
-  if (field_signature == NULL || field_signature->shill_property_name == NULL)
+  if (!value || !field_translation_table_)
     return;
 
-  shill_dictionary_->SetWithoutPathExpansion(
-      field_signature->shill_property_name, value.release());
+  std::string shill_property_name;
+  if (!GetShillPropertyName(onc_name,
+                            field_translation_table_,
+                            &shill_property_name))
+    return;
+
+  shill_dictionary_->SetWithoutPathExpansion(shill_property_name,
+                                             value.release());
 }
 
 void LocalTranslator::TranslateWithTableAndSet(
     const std::string& onc_value,
     const StringTranslationEntry table[],
     const std::string& shill_property_name) {
   std::string shill_value;
   if (TranslateStringToShill(table, onc_value, &shill_value)) {
     shill_dictionary_->SetStringWithoutPathExpansion(shill_property_name,
                                                      shill_value);
@@ skipping 38 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