Use networkingPrivate.startConnect (Take 2)

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 34 matching lines @@
 }
 
 // This class implements the translation of properties from the given
 // |shill_dictionary| to a new ONC object of signature |onc_signature|. Using
 // recursive calls to CreateTranslatedONCObject of new instances, nested objects
 // are translated.
 class ShillToONCTranslator {
  public:
   ShillToONCTranslator(const base::DictionaryValue& shill_dictionary,
                        ::onc::ONCSource onc_source,
-                       const OncValueSignature& onc_signature)
+                       const OncValueSignature& onc_signature,
+                       const NetworkState* network_state)
       : shill_dictionary_(&shill_dictionary),
         onc_source_(onc_source),
-        onc_signature_(&onc_signature) {
+        onc_signature_(&onc_signature),
+        network_state_(network_state) {
     field_translation_table_ = GetFieldTranslationTable(onc_signature);
   }
 
   ShillToONCTranslator(const base::DictionaryValue& shill_dictionary,
                        ::onc::ONCSource onc_source,
                        const OncValueSignature& onc_signature,
-                       const FieldTranslationEntry* field_translation_table)
+                       const FieldTranslationEntry* field_translation_table,
+                       const NetworkState* network_state)
       : shill_dictionary_(&shill_dictionary),
         onc_source_(onc_source),
         onc_signature_(&onc_signature),
-        field_translation_table_(field_translation_table) {}
+        field_translation_table_(field_translation_table),
+        network_state_(network_state) {}
 
   // 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 TranslateIPsec();
   void TranslateThirdPartyVPN();
@@ skipping 55 matching lines @@
 
   // 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_;
   scoped_ptr<base::DictionaryValue> onc_object_;
+  const NetworkState* network_state_;
 
   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) {
@@ skipping 220 matching lines @@
     TranslateAndAddNestedObject(::onc::cellular::kPaymentPortal, *dictionary);
   }
 
   const base::DictionaryValue* device_dictionary = NULL;
   bool requires_roaming = false;
   shill_dictionary_->GetDictionaryWithoutPathExpansion(shill::kDeviceProperty,
                                                        &device_dictionary);
   if (device_dictionary) {
     // Merge the Device dictionary with this one (Cellular) using the
     // CellularDevice signature.
-    ShillToONCTranslator nested_translator(*device_dictionary, onc_source_,
-                                           kCellularWithStateSignature,
-                                           kCellularDeviceTable);
+    ShillToONCTranslator nested_translator(
+        *device_dictionary, onc_source_, kCellularWithStateSignature,
+        kCellularDeviceTable, network_state_);
     scoped_ptr<base::DictionaryValue> nested_object =
         nested_translator.CreateTranslatedONCObject();
     onc_object_->MergeDictionary(nested_object.get());
 
     /// Get the requires_roaming from the Device dictionary.
     device_dictionary->GetBooleanWithoutPathExpansion(
         shill::kProviderRequiresRoamingProperty, &requires_roaming);
   }
   if (requires_roaming) {
     onc_object_->SetStringWithoutPathExpansion(
@@ skipping 69 matching lines @@
     }
     onc_object_->SetStringWithoutPathExpansion(
         ::onc::network_config::kConnectionState, onc_state);
     // Only set 'RestrictedConnectivity' if captive portal state is true.
     if (NetworkState::NetworkStateIsCaptivePortal(*shill_dictionary_)) {
       onc_object_->SetBooleanWithoutPathExpansion(
           ::onc::network_config::kRestrictedConnectivity, true);
     }
   }
 
+  // 'ErrorState' reflects the most recent error maintained in NetworkState
+  // (which may not match Shill's Error or PreviousError properties). Non
+  // visible networks (with null network_state_) do not set ErrorState.
+  if (network_state_) {
+    std::string error_state = network_state_->GetErrorState();
+    if (!error_state.empty()) {
+      onc_object_->SetStringWithoutPathExpansion(
+          ::onc::network_config::kErrorState, error_state);
+    }
+  }
+
   std::string profile_path;
   if (onc_source_ != ::onc::ONC_SOURCE_UNKNOWN &&
       shill_dictionary_->GetStringWithoutPathExpansion(shill::kProfileProperty,
                                                        &profile_path)) {
     std::string source;
     if (onc_source_ == ::onc::ONC_SOURCE_DEVICE_POLICY)
       source = ::onc::network_config::kSourceDevicePolicy;
     else if (onc_source_ == ::onc::ONC_SOURCE_USER_POLICY)
       source = ::onc::network_config::kSourceUserPolicy;
     else if (profile_path == NetworkProfileHandler::GetSharedProfilePath())
@@ skipping 107 matching lines @@
 void ShillToONCTranslator::TranslateAndAddNestedObject(
     const std::string& onc_field_name,
     const base::DictionaryValue& dictionary) {
   const OncFieldSignature* field_signature =
       GetFieldSignature(*onc_signature_, onc_field_name);
   if (!field_signature) {
     NOTREACHED() << "Unable to find signature for field: " << onc_field_name;
     return;
   }
   ShillToONCTranslator nested_translator(dictionary, onc_source_,
-                                         *field_signature->value_signature);
+                                         *field_signature->value_signature,
+                                         network_state_);
   scoped_ptr<base::DictionaryValue> nested_object =
       nested_translator.CreateTranslatedONCObject();
   if (nested_object->empty())
     return;
   onc_object_->SetWithoutPathExpansion(onc_field_name, nested_object.release());
 }
 
 void ShillToONCTranslator::SetNestedOncValue(
     const std::string& onc_dictionary_name,
     const std::string& onc_field_name,
@@ skipping 20 matching lines @@
   }
   DCHECK(field_signature->value_signature->onc_array_entry_signature);
   scoped_ptr<base::ListValue> result(new base::ListValue());
   for (base::ListValue::const_iterator it = list.begin(); it != list.end();
        ++it) {
     const base::DictionaryValue* shill_value = NULL;
     if (!(*it)->GetAsDictionary(&shill_value))
       continue;
     ShillToONCTranslator nested_translator(
         *shill_value, onc_source_,
-        *field_signature->value_signature->onc_array_entry_signature);
+        *field_signature->value_signature->onc_array_entry_signature,
+        network_state_);
     scoped_ptr<base::DictionaryValue> nested_object =
         nested_translator.CreateTranslatedONCObject();
     // If the nested object couldn't be parsed, simply omit it.
     if (nested_object->empty())
       continue;
     result->Append(nested_object.release());
   }
   // If there are no entries in the list, there is no need to expose this field.
   if (result->empty())
     return;
@@ skipping 65 matching lines @@
   std::string name;
   shill_dictionary_->GetStringWithoutPathExpansion(shill::kNameProperty, &name);
   return name;
 }
 
 }  // namespace
 
 scoped_ptr<base::DictionaryValue> TranslateShillServiceToONCPart(
     const base::DictionaryValue& shill_dictionary,
     ::onc::ONCSource onc_source,
-    const OncValueSignature* onc_signature) {
+    const OncValueSignature* onc_signature,
+    const NetworkState* network_state) {
   CHECK(onc_signature != NULL);
 
-  ShillToONCTranslator translator(shill_dictionary, onc_source, *onc_signature);
+  ShillToONCTranslator translator(shill_dictionary, onc_source, *onc_signature,
+                                  network_state);
   return translator.CreateTranslatedONCObject();
 }
 
 }  // namespace onc
 }  // namespace chromeos