Add ethernet to ONC validation and Shill 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 34 matching lines @@
                   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 TranslateEthernet();
   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();
 
@@ skipping 14 matching lines @@
   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_ == &kEthernetSignature)
+    TranslateEthernet();
   else if (onc_signature_ == &kVPNSignature)
     TranslateVPN();
   else if (onc_signature_ == &kOpenVPNSignature)
     TranslateOpenVPN();
   else if (onc_signature_ == &kWiFiSignature)
     TranslateWiFi();
   else if (onc_signature_ == &kEAPSignature)
     TranslateEAP();
   else
     CopyFieldsAccordingToSignature();
 }
 
+void LocalTranslator::TranslateEthernet() {
+  std::string authentication;
+  onc_object_->GetStringWithoutPathExpansion(ethernet::kAuthentication,
+                                             &authentication);
+
+  const char* shill_type = flimflam::kTypeEthernet;
+  if (authentication == ethernet::k8021X)
+    shill_type = shill::kTypeEthernetEap;
+  shill_dictionary_->SetStringWithoutPathExpansion(flimflam::kTypeProperty,
+                                                   shill_type);
+
+  CopyFieldsAccordingToSignature();
+}
+
 void LocalTranslator::TranslateOpenVPN() {
   // Shill supports only one RemoteCertKU but ONC a list.
   // Copy only the first entry if existing.
   const base::ListValue* certKUs = NULL;
   std::string certKU;
   if (onc_object_->GetListWithoutPathExpansion(openvpn::kRemoteCertKU,
                                                &certKUs) &&
       certKUs->GetString(0, &certKU)) {
     shill_dictionary_->SetStringWithoutPathExpansion(
         flimflam::kOpenVPNRemoteCertKUProperty, certKU);
@@ skipping 53 matching lines @@
       TranslateWithTableAndSet(inner, table, flimflam::kEapPhase2AuthProperty);
     }
   }
 
   CopyFieldsAccordingToSignature();
 }
 
 void LocalTranslator::TranslateNetworkConfiguration() {
   std::string type;
   onc_object_->GetStringWithoutPathExpansion(network_config::kType, &type);
-  TranslateWithTableAndSet(type, kNetworkTypeTable, flimflam::kTypeProperty);
+
+  // Set the type except for Ethernet which is set in TranslateEthernet.
+  if (type != network_type::kEthernet)
+    TranslateWithTableAndSet(type, kNetworkTypeTable, flimflam::kTypeProperty);
 
   // Shill doesn't allow setting the name for non-VPN networks.
   if (type == network_type::kVPN) {
     std::string name;
     onc_object_->GetStringWithoutPathExpansion(network_config::kName, &name);
-    shill_dictionary_->SetStringWithoutPathExpansion(
-        flimflam::kNameProperty, name);
+    shill_dictionary_->SetStringWithoutPathExpansion(flimflam::kNameProperty,
+                                                     name);
   }
 
   CopyFieldsAccordingToSignature();
 }
 
 void LocalTranslator::CopyFieldsAccordingToSignature() {
   for (base::DictionaryValue::Iterator it(*onc_object_); !it.IsAtEnd();
        it.Advance()) {
     AddValueAccordingToSignature(it.key(),
                                  make_scoped_ptr(it.value().DeepCopy()));
@@ skipping 80 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