Add ConnectToBestServices call when Certs are loaded

chromeos/network/shill_property_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_SHILL_PROPERTY_HANDLER_H_
 #define CHROMEOS_NETWORK_SHILL_PROPERTY_HANDLER_H_
 
 #include <list>
 #include <map>
 #include <set>
@@ skipping 20 matching lines @@
 class ShillPropertyObserver;
 
 // This class handles Shill calls and observers to reflect the state of the
 // Shill Manager and its services and devices. It observes Shill.Manager and
 // requests properties for new devices/networks. It takes a Listener in its
 // constructor (e.g. NetworkStateHandler) that it calls when properties change
 // (including once to set their initial state after Init() gets called).
 // It also observes Shill.Service for all services in Manager.ServiceWatchList.
 // This class must not outlive the ShillManagerClient instance.
 class CHROMEOS_EXPORT ShillPropertyHandler
-    : public ShillPropertyChangedObserver {
+    : public ShillPropertyChangedObserver,
+      public base::SupportsWeakPtr<ShillPropertyHandler> {

[Greg Spencer (Chromium), 2013/04/01 19:37:18]

Ooh, is that the new way to do weak pointer support?  Nice.

[stevenjb, 2013/04/01 20:34:48]

It's not exactly new, I'm not sure why I usually use a member instead of
inheriting SupportsWeakPtr. This is definitely better though if another class
needs to access this as a weak ptr though.

  public:
   typedef std::map<std::string, ShillPropertyObserver*>
       ShillPropertyObserverMap;
 
   class CHROMEOS_EXPORT Listener {
    public:
     // Called when the entries in a managed list have changed.
     virtual void UpdateManagedList(ManagedState::ManagedType type,
                                    const base::ListValue& entries) = 0;
 
@@ skipping 48 matching lines @@
   // Asynchronously sets the enabled state for |technology|.
   // Note: Modifes Manager state. Calls |error_callback| on failure.
   void SetTechnologyEnabled(
       const std::string& technology,
       bool enabled,
       const network_handler::ErrorCallback& error_callback);
 
   // Requests an immediate network scan.
   void RequestScan() const;
 
+  // Calls Manager.ConnectToBestServices().
+  void ConnectToBestServices() const;
+
   // Requests all properties for the service or device (called for new items).
   void RequestProperties(ManagedState::ManagedType type,
                          const std::string& path);
 
   // Returns true if |service_path| is being observed.
   bool IsObservingNetwork(const std::string& service_path) {
     return observed_networks_.count(service_path) != 0;
   }
 
   // ShillPropertyChangedObserver overrides
@@ skipping 57 matching lines @@
   ShillPropertyObserverMap observed_networks_;
 
   // List of network devices with Shill property changed observers
   ShillPropertyObserverMap observed_devices_;
 
   // Lists of available / enabled / uninitialized technologies
   std::set<std::string> available_technologies_;
   std::set<std::string> enabled_technologies_;
   std::set<std::string> uninitialized_technologies_;
 
-  // For Shill client callbacks
-  base::WeakPtrFactory<ShillPropertyHandler> weak_ptr_factory_;
-
   DISALLOW_COPY_AND_ASSIGN(ShillPropertyHandler);
 };
 
 }  // namespace internal
 }  // namespace chromeos
 
 #endif  // CHROMEOS_NETWORK_SHILL_PROPERTY_HANDLER_H_