Add ConnectToBestServices call when Certs are loaded

chromeos/network/network_state_handler.h

 // 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.
 
 #ifndef CHROMEOS_NETWORK_NETWORK_STATE_HANDLER_H_
 #define CHROMEOS_NETWORK_NETWORK_STATE_HANDLER_H_
 
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
+#include "base/callback_forward.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/observer_list.h"
 #include "chromeos/chromeos_export.h"
 #include "chromeos/network/managed_state.h"
 #include "chromeos/network/network_handler_callbacks.h"
 #include "chromeos/network/shill_property_handler.h"
 
 namespace base {
 class DictionaryValue;
@@ skipping 109 matching lines @@
   // Sets |list| to contain the list of networks.  The returned list contains
   // a copy of NetworkState pointers which should not be stored or used beyond
   // the scope of the calling function (i.e. they may later become invalid, but
   // only on the UI thread).
   void GetNetworkList(NetworkStateList* list) const;
 
   // Requests a network scan. This may trigger updates to the network
   // list, which will trigger the appropriate observer calls.
   void RequestScan() const;
 
+  // Request a scan if not scanning and run |callback| when the Scanning state
+  // for Device type |type| completes.
+  void WaitForScan(const std::string& type, const base::Closure& callback);
+
+  // Request a network scan then signal Shill to connect to the best available
+  // networks when completed.
+  void ConnectToBestWifiNetwork();
+
   static const char kMatchTypeDefault[];
   static const char kMatchTypeWireless[];
   static const char kMatchTypeMobile[];
   static const char kMatchTypeNonVirtual[];
 
   const std::string& connecting_network() const { return connecting_network_; }
   void set_connecting_network(const std::string& service_path) {
     connecting_network_ = service_path;
   }
 
@@ skipping 39 matching lines @@
   // notifies observers. If |type| == TYPE_NETWORK this also calls
   // CheckDefaultNetworkChanged().
   virtual void ManagedStateListChanged(
       ManagedState::ManagedType type) OVERRIDE;
 
   // Called in Initialize(). Called explicitly by tests after adding
   // test observers.
   void InitShillPropertyHandler();
 
  private:
+  typedef std::list<base::Closure> ScanCallbackList;
+  typedef std::map<std::string, ScanCallbackList> ScanCompleteCallbackMap;
   friend class NetworkStateHandlerTest;
   FRIEND_TEST_ALL_PREFIXES(NetworkStateHandlerTest, NetworkStateHandlerStub);
 
   // Non-const getters for managed entries. These are const so that they can
   // be called by Get[Network|Device]State, even though they return non-const
   // pointers.
   DeviceState* GetModifiableDeviceState(const std::string& device_path) const;
   NetworkState* GetModifiableNetworkState(
       const std::string& service_path) const;
   ManagedState* GetModifiableManagedState(const ManagedStateList* managed_list,
                                           const std::string& path) const;
 
   // Gets the list specified by |type|.
   ManagedStateList* GetManagedList(ManagedState::ManagedType type);
 
   // Helper function to notify observers. Calls CheckDefaultNetworkChanged().
   void OnNetworkConnectionStateChanged(NetworkState* network);
 
   // If the default network changed returns true and sets
   // |default_network_path_|.
   bool CheckDefaultNetworkChanged();
 
   // Logs an event and notifies observers.
   void OnDefaultNetworkChanged();
 
   // Notifies observers and updates connecting_network_.
   void NetworkPropertiesUpdated(const NetworkState* network);
 
+  // Called whenever Device.Scanning state transitions to false.
+  void ScanCompleted(const std::string& type);
+
   // Shill property handler instance, owned by this class.
   scoped_ptr<internal::ShillPropertyHandler> shill_property_handler_;
 
   // Observer list
   ObserverList<NetworkStateHandlerObserver> observers_;
 
   // Lists of managed states
   ManagedStateList network_list_;
   ManagedStateList device_list_;
 
   // Keeps track of the default network for notifying observers when it changes.
   std::string default_network_path_;
 
   // Convenience member to track the user initiated connecting network. Set
   // externally when a connection is requested and cleared here when the state
   // changes to something other than Connecting (after observers are notified).
   // TODO(stevenjb): Move this to NetworkConfigurationHandler.
   std::string connecting_network_;
 
+  // Callbacks to run when a scan for the technology type completes.
+  ScanCompleteCallbackMap scan_complete_callbacks_;
+
   DISALLOW_COPY_AND_ASSIGN(NetworkStateHandler);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROMEOS_NETWORK_NETWORK_STATE_HANDLER_H_