Use networkingPrivate.startConnect

chromeos/network/network_util.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/network_util.h"
 
 #include "base/strings/string_tokenizer.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "chromeos/login/login_state.h"
@@ skipping 192 matching lines @@
       onc_dictionary->SetBoolean("visible", state->visible());
       onc_dictionary->SetString("profile_path", state->profile_path());
       onc_dictionary->SetString("service_path", state->path());
     }
 
     network_properties_list->Append(onc_dictionary.release());
   }
   return network_properties_list.Pass();
 }
 
+scoped_ptr<base::DictionaryValue> TranslateShillPropertiesToONC(
+    const std::string& service_path,
+    const base::DictionaryValue& shill_properties,
+    ::onc::ONCSource onc_source) {
+  scoped_ptr<base::DictionaryValue> shill_dictionary(
+      shill_properties.DeepCopy());
+  // Shill's 'Error' property is transient. Use NetworkState::GetErrorState()
+  // instead.
+  const NetworkState* network_state =
+      NetworkHandler::Get()->network_state_handler()->GetNetworkState(
+          service_path);
+  if (network_state) {
+    std::string error_state = network_state->GetErrorState();

[pneubeck (no reviews), 2015/04/13 19:16:11]

this deviates from the GetStateProperties behavior, where you check for
error_state.empty() before setting.

we probably should add a unit test that compares these two translation flows:
Shill properties -> NetworkState -> TranslateNetworkStateToONC (calling
GetStateProperties)
Shill properties -> TranslateShillPropertiesToONC (also getting the NetworkState
that's calling GetStateProperties)

[stevenjb, 2015/04/13 21:16:32]

I was trying to avoid adding a dependency on NSH to ShillToONCTranslator, but
upon reflection I think it is better just to add that dependency instead.

+    shill_dictionary->SetStringWithoutPathExpansion(shill::kErrorProperty,
+                                                    error_state);
+  }
+  return TranslateShillServiceToONCPart(*shill_dictionary, onc_source,
+                                        &onc::kNetworkWithStateSignature);
+}
+
 std::string TranslateONCTypeToShill(const std::string& onc_type) {
   if (onc_type == ::onc::network_type::kEthernet)
     return shill::kTypeEthernet;
   std::string shill_type;
   onc::TranslateStringToShill(onc::kNetworkTypeTable, onc_type, &shill_type);
   return shill_type;
 }
 
 std::string TranslateShillTypeToONC(const std::string& shill_type) {
   if (shill_type == shill::kTypeEthernet)
     return ::onc::network_type::kEthernet;
   std::string onc_type;
   onc::TranslateStringToONC(onc::kNetworkTypeTable, shill_type, &onc_type);
   return onc_type;
 }
 
 }  // namespace network_util
 }  // namespace chromeos