Push change for stevenjb:...

chrome/browser/chromeos/cros/network_library.cc

 // Copyright (c) 2010 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 "chrome/browser/chromeos/cros/network_library.h"
 
 #include <algorithm>
 
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
@@ skipping 245 matching lines @@
 }
 
 void NetworkLibraryImpl::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void NetworkLibraryImpl::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
+////////////////////////////////////////////////////////////////////////////////
+
+bool NetworkLibraryImpl::FindWifiNetworkByPath(
+    const std::string& path, WifiNetwork* result) const {
+  const WifiNetwork* wifi =
+      GetWirelessNetworkByPath(wifi_networks_, path);
+  if (wifi) {
+    if (result)
+      *result = *wifi;
+    return true;
+  }
+  return false;
+}
+
+bool NetworkLibraryImpl::FindCellularNetworkByPath(
+    const std::string& path, CellularNetwork* result) const {
+  const CellularNetwork* cellular =
+      GetWirelessNetworkByPath(cellular_networks_, path);
+  if (cellular) {
+    if (result)
+      *result = *cellular;
+    return true;
+  }
+  return false;
+}
+
 void NetworkLibraryImpl::RequestWifiScan() {
   if (CrosLibrary::Get()->EnsureLoaded()) {
     RequestScan(TYPE_WIFI);
   }
 }
 
 bool NetworkLibraryImpl::ConnectToPreferredNetworkIfAvailable() {
   // TODO(chocobo): Add the concept of preferred network to libcros.
   // So that we don't have to hard-code Google-A here.
   if (CrosLibrary::Get()->EnsureLoaded()) {
@@ skipping 17 matching lines @@
     const std::string wifi_path = wifi->service_path();
 
     // It takes some time for the enterprise daemon to start up and populate the
     // certificate and identity. So we wait at most 3 seconds here. And every
     // 100ms, we refetch the system info and check the cert and identify on the
     // wifi. The enterprise daemon takes between 0.4 to 0.9 seconds to setup.
     bool setup = false;
     for (int i = 0; i < 30; i++) {
       // Update the system and refetch the network.
       UpdateSystemInfo();
-      wifi = GetWifiNetworkByPath(wifi_path);
+      wifi = GetWirelessNetworkByPath(wifi_networks_, wifi_path);
       // See if identity and certpath are available.
       if (wifi && !wifi->identity().empty() && !wifi->cert_path().empty()) {
         LOG(INFO) << "Google wifi set up after " << (i*0.1) << " seconds.";
         setup = true;
         break;
       }
       PlatformThread::Sleep(100);
     }
 
     if (!setup) {
@@ skipping 65 matching lines @@
 
 void NetworkLibraryImpl::DisconnectFromWirelessNetwork(
     const WirelessNetwork& network) {
   if (CrosLibrary::Get()->EnsureLoaded()) {
     DisconnectFromNetwork(network.service_path().c_str());
   }
 }
 
 void NetworkLibraryImpl::SaveWifiNetwork(const WifiNetwork& network) {
   // Update the wifi network in the local cache.
-  WifiNetwork* wifi = GetWifiNetworkByPath(network.service_path());
+  WifiNetwork* wifi = GetWirelessNetworkByPath(wifi_networks_,
+                                               network.service_path());
   if (wifi)
     *wifi = network;
 
   // Update the wifi network with libcros.
   if (CrosLibrary::Get()->EnsureLoaded()) {
     SetPassphrase(network.service_path().c_str(), network.passphrase().c_str());
     SetIdentity(network.service_path().c_str(), network.identity().c_str());
     SetCertPath(network.service_path().c_str(), network.cert_path().c_str());
     SetAutoConnect(network.service_path().c_str(), network.auto_connect());
   }
@@ skipping 212 matching lines @@
 
 WifiNetwork* NetworkLibraryImpl::GetWifiNetworkByName(const std::string& name) {
   for (size_t i = 0; i < wifi_networks_.size(); ++i) {
     if (wifi_networks_[i].name().compare(name) == 0) {
       return &wifi_networks_[i];
     }
   }
   return NULL;
 }
 
-WifiNetwork* NetworkLibraryImpl::GetWifiNetworkByPath(const std::string& path) {
-  for (size_t i = 0; i < wifi_networks_.size(); ++i) {
-    if (wifi_networks_[i].service_path().compare(path) == 0) {
-      return &wifi_networks_[i];
-    }
-  }
-  return NULL;
+template<typename T> T* NetworkLibraryImpl::GetWirelessNetworkByPath(
+    std::vector<T>& networks, const std::string& path) {
+  typedef typename std::vector<T>::iterator iter_t;
+  iter_t iter = std::find_if(networks.begin(), networks.end(),
+                             WirelessNetwork::ServicePathEq(path));
+  return (iter != networks.end()) ? &(*iter) : NULL;
+}
+
+// const version
+template<typename T> const T* NetworkLibraryImpl::GetWirelessNetworkByPath(
+    const std::vector<T>& networks, const std::string& path) const {
+  typedef typename std::vector<T>::const_iterator iter_t;
+  iter_t iter = std::find_if(networks.begin(), networks.end(),
+                             WirelessNetwork::ServicePathEq(path));
+  return (iter != networks.end()) ? &(*iter) : NULL;
 }
 
 void NetworkLibraryImpl::EnableNetworkDeviceType(ConnectionType device,
                                                  bool enable) {
   if (!CrosLibrary::Get()->EnsureLoaded())
     return;
 
   // If network device is already enabled/disabled, then don't do anything.
   if (enable && (enabled_devices_ & (1 << device))) {
     LOG(WARNING) << "Trying to enable a device that's already enabled: "
@@ skipping 104 matching lines @@
   if (ethernet_connected())
     return ethernet_.ip_address();
   if (wifi_connected())
     return wifi_.ip_address();
   if (cellular_connected())
     return cellular_.ip_address();
   return ethernet_.ip_address();
 }
 
 }  // namespace chromeos