ONC: Translate EAP from Shill 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 <string>
 #include <utility>
 
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
@@ skipping 118 matching lines @@
   void CopyProperty(const OncFieldSignature* field_signature);
 
   // If existent, translates the entry at |shill_property_name| in
   // |shill_dictionary_| using |table|. It is an error if no matching table
   // entry is found. Writes the result as entry at |onc_field_name| in
   // |onc_object_|.
   void TranslateWithTableAndSet(const std::string& shill_property_name,
                                 const StringTranslationEntry table[],
                                 const std::string& onc_field_name);
 
+  // Same as above but for nested properties.
+  bool TranslateWithTableAndSetNested(const std::string& shill_property_name,
+                                      const StringTranslationEntry table[],
+                                      const std::string& onc_dictionary_name,
+                                      const std::string& onc_field_name);
+
   // Returns the name of the Shill service provided in |shill_dictionary_|
   // for debugging.
   std::string GetName();
 
   const base::DictionaryValue* shill_dictionary_;
   ::onc::ONCSource onc_source_;
   const OncValueSignature* onc_signature_;
   const FieldTranslationEntry* field_translation_table_;
   std::unique_ptr<base::DictionaryValue> onc_object_;
   const NetworkState* network_state_;
@@ skipping 203 matching lines @@
 
   bool link_monitor_disable;
   if (shill_dictionary_->GetBooleanWithoutPathExpansion(
           shill::kLinkMonitorDisableProperty, &link_monitor_disable)) {
     onc_object_->SetBooleanWithoutPathExpansion(
         ::onc::wifi::kAllowGatewayARPPolling, !link_monitor_disable);
   }
 
   CopyPropertiesAccordingToSignature();
   TranslateAndAddNestedObject(::onc::wifi::kEAP);
+
+  // Translate EAP Outer and Inner values. Note: Shill provides an empty
+  // EAP property for non EAP networks, so check that before appmpting to
+  // translate.
+  std::string eap;

[tbarzic, 2017/05/01 18:05:56]

Could this be done as part of TranslateAndAddNestedObject(::onc::wifi::kEAP); so
the same does not have to be repeated for all occurrences of EAP property?

e.g. introduce
TranslateEAP() {
  CopyPropertiesAccordingToSignature();
  TranslateWithTableAndSet(shill::kEapMethodProperty, kEAPOuterTable,
::onc::eap::kOuter);
  TranslateWithTableAndSet(shill::kEapPhase2AuthProperty, kEAP_TTLS_InnerTable,
::onc::eap::kInner);
}

and add 
if (onc_signature_ == &kEAPSignature) {
  TranslateEAP();
}

to ShillToONCTranslator::CreateTranslatedONCObject

[stevenjb, 2017/05/01 20:12:04]

Yes, thanks, I've been out of this code for too long, that's a much better
approach. Done.

+  shill_dictionary_->GetStringWithoutPathExpansion(shill::kEapMethodProperty,
+                                                   &eap);
+  if (!eap.empty() &&
+      TranslateWithTableAndSetNested(shill::kEapMethodProperty, kEAPOuterTable,
+                                     ::onc::wifi::kEAP, ::onc::eap::kOuter)) {
+    TranslateWithTableAndSetNested(shill::kEapPhase2AuthProperty,
+                                   kEAP_TTLS_InnerTable, ::onc::wifi::kEAP,
+                                   ::onc::eap::kInner);
+  }
 }
 
 void ShillToONCTranslator::TranslateWiMAXWithState() {
   CopyPropertiesAccordingToSignature();
   TranslateAndAddNestedObject(::onc::wimax::kEAP);
 }
 
 void ShillToONCTranslator::TranslateCellularWithState() {
   CopyPropertiesAccordingToSignature();
   TranslateWithTableAndSet(shill::kActivationStateProperty,
@@ skipping 383 matching lines @@
   }
   std::string onc_value;
   if (TranslateStringToONC(table, shill_value, &onc_value)) {
     onc_object_->SetStringWithoutPathExpansion(onc_field_name, onc_value);
     return;
   }
   LOG(ERROR) << "Shill property '" << shill_property_name << "' with value "
              << shill_value << " couldn't be translated to ONC: " << GetName();
 }
 
+bool ShillToONCTranslator::TranslateWithTableAndSetNested(
+    const std::string& shill_property_name,
+    const StringTranslationEntry table[],
+    const std::string& onc_dictionary_name,
+    const std::string& onc_field_name) {
+  std::string shill_value;
+  if (!shill_dictionary_->GetStringWithoutPathExpansion(shill_property_name,
+                                                        &shill_value)) {
+    return false;
+  }
+  std::string onc_value;
+  if (TranslateStringToONC(table, shill_value, &onc_value)) {
+    SetNestedOncValue(onc_dictionary_name, onc_field_name,
+                      base::Value(onc_value));
+    return true;
+  }
+  LOG(ERROR) << "Shill property '" << shill_property_name << "' with value "
+             << shill_value << " couldn't be translated to ONC: " << GetName();
+  return false;
+}
+
 std::string ShillToONCTranslator::GetName() {
   DCHECK(shill_dictionary_);
   std::string name;
   shill_dictionary_->GetStringWithoutPathExpansion(shill::kNameProperty, &name);
   return name;
 }
 
 }  // namespace
 
 std::unique_ptr<base::DictionaryValue> TranslateShillServiceToONCPart(
     const base::DictionaryValue& shill_dictionary,
     ::onc::ONCSource onc_source,
     const OncValueSignature* onc_signature,
     const NetworkState* network_state) {
   CHECK(onc_signature != NULL);
 
   ShillToONCTranslator translator(shill_dictionary, onc_source, *onc_signature,
                                   network_state);
   return translator.CreateTranslatedONCObject();
 }
 
 }  // namespace onc
 }  // namespace chromeos