Add ConnectToBestServices call when Certs are loaded

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"
 #include "base/stringprintf.h"
 #include "base/values.h"
 #include "chromeos/network/device_state.h"
 #include "chromeos/network/managed_state.h"
 #include "chromeos/network/network_event_log.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler_observer.h"
@@ skipping 273 matching lines @@
   list->clear();
   for (ManagedStateList::const_iterator iter = network_list_.begin();
        iter != network_list_.end(); ++iter) {
     const NetworkState* network = (*iter)->AsNetworkState();
     DCHECK(network);
     list->push_back(network);
   }
 }
 
 void NetworkStateHandler::RequestScan() const {
+  network_event_log::AddEntry(kLogModule, "RequestScan", "");
   shill_property_handler_->RequestScan();
 }
 
+void NetworkStateHandler::WaitForScan(const std::string& type,
+                                      const base::Closure& callback) {
+  scan_complete_callbacks_[type].push_back(callback);
+  if (!GetScanningByType(type))
+    RequestScan();
+}
+
+void NetworkStateHandler::ConnectToBestWifiNetwork() {
+  network_event_log::AddEntry(kLogModule, "ConnectToBestWifiNetwork", "");
+  WaitForScan(flimflam::kTypeWifi,
+              base::Bind(&internal::ShillPropertyHandler::ConnectToBestServices,
+                         shill_property_handler_->AsWeakPtr()));
+}
+
 void NetworkStateHandler::SetConnectingNetwork(
     const std::string& service_path) {
   connecting_network_ = service_path;
   network_event_log::AddEntry(
       kLogModule, "SetConnectingNetwork", service_path);
 }
 
 void NetworkStateHandler::GetNetworkStatePropertiesForTest(
     base::DictionaryValue* dictionary) const {
   for (ManagedStateList::const_iterator iter = network_list_.begin();
@@ skipping 66 matching lines @@
     prev_connection_state = managed->AsNetworkState()->connection_state();
   for (base::DictionaryValue::Iterator iter(properties);
        iter.HasNext(); iter.Advance()) {
     if (type == ManagedState::MANAGED_TYPE_NETWORK) {
       if (managed->PropertyChanged(iter.key(), iter.value()))
         network_property_updated = true;
     } else {
       managed->PropertyChanged(iter.key(), iter.value());
     }
   }
+  network_event_log::AddEntry(
+      kLogModule, "PropertiesReceived",
+      base::StringPrintf("%s (%s)", path.c_str(), managed->name().c_str()));
   // Notify observers.
   if (network_property_updated) {
     NetworkState* network = managed->AsNetworkState();
     DCHECK(network);
     // Signal connection state changed after all properties have been updated.
     if (network->connection_state() != prev_connection_state)
       OnNetworkConnectionStateChanged(network);
     NetworkPropertiesUpdated(network);
   }
-  network_event_log::AddEntry(
-      kLogModule, "PropertiesReceived",
-      base::StringPrintf("%s (%s)", path.c_str(), managed->name().c_str()));
 }
 
 void NetworkStateHandler::UpdateNetworkServiceProperty(
     const std::string& service_path,
     const std::string& key,
     const base::Value& value) {
   NetworkState* network = GetModifiableNetworkState(service_path);
   if (!network)
     return;
   std::string prev_connection_state = network->connection_state();
   if (!network->PropertyChanged(key, value))
     return;
-  if (network->connection_state() != prev_connection_state)
-    OnNetworkConnectionStateChanged(network);
-
-  NetworkPropertiesUpdated(network);
 
   std::string detail = network->name() + "." + key;
   std::string vstr = ValueAsString(value);
   if (!vstr.empty())
     detail += " = " + vstr;
   network_event_log::AddEntry(kLogModule, "NetworkPropertyUpdated", detail);
+
+  if (network->connection_state() != prev_connection_state)
+    OnNetworkConnectionStateChanged(network);
+  NetworkPropertiesUpdated(network);
 }
 
 void NetworkStateHandler::UpdateNetworkServiceIPAddress(
     const std::string& service_path,
     const std::string& ip_address) {
   NetworkState* network = GetModifiableNetworkState(service_path);
   if (!network)
     return;
   std::string detail = network->name() + ".IPAddress = " + ip_address;
   network_event_log::AddEntry(kLogModule, "NetworkIPChanged", detail);
   network->set_ip_address(ip_address);
   NetworkPropertiesUpdated(network);
 }
 
 void NetworkStateHandler::UpdateDeviceProperty(const std::string& device_path,
                                                const std::string& key,
                                                const base::Value& value) {
   DeviceState* device = GetModifiableDeviceState(device_path);
   if (!device)
     return;
   if (!device->PropertyChanged(key, value))
     return;
 
-  FOR_EACH_OBSERVER(NetworkStateHandlerObserver, observers_,
-                    DeviceListChanged());
-
   std::string detail = device->name() + "." + key;
   std::string vstr = ValueAsString(value);
   if (!vstr.empty())
     detail += " = " + vstr;
   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() {
   FOR_EACH_OBSERVER(NetworkStateHandlerObserver, observers_,
                     NetworkManagerChanged());
 }
 
 void NetworkStateHandler::ManagedStateListChanged(
     ManagedState::ManagedType type) {
   if (type == ManagedState::MANAGED_TYPE_NETWORK) {
@@ skipping 104 matching lines @@
       !network->IsConnectingState() &&
       network->connection_state() != flimflam::kStateIdle) {
     connecting_network_.clear();
     network_event_log::AddEntry(
         kLogModule, "ClearConnectingNetwork",
         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));
+  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);
+}
+
 }  // namespace chromeos