Use networkingPrivate.startConnect

chromeos/network/network_state.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_state.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
@@ skipping 213 matching lines @@
   ManagedState::GetStateProperties(dictionary);
 
   // Properties shared by all types.
   dictionary->SetStringWithoutPathExpansion(shill::kGuidProperty, guid());
   dictionary->SetStringWithoutPathExpansion(shill::kSecurityClassProperty,
                                             security_class());
   dictionary->SetStringWithoutPathExpansion(shill::kProfileProperty,
                                             profile_path());
 
   if (visible()) {
-    if (!error().empty())
-      dictionary->SetStringWithoutPathExpansion(shill::kErrorProperty, error());
+    std::string error_state = GetErrorState();
+    if (!error_state.empty()) {
+      dictionary->SetStringWithoutPathExpansion(shill::kErrorProperty,
+                                                error_state);
+    }
     dictionary->SetStringWithoutPathExpansion(shill::kStateProperty,
                                               connection_state());
   }
 
   // VPN properties.
   if (NetworkTypePattern::VPN().MatchesType(type())) {
     // Shill sends VPN provider properties in a nested dictionary. |dictionary|
     // must replicate that nested structure.
     scoped_ptr<base::DictionaryValue> provider_property(
         new base::DictionaryValue);
@@ skipping 145 matching lines @@
 bool NetworkState::UpdateName(const base::DictionaryValue& properties) {
   std::string updated_name =
       shill_property_util::GetNameFromProperties(path(), properties);
   if (updated_name != name()) {
     set_name(updated_name);
     return true;
   }
   return false;
 }
 
+std::string NetworkState::GetErrorState() const {
+  if (ErrorIsValid(error()))
+    return error();
+  return last_error();
+}
+
 // static
 bool NetworkState::StateIsConnected(const std::string& connection_state) {
   return (connection_state == shill::kStateReady ||
           connection_state == shill::kStateOnline ||
           connection_state == shill::kStatePortal);
 }
 
 // static
 bool NetworkState::StateIsConnecting(const std::string& connection_state) {
   return (connection_state == shill::kStateAssociation ||
           connection_state == shill::kStateConfiguration ||
           connection_state == shill::kStateCarrier);
 }
 
 // static
 bool NetworkState::NetworkStateIsCaptivePortal(
     const base::DictionaryValue& shill_properties) {
   return IsCaptivePortalState(shill_properties, false /* log */);
 }
 
 // static
 bool NetworkState::ErrorIsValid(const std::string& error) {
   // Shill uses "Unknown" to indicate an unset or cleared error state.
   return !error.empty() && error != kErrorUnknown;
 }
 
 }  // namespace chromeos