Add TechnologyState to NetworkStateHandler.

chromeos/network/network_state_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/network_state_handler.h"
 
 #include "base/bind.h"
 #include "base/format_macros.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
@@ skipping 112 matching lines @@
 
 void NetworkStateHandler::AddObserver(NetworkStateHandlerObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void NetworkStateHandler::RemoveObserver(
     NetworkStateHandlerObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
-bool NetworkStateHandler::TechnologyAvailable(const std::string& type) const {
-  if (type == kMatchTypeMobile) {
-    return shill_property_handler_->TechnologyAvailable(flimflam::kTypeWimax) ||
-        shill_property_handler_->TechnologyAvailable(flimflam::kTypeCellular);
-  }
-  return shill_property_handler_->TechnologyAvailable(type);
+NetworkStateHandler::TechnologyState NetworkStateHandler::GetTechnologyState(
+    const std::string& type) const {
+  std::string technology = GetTechnologyForType(type);
+  TechnologyState state;
+  if (shill_property_handler_->IsTechnologyEnabled(technology))
+    state = TECHNOLOGY_ENABLED;
+  else if (shill_property_handler_->IsTechnologyEnabling(technology))
+    state = TECHNOLOGY_ENABLING;
+  else if (shill_property_handler_->IsTechnologyUninitialized(technology))
+    state = TECHNOLOGY_UNINITIALIZED;
+  else if (shill_property_handler_->IsTechnologyAvailable(technology))
+    state = TECHNOLOGY_AVAILABLE;
+  else
+    state = TECHNOLOGY_UNINITIALIZED;
+  VLOG(2) << "GetTechnologyState: " << type << " = " << state;
+  return state;
 }
 
-bool NetworkStateHandler::TechnologyEnabled(const std::string& type) const {
-  if (type == kMatchTypeMobile) {
-    return shill_property_handler_->TechnologyEnabled(flimflam::kTypeWimax) ||
-        shill_property_handler_->TechnologyEnabled(flimflam::kTypeCellular);
-  }
-  return shill_property_handler_->TechnologyEnabled(type);
-}
-
-bool NetworkStateHandler::TechnologyUninitialized(
-    const std::string& type) const {
-  if (type == kMatchTypeMobile) {
-    return
-        shill_property_handler_->TechnologyUninitialized(
-            flimflam::kTypeWimax) ||
-        shill_property_handler_->TechnologyUninitialized(
-            flimflam::kTypeCellular);
-  }
-  return shill_property_handler_->TechnologyUninitialized(type);
-}
-
-
 void NetworkStateHandler::SetTechnologyEnabled(
     const std::string& type,
     bool enabled,
     const network_handler::ErrorCallback& error_callback) {
-  if (type == kMatchTypeMobile) {
-    shill_property_handler_->SetTechnologyEnabled(
-        flimflam::kTypeCellular, enabled, error_callback);
-    shill_property_handler_->SetTechnologyEnabled(
-        flimflam::kTypeWimax, enabled, error_callback);
-  } else {
-    shill_property_handler_->SetTechnologyEnabled(
-        type, enabled, error_callback);
-  }
+  std::string technology = GetTechnologyForType(type);
+  network_event_log::AddEntry(
+      kLogModule, "SetTechnologyEnabled",
+      base::StringPrintf("%s:%d", technology.c_str(), enabled));
+  shill_property_handler_->SetTechnologyEnabled(
+      technology, enabled, error_callback);
+  ManagerPropertyChanged();  // Technology state changed -> ENABLING
 }
 
 const DeviceState* NetworkStateHandler::GetDeviceState(
     const std::string& device_path) const {
   return GetModifiableDeviceState(device_path);
 }
 
 const DeviceState* NetworkStateHandler::GetDeviceStateByType(
     const std::string& type) const {
   for (ManagedStateList::const_iterator iter = device_list_.begin();
@@ skipping 286 matching lines @@
   network_event_log::AddEntry(kLogModule, "DevicePropertyUpdated", detail);
 
   FOR_EACH_OBSERVER(NetworkStateHandlerObserver, observers_,
                     DeviceListChanged());
 
   if (key == flimflam::kScanningProperty && device->scanning() == false)
     ScanCompleted(device->type());
 }
 
 void NetworkStateHandler::ManagerPropertyChanged() {
+  network_event_log::AddEntry(kLogModule, "NetworkManagerChanged", "");
   FOR_EACH_OBSERVER(NetworkStateHandlerObserver, observers_,
                     NetworkManagerChanged());
 }
 
 void NetworkStateHandler::ManagedStateListChanged(
     ManagedState::ManagedType type) {
   if (type == ManagedState::MANAGED_TYPE_NETWORK) {
     // Notify observers that the list of networks has changed.
     network_event_log::AddEntry(
         kLogModule, "NetworkListChanged",
-        base::StringPrintf("Size: %"PRIuS, network_list_.size()));
+        base::StringPrintf("Size:%"PRIuS, network_list_.size()));
     FOR_EACH_OBSERVER(NetworkStateHandlerObserver, observers_,
                       NetworkListChanged());
     // The list order may have changed, so check if the default network changed.
     if (CheckDefaultNetworkChanged())
       OnDefaultNetworkChanged();
   } else if (type == ManagedState::MANAGED_TYPE_DEVICE) {
     network_event_log::AddEntry(
         kLogModule, "DeviceListChanged",
-        base::StringPrintf("Size: %"PRIuS, device_list_.size()));
+        base::StringPrintf("Size:%"PRIuS, device_list_.size()));
     FOR_EACH_OBSERVER(NetworkStateHandlerObserver, observers_,
                       DeviceListChanged());
   } else {
     NOTREACHED();
   }
 }
 
 //------------------------------------------------------------------------------
 // Private methods
 
@@ skipping 34 matching lines @@
     case ManagedState::MANAGED_TYPE_DEVICE:
       return &device_list_;
   }
   NOTREACHED();
   return NULL;
 }
 
 void NetworkStateHandler::OnNetworkConnectionStateChanged(
     NetworkState* network) {
   DCHECK(network);
-  std::string desc = base::StringPrintf(
-      "%s: %s", network->path().c_str(), network->connection_state().c_str());
   network_event_log::AddEntry(
-      kLogModule, "NetworkConnectionStateChanged", desc);
+      kLogModule, "NetworkConnectionStateChanged",
+      base::StringPrintf("%s:%s", network->path().c_str(),
+                         network->connection_state().c_str()));
   FOR_EACH_OBSERVER(NetworkStateHandlerObserver, observers_,
                     NetworkConnectionStateChanged(network));
   if (CheckDefaultNetworkChanged() || network->path() == default_network_path_)
     OnDefaultNetworkChanged();
 }
 
 bool NetworkStateHandler::CheckDefaultNetworkChanged() {
   std::string new_default_network_path;
   const NetworkState* new_default_network = DefaultNetwork();
   if (new_default_network)
@@ skipping 18 matching lines @@
   FOR_EACH_OBSERVER(NetworkStateHandlerObserver, observers_,
                     NetworkPropertiesUpdated(network));
   // If |connecting_network_| transitions to a non-idle, non-connecting state,
   // clear it *after* signalling observers.
   if (network->path() == connecting_network_ &&
       !network->IsConnectingState() &&
       network->connection_state() != flimflam::kStateIdle) {
     connecting_network_.clear();
     network_event_log::AddEntry(
         kLogModule, "ClearConnectingNetwork",
-        base::StringPrintf("%s: %s", network->path().c_str(),
+        base::StringPrintf("%s:%s", network->path().c_str(),
                            network->connection_state().c_str()));
   }
 }
 
 void NetworkStateHandler::ScanCompleted(const std::string& type) {
   size_t num_callbacks = scan_complete_callbacks_.count(type);
   network_event_log::AddEntry(
       kLogModule, "ScanCompleted",
-      base::StringPrintf("%s: %"PRIuS, type.c_str(), num_callbacks));
+      base::StringPrintf("%s:%"PRIuS, type.c_str(), num_callbacks));
   if (num_callbacks == 0)
     return;
   ScanCallbackList& callback_list = scan_complete_callbacks_[type];
   for (ScanCallbackList::iterator iter = callback_list.begin();
        iter != callback_list.end(); ++iter) {
     (*iter).Run();
   }
   scan_complete_callbacks_.erase(type);
 }
 
+std::string NetworkStateHandler::GetTechnologyForType(
+    const std::string& type) const {
+  if (type == kMatchTypeMobile) {
+    if (shill_property_handler_->IsTechnologyAvailable(flimflam::kTypeWimax))
+      return flimflam::kTypeWimax;
+    else
+      return flimflam::kTypeCellular;
+  }
+  if (type == kMatchTypeDefault || type == kMatchTypeNonVirtual ||
+      type == kMatchTypeWireless) {
+    NOTREACHED();
+    return flimflam::kTypeWifi;
+  }
+  return type;
+}
+
 }  // namespace chromeos