Add ethernet to ONC validation and Shill translation.

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 40 matching lines @@
       : shill_dictionary_(&shill_dictionary),
         onc_signature_(&onc_signature) {
     field_translation_table_ = GetFieldTranslationTable(onc_signature);
   }
 
   // Translates the associated Shill dictionary and creates an ONC object of the
   // given signature.
   scoped_ptr<base::DictionaryValue> CreateTranslatedONCObject();
 
  private:
+  void TranslateEthernet();
   void TranslateOpenVPN();
   void TranslateVPN();
   void TranslateWiFiWithState();
   void TranslateCellularWithState();
   void TranslateNetworkWithState();
 
   // 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,
@@ skipping 31 matching lines @@
   scoped_ptr<base::DictionaryValue> onc_object_;
 
   DISALLOW_COPY_AND_ASSIGN(ShillToONCTranslator);
 };
 
 scoped_ptr<base::DictionaryValue>
 ShillToONCTranslator::CreateTranslatedONCObject() {
   onc_object_.reset(new base::DictionaryValue);
   if (onc_signature_ == &kNetworkWithStateSignature) {
     TranslateNetworkWithState();
+  } else if (onc_signature_ == &kEthernetSignature) {
+    TranslateEthernet();
   } else if (onc_signature_ == &kVPNSignature) {
     TranslateVPN();
   } else if (onc_signature_ == &kOpenVPNSignature) {
     TranslateOpenVPN();
   } else if (onc_signature_ == &kWiFiWithStateSignature) {
     TranslateWiFiWithState();
   } else if (onc_signature_ == &kCellularWithStateSignature) {
     TranslateCellularWithState();
   } else {
     CopyPropertiesAccordingToSignature();
   }
   return onc_object_.Pass();
 }
 
+void ShillToONCTranslator::TranslateEthernet() {
+  std::string shill_network_type;
+  shill_dictionary_->GetStringWithoutPathExpansion(flimflam::kTypeProperty,
+                                                   &shill_network_type);
+  const char* onc_auth = ethernet::kNone;
+  if (shill_network_type == shill::kTypeEthernetEap)
+    onc_auth = ethernet::k8021X;
+  onc_object_->SetStringWithoutPathExpansion(ethernet::kAuthentication,
+                                             onc_auth);
+}
+
 void ShillToONCTranslator::TranslateOpenVPN() {
   // Shill supports only one RemoteCertKU but ONC requires a list. If existing,
   // wraps the value into a list.
   std::string certKU;
   if (shill_dictionary_->GetStringWithoutPathExpansion(
           flimflam::kOpenVPNRemoteCertKUProperty, &certKU)) {
     scoped_ptr<base::ListValue> certKUs(new base::ListValue);
     certKUs->AppendString(certKU);
     onc_object_->SetWithoutPathExpansion(openvpn::kRemoteCertKU,
                                          certKUs.release());
@@ skipping 76 matching lines @@
         flimflam::kServingOperatorProperty, &dictionary)) {
     TranslateAndAddNestedObject(cellular::kServingOperator, *dictionary);
   }
   if (shill_dictionary_->GetDictionaryWithoutPathExpansion(
         flimflam::kCellularApnProperty, &dictionary)) {
     TranslateAndAddNestedObject(cellular::kAPN, *dictionary);
   }
 }
 
 void ShillToONCTranslator::TranslateNetworkWithState() {
-  TranslateWithTableAndSet(flimflam::kTypeProperty, kNetworkTypeTable,
-                           network_config::kType);
   CopyPropertiesAccordingToSignature();
 
-  std::string network_type;
-  if (onc_object_->GetStringWithoutPathExpansion(network_config::kType,
-                                                 &network_type)) {
-    TranslateAndAddNestedObject(network_type);
+  std::string shill_network_type;
+  shill_dictionary_->GetStringWithoutPathExpansion(flimflam::kTypeProperty,
+                                                   &shill_network_type);
+  std::string onc_network_type = network_type::kEthernet;
+  if (shill_network_type != flimflam::kTypeEthernet &&
+      shill_network_type != shill::kTypeEthernetEap) {
+    TranslateStringToONC(
+        kNetworkTypeTable, shill_network_type, &onc_network_type);
+  }
+  if (!onc_network_type.empty()) {
+    onc_object_->SetStringWithoutPathExpansion(network_config::kType,
+                                               onc_network_type);
+    TranslateAndAddNestedObject(onc_network_type);
   }
 
   // Since Name is a read only field in Shill unless it's a VPN, it is copied
   // here, but not when going the other direction (if it's not a VPN).
   std::string name;
   shill_dictionary_->GetStringWithoutPathExpansion(flimflam::kNameProperty,
                                                    &name);
   onc_object_->SetStringWithoutPathExpansion(network_config::kName, name);
 
   std::string state;
@@ skipping 98 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