Add TechnologyState to NetworkStateHandler.

chromeos/network/shill_property_handler.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/shill_property_handler.h"
 
 #include "base/bind.h"
 #include "base/format_macros.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
@@ skipping 103 matching lines @@
   shill_manager_->RemovePropertyChangedObserver(this);
 }
 
 void ShillPropertyHandler::Init() {
   shill_manager_->GetProperties(
       base::Bind(&ShillPropertyHandler::ManagerPropertiesCallback,
                  AsWeakPtr()));
   shill_manager_->AddPropertyChangedObserver(this);
 }
 
-bool ShillPropertyHandler::TechnologyAvailable(
+bool ShillPropertyHandler::IsTechnologyAvailable(
     const std::string& technology) const {
   return available_technologies_.count(technology) != 0;
 }
 
-bool ShillPropertyHandler::TechnologyEnabled(
+bool ShillPropertyHandler::IsTechnologyEnabled(
     const std::string& technology) const {
   return enabled_technologies_.count(technology) != 0;
 }
 
-bool ShillPropertyHandler::TechnologyUninitialized(
+bool ShillPropertyHandler::IsTechnologyEnabling(
+    const std::string& technology) const {
+  return enabling_technologies_.count(technology) != 0;
+}
+
+bool ShillPropertyHandler::IsTechnologyUninitialized(
     const std::string& technology) const {
   return uninitialized_technologies_.count(technology) != 0;
 }
 
 void ShillPropertyHandler::SetTechnologyEnabled(
     const std::string& technology,
     bool enabled,
     const network_handler::ErrorCallback& error_callback) {
   if (enabled) {
+    enabling_technologies_.insert(technology);
     shill_manager_->EnableTechnology(
         technology,
         base::Bind(&base::DoNothing),
-        base::Bind(&network_handler::ShillErrorCallbackFunction,
-                   kLogModule, technology, error_callback));
+        base::Bind(&ShillPropertyHandler::EnableTechnologyFailed,
+                   AsWeakPtr(), technology, error_callback));
   } else {
+    // Imediately clear locally from enabled and enabling lists.
+    enabled_technologies_.erase(technology);
+    enabling_technologies_.erase(technology);
     shill_manager_->DisableTechnology(
         technology,
         base::Bind(&base::DoNothing),
         base::Bind(&network_handler::ShillErrorCallbackFunction,
                    kLogModule, technology, error_callback));
   }
 }
 
 void ShillPropertyHandler::RequestScan() const {
   shill_manager_->RequestScan(
@@ skipping 184 matching lines @@
   enabled_technologies_.clear();
   network_event_log::AddEntry(
       kLogModule, "EnabledTechnologiesChanged",
       base::StringPrintf("Size: %"PRIuS, technologies.GetSize()));
   for (base::ListValue::const_iterator iter = technologies.begin();
        iter != technologies.end(); ++iter) {
     std::string technology;
     (*iter)->GetAsString(&technology);
     DCHECK(!technology.empty());
     enabled_technologies_.insert(technology);
+    enabling_technologies_.erase(technology);
   }
 }
 
 void ShillPropertyHandler::UpdateUninitializedTechnologies(
     const base::ListValue& technologies) {
   uninitialized_technologies_.clear();
   network_event_log::AddEntry(
       kLogModule, "UninitializedTechnologiesChanged",
       base::StringPrintf("Size: %"PRIuS, technologies.GetSize()));
   for (base::ListValue::const_iterator iter = technologies.begin();
        iter != technologies.end(); ++iter) {
     std::string technology;
     (*iter)->GetAsString(&technology);
     DCHECK(!technology.empty());
     uninitialized_technologies_.insert(technology);
   }
 }
 
+void ShillPropertyHandler::EnableTechnologyFailed(
+    const std::string& technology,
+    const network_handler::ErrorCallback& error_callback,
+    const std::string& error_name,
+    const std::string& error_message) {
+  enabling_technologies_.erase(technology);
+  network_handler::ShillErrorCallbackFunction(
+      kLogModule, technology, error_callback, error_name, error_message);
+}
+
 void ShillPropertyHandler::GetPropertiesCallback(
     ManagedState::ManagedType type,
     const std::string& path,
     DBusMethodCallStatus call_status,
     const base::DictionaryValue& properties) {
   VLOG(2) << "GetPropertiesCallback: " << type << " : " << path;
   pending_updates_[type].erase(path);
   if (call_status != DBUS_METHOD_CALL_SUCCESS) {
     LOG(ERROR) << "Failed to get properties for: " << path
                << ": " << call_status;
@@ skipping 83 matching lines @@
 
 void ShillPropertyHandler::NetworkDevicePropertyChangedCallback(
     const std::string& path,
     const std::string& key,
     const base::Value& value) {
   listener_->UpdateDeviceProperty(path, key, value);
 }
 
 }  // namespace internal
 }  // namespace chromeos