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()));
+}
+
 //------------------------------------------------------------------------------
 // ShillPropertyHandler::Delegate overrides
 
 void NetworkStateHandler::UpdateManagedList(ManagedState::ManagedType type,
                                             const base::ListValue& entries) {
   ManagedStateList* managed_list = GetManagedList(type);
   VLOG(2) << "UpdateManagedList: " << type;
   // Create a map of existing entries.
   std::map<std::string, ManagedState*> managed_map;
   for (ManagedStateList::iterator iter = managed_list->begin();
@@ skipping 109 matching lines @@
                                                const base::Value& value) {
   DeviceState* device = GetModifiableDeviceState(device_path);
   if (!device)
     return;
   if (!device->PropertyChanged(key, value))
     return;
 
   FOR_EACH_OBSERVER(NetworkStateHandlerObserver, observers_,
                     DeviceListChanged());
 
+  if (key == flimflam::kScanningProperty && device->scanning() == false)
+    ScanCompleted(device->type());
+
   std::string detail = device->name() + "." + key;
   std::string vstr = ValueAsString(value);
   if (!vstr.empty())
     detail += " = " + vstr;
   network_event_log::AddEntry(kLogModule, "DevicePropertyUpdated", detail);
 }
 
 void NetworkStateHandler::ManagerPropertyChanged() {
   FOR_EACH_OBSERVER(NetworkStateHandlerObserver, observers_,
                     NetworkManagerChanged());
@@ skipping 100 matching lines @@
 }
 
 void NetworkStateHandler::NetworkPropertiesUpdated(
     const NetworkState* network) {
   if (network->path() == connecting_network_ && !network->IsConnectingState())
     connecting_network_.clear();
   FOR_EACH_OBSERVER(NetworkStateHandlerObserver, observers_,
                     NetworkPropertiesUpdated(network));
 }
 
+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