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 292 matching lines @@
     RequestScan();
 }
 
 void NetworkStateHandler::ConnectToBestWifiNetwork() {
   network_event_log::AddEntry(kLogModule, "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);
+  network_event_log::AddEntry(kLogModule, "RequestUpdate", service_path);
+  shill_property_handler_->RequestProperties(
+      ManagedState::MANAGED_TYPE_NETWORK, service_path);
+  return true;
+}
+
+void NetworkStateHandler::RequestUpdateForAllNetworks() {
+  network_event_log::AddEntry(kLogModule, "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;
   network_event_log::AddEntry(
       kLogModule, "SetConnectingNetwork", service_path);
 }
 
 void NetworkStateHandler::GetNetworkStatePropertiesForTest(
     base::DictionaryValue* dictionary) const {
   for (ManagedStateList::const_iterator iter = network_list_.begin();
@@ skipping 81 matching lines @@
         network_property_updated = true;
     } else {
       managed->PropertyChanged(iter.key(), iter.value());
     }
   }
   managed->InitialPropertiesReceived();
   network_event_log::AddEntry(
       kLogModule, "PropertiesReceived",
       base::StringPrintf("%s (%s)", path.c_str(), managed->name().c_str()));
   // Notify observers.
-  if (network_property_updated) {
+  if (network_property_updated || managed->update_requested()) {

[pneubeck (no reviews), 2013/05/22 08:42:40]

a comment about your intent (guaranteed notification after request) either here
or at the Request*() methods in the header might be helpful for future readers.

[stevenjb, 2013/05/22 16:08:23]

Good thought, comment added.

     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 189 matching lines @@
   }
   if (type == kMatchTypeDefault || type == kMatchTypeNonVirtual ||
       type == kMatchTypeWireless) {
     NOTREACHED();
     return flimflam::kTypeWifi;
   }
   return type;
 }
 
 }  // namespace chromeos