Add ConnectToBestServices call when Certs are loaded

chromeos/network/shill_property_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/shill_property_handler.h"
 
 #include "base/bind.h"
 #include "base/format_macros.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
@@ skipping 82 matching lines @@
   Handler handler_;
 
   DISALLOW_COPY_AND_ASSIGN(ShillPropertyObserver);
 };
 
 //------------------------------------------------------------------------------
 // ShillPropertyHandler
 
 ShillPropertyHandler::ShillPropertyHandler(Listener* listener)
     : listener_(listener),
-      shill_manager_(DBusThreadManager::Get()->GetShillManagerClient()),
-      weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
+      shill_manager_(DBusThreadManager::Get()->GetShillManagerClient()) {
 }
 
 ShillPropertyHandler::~ShillPropertyHandler() {
   // Delete network service observers.
   STLDeleteContainerPairSecondPointers(
       observed_networks_.begin(), observed_networks_.end());
   STLDeleteContainerPairSecondPointers(
       observed_devices_.begin(), observed_devices_.end());
   CHECK(shill_manager_ == DBusThreadManager::Get()->GetShillManagerClient());
   shill_manager_->RemovePropertyChangedObserver(this);
 }
 
 void ShillPropertyHandler::Init() {
   shill_manager_->GetProperties(
       base::Bind(&ShillPropertyHandler::ManagerPropertiesCallback,
-                 weak_ptr_factory_.GetWeakPtr()));
+                 AsWeakPtr()));
   shill_manager_->AddPropertyChangedObserver(this);
 }
 
 bool ShillPropertyHandler::TechnologyAvailable(
     const std::string& technology) const {
   return available_technologies_.count(technology) != 0;
 }
 
 bool ShillPropertyHandler::TechnologyEnabled(
     const std::string& technology) const {
@@ skipping 25 matching lines @@
 }
 
 void ShillPropertyHandler::RequestScan() const {
   shill_manager_->RequestScan(
       "",
       base::Bind(&base::DoNothing),
       base::Bind(&network_handler::ShillErrorCallbackFunction,
                  kLogModule, "", network_handler::ErrorCallback()));
 }
 
+void ShillPropertyHandler::ConnectToBestServices() const {
+  network_event_log::AddEntry(kLogModule, "ConnectToBestServices", "");
+  shill_manager_->ConnectToBestServices(
+      base::Bind(&base::DoNothing),
+      base::Bind(&network_handler::ShillErrorCallbackFunction,
+                 kLogModule, "", network_handler::ErrorCallback()));
+}
+
 void ShillPropertyHandler::RequestProperties(ManagedState::ManagedType type,
                                              const std::string& path) {
   if (pending_updates_[type].find(path) != pending_updates_[type].end())
     return;  // Update already requested.
 
   pending_updates_[type].insert(path);
   if (type == ManagedState::MANAGED_TYPE_NETWORK) {
     DBusThreadManager::Get()->GetShillServiceClient()->GetProperties(
         dbus::ObjectPath(path),
         base::Bind(&ShillPropertyHandler::GetPropertiesCallback,
-                   weak_ptr_factory_.GetWeakPtr(), type, path));
+                   AsWeakPtr(), type, path));
   } else if (type == ManagedState::MANAGED_TYPE_DEVICE) {
     DBusThreadManager::Get()->GetShillDeviceClient()->GetProperties(
         dbus::ObjectPath(path),
         base::Bind(&ShillPropertyHandler::GetPropertiesCallback,
-                   weak_ptr_factory_.GetWeakPtr(), type, path));
+                   AsWeakPtr(), type, path));
   } else {
     NOTREACHED();
   }
 }
 
 void ShillPropertyHandler::OnPropertyChanged(const std::string& key,
                                              const base::Value& value) {
   if (ManagerPropertyChanged(key, value))
     listener_->ManagerPropertyChanged();
   // If the service watch or device list changed and there are no pending
@@ skipping 98 matching lines @@
       continue;
     ShillPropertyObserverMap::iterator iter2 = observer_map.find(path);
     if (iter2 != observer_map.end()) {
       new_observed[path] = iter2->second;
     } else {
       // Request an update.
       RequestProperties(type, path);
       // Create an observer for future updates.
       new_observed[path] = new ShillPropertyObserver(
           type, path, base::Bind(
-              &ShillPropertyHandler::PropertyChangedCallback,
-              weak_ptr_factory_.GetWeakPtr()));
+              &ShillPropertyHandler::PropertyChangedCallback, AsWeakPtr()));
       network_event_log::AddEntry(kLogModule, "StartObserving", path);
     }
     observer_map.erase(path);
     // Limit the number of observed services.
     if (new_observed.size() >= kMaxObserved)
       break;
   }
   // Delete network service observers still in observer_map.
   for (ShillPropertyObserverMap::iterator iter =  observer_map.begin();
        iter != observer_map.end(); ++iter) {
@@ skipping 63 matching lines @@
   listener_->UpdateManagedStateProperties(type, path, properties);
 
   if (properties.HasKey(shill::kIPConfigProperty)) {
   // Since this is the first time we received properties for this network,
   // also request its IPConfig parameters.
     std::string ip_config_path;
     if (properties.GetString(shill::kIPConfigProperty, &ip_config_path)) {
       DBusThreadManager::Get()->GetShillIPConfigClient()->GetProperties(
           dbus::ObjectPath(ip_config_path),
           base::Bind(&ShillPropertyHandler::GetIPConfigCallback,
-                     weak_ptr_factory_.GetWeakPtr(), path));
+                     AsWeakPtr(), path));
     }
   }
 
   // Notify the listener only when all updates for that type have completed.
   if (pending_updates_[type].size() == 0)
     listener_->ManagedStateListChanged(type);
 }
 
 void ShillPropertyHandler::PropertyChangedCallback(
     ManagedState::ManagedType type,
@@ skipping 14 matching lines @@
     const base::Value& value) {
   if (key == shill::kIPConfigProperty) {
     // Handle IPConfig here and call listener_->UpdateNetworkServiceIPAddress
     // when the request completes.
     std::string ip_config_path;
     value.GetAsString(&ip_config_path);
     DCHECK(!ip_config_path.empty());
     DBusThreadManager::Get()->GetShillIPConfigClient()->GetProperties(
         dbus::ObjectPath(ip_config_path),
         base::Bind(&ShillPropertyHandler::GetIPConfigCallback,
-                   weak_ptr_factory_.GetWeakPtr(), path));
+                   AsWeakPtr(), path));
   } else {
     listener_->UpdateNetworkServiceProperty(path, key, value);
   }
 }
 
 void ShillPropertyHandler::GetIPConfigCallback(
     const std::string& service_path,
     DBusMethodCallStatus call_status,
     const base::DictionaryValue& properties)  {
   if (call_status != DBUS_METHOD_CALL_SUCCESS) {
@@ skipping 11 matching lines @@
 
 void ShillPropertyHandler::NetworkDevicePropertyChangedCallback(
     const std::string& path,
     const std::string& key,
     const base::Value& value) {
   listener_->UpdateDeviceProperty(path, key, value);
 }
 
 }  // namespace internal
 }  // namespace chromeos