Fix bug where auto-connect setting is not immediately saved....

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"
 #include "chrome/browser/chrome_thread.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "net/url_request/url_request_job.h"
 
 // Allows InvokeLater without adding refcounting. This class is a Singleton and
 // won't be deleted until it's last InvokeLater is run.
 DISABLE_RUNNABLE_METHOD_REFCOUNT(chromeos::NetworkLibraryImpl);
 
 namespace chromeos {
 
+static const std::string kGoogleWifi = "Google";
 static const std::string kGoogleAWifi = "Google-A";
 
 // Helper function to wrap Html with <th> tag.
 static std::string WrapWithTH(std::string text) {
   return "<th>" + text + "</th>";
 }
 
 // Helper function to wrap Html with <td> tag.
 static std::string WrapWithTD(std::string text) {
   return "<td>" + text + "</td>";
@@ skipping 219 matching lines @@
 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()) {
-    LOG(INFO) << "Attempting to auto-connect to Google-A wifi.";
+    LOG(INFO) << "Attempting to auto-connect to Google wifi.";
     // First force a refresh of the system info.
     UpdateSystemInfo();
 
     // If ethernet is connected, then don't bother.
     if (ethernet_connected()) {
-      LOG(INFO) << "Ethernet connected, so don't need Google-A.";
+      LOG(INFO) << "Ethernet connected, so don't need Google wifi.";
       return false;
     }
 
-    // Find Google-A network.
-    WifiNetwork wifi;
-    bool found = GetWifiNetworkByName(kGoogleAWifi, &wifi);
-    if (!found) {
-      LOG(INFO) << "Google-A wifi not found.";
+    // First look for Google-A then look for Google.
+    // Only care if set to auto-connect.
+    WifiNetwork* wifi = GetWifiNetworkByName(kGoogleAWifi);
+    // If wifi found and set to not auto-connect, then ignore it.
+    if (wifi && !wifi->auto_connect())
+      wifi = NULL;
+
+    if (!wifi) {
+      wifi = GetWifiNetworkByName(kGoogleWifi);
+      // If wifi found and set to not auto-connect, then ignore it.
+      if (wifi && !wifi->auto_connect())
+        wifi = NULL;
+    }
+
+    if (!wifi) {
+      LOG(INFO) << "Google-A/Google wifi not found or set to not auto-connect.";
       return false;
     }
 
-    // Make sure we want to auto-connect.
-    // Since auto-connect is true, we assume the identity and certificate
-    // is setup propertly. If it's not, the connection will fail.
-    if (!wifi.auto_connect()) {
-      LOG(INFO) << "Google-A wifi is set to not auto-connect.";
-      return false;
-    }
+    // Save the wifi path, so we know which one we want to auto-connect to.
+    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();
-      GetWifiNetworkByName(kGoogleAWifi, &wifi);
+      wifi = GetWifiNetworkByPath(wifi_path);
       // See if identity and certpath are available.
-      if (!wifi.identity().empty() && !wifi.cert_path().empty()) {
-        LOG(INFO) << "Google-A wifi set up after " << (i*0.1) << " seconds.";
+      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) {
-      LOG(INFO) << "Google-A wifi not set up after 3 seconds.";
+      LOG(INFO) << "Google wifi not set up after 3 seconds.";
       return false;
     }
 
-    // Now that we have a setup Google-A, we can connect to it.
-    ConnectToNetwork(wifi.service_path().c_str(), NULL);
+    // Now that we have a setup Google wifi, we can connect to it.
+    ConnectToNetwork(wifi_path.c_str(), NULL);
     return true;
   }
   return false;
 }
 
 bool NetworkLibraryImpl::PreferredNetworkConnected() {
-  WifiNetwork wifi;
-  bool found = GetWifiNetworkByName(kGoogleAWifi, &wifi);
-  return found && wifi.connected();
+  WifiNetwork* wifi = GetWifiNetworkByName(kGoogleAWifi);
+  return wifi && wifi->connected();
 }
 
 bool NetworkLibraryImpl::PreferredNetworkFailed() {
-  WifiNetwork wifi;
-  bool found = GetWifiNetworkByName(kGoogleAWifi, &wifi);
-  return !found || wifi.failed();
+  WifiNetwork* wifi = GetWifiNetworkByName(kGoogleAWifi);
+  return !wifi || wifi->failed();
 }
 
 void NetworkLibraryImpl::ConnectToWifiNetwork(WifiNetwork network,
                                               const string16& password,
                                               const string16& identity,
                                               const string16& certpath) {
   if (CrosLibrary::Get()->EnsureLoaded()) {
     ConnectToNetworkWithCertInfo(network.service_path().c_str(),
                      password.empty() ? NULL : UTF16ToUTF8(password).c_str(),
                      identity.empty() ? NULL : UTF16ToUTF8(identity).c_str(),
@@ skipping 35 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());
+  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());
   }
 }
 
 void NetworkLibraryImpl::ForgetWirelessNetwork(const WirelessNetwork& network) {
   if (CrosLibrary::Get()->EnsureLoaded()) {
@@ skipping 182 matching lines @@
 }
 
 void NetworkLibraryImpl::UpdateSystemInfo() {
   SystemInfo* system = GetSystemInfo();
   if (system) {
     UpdateNetworkStatus(system);
     FreeSystemInfo(system);
   }
 }
 
-bool NetworkLibraryImpl::GetWifiNetworkByName(const std::string& name,
-                                              WifiNetwork* wifi) {
+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) {
-      *wifi = wifi_networks_[i];
-      return true;
+      return &wifi_networks_[i];
     }
   }
-  return false;
+  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;
 }
 
 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