Add NetworkStateHandler::RequestUpdateForNetwork

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"
@@ skipping 276 matching lines @@
     RequestScan();
 }
 
 void NetworkStateHandler::ConnectToBestWifiNetwork() {
   NET_LOG_EVENT("ConnectToBestWifiNetwork", "");
   WaitForScan(flimflam::kTypeWifi,
               base::Bind(&internal::ShillPropertyHandler::ConnectToBestServices,
                          shill_property_handler_->AsWeakPtr()));
 }
 
+bool NetworkStateHandler::RequestUpdateForNetwork(
+    const std::string& service_path) {
+  NetworkState* network = GetModifiableNetworkState(service_path);
+  if (!network)
+    return false;  // Only request an update for known networks.
+  network->set_update_requested(true);
+  NET_LOG_EVENT("RequestUpdate", service_path);
+  shill_property_handler_->RequestProperties(
+      ManagedState::MANAGED_TYPE_NETWORK, service_path);
+  return true;
+}
+
+void NetworkStateHandler::RequestUpdateForAllNetworks() {
+  NET_LOG_EVENT("RequestUpdateForAllNetworks", "");
+  for (ManagedStateList::iterator iter = network_list_.begin();
+       iter != network_list_.end(); ++iter) {
+    ManagedState* network = *iter;
+    network->set_update_requested(true);
+    shill_property_handler_->RequestProperties(
+        ManagedState::MANAGED_TYPE_NETWORK, network->path());
+  }
+}
+
 void NetworkStateHandler::SetConnectingNetwork(
     const std::string& service_path) {
   connecting_network_ = service_path;
   const NetworkState* network = GetNetworkState(service_path);
   if (network)
     NET_LOG_EVENT("SetConnectingNetwork", GetManagedStateLogName(network));
   else
     NET_LOG_ERROR("SetConnectingNetwork to unknown network", service_path);
 }
 
@@ skipping 81 matching lines @@
     if (type == ManagedState::MANAGED_TYPE_NETWORK) {
       if (managed->PropertyChanged(iter.key(), iter.value()))
         network_property_updated = true;
     } else {
       managed->PropertyChanged(iter.key(), iter.value());
     }
   }
   managed->InitialPropertiesReceived();
   NET_LOG_DEBUG("PropertiesReceived", GetManagedStateLogName(managed));
   // Notify observers.
-  if (network_property_updated) {
+  if (network_property_updated || managed->update_requested()) {
     NetworkState* network = managed->AsNetworkState();
     DCHECK(network);
     // Signal connection state changed after all properties have been updated.
     if (ConnectionStateChanged(network, prev_connection_state))
       OnNetworkConnectionStateChanged(network);
     NetworkPropertiesUpdated(network);
   }
+  managed->set_update_requested(false);
 }
 
 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();
@@ skipping 184 matching lines @@
   }
   if (type == kMatchTypeDefault || type == kMatchTypeNonVirtual ||
       type == kMatchTypeWireless) {
     NOTREACHED();
     return flimflam::kTypeWifi;
   }
   return type;
 }
 
 }  // namespace chromeos