Add network testing automation hooks GetNetworkInfo() and ConnectToWifiNetwork().

Make all tests wait for network library to be ready. This is a prerequisite for the above hooks and also will make more PyAuto CONTINUOUS suite tests pass.

BUG=chromium-os:12727,chromium-os:12851
TEST=Run PyAuto test chromeos_basic.py

Review URL: http://codereview.chromium.org/6639014

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@77567 0039d316-1c4b-4281-b951-d872f2087c98

9 files changed, 239 insertions, 15 deletions

diff --git a/chrome/browser/automation/automation_provider.cc b/chrome/browser/automation/automation_provider.cc
index 86fae50..730e484 100644
--- a/chrome/browser/automation/automation_provider.cc
+++ b/chrome/browser/automation/automation_provider.cc
@@ -112,7 +112,8 @@ AutomationProvider::AutomationProvider(Profile* profile)
       reply_message_(NULL),
       reinitialize_on_channel_error_(false),
       is_connected_(false),
-      initial_loads_complete_(false) {
+      initial_tab_loads_complete_(false),
+      network_library_initialized_(true) {
   TRACE_EVENT_BEGIN("AutomationProvider::AutomationProvider", 0, "");
 
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ -176,6 +177,13 @@ bool AutomationProvider::InitializeChannel(const std::string& channel_id) {
       true, g_browser_process->shutdown_event()));
   channel_->AddFilter(automation_resource_message_filter_);
 
+#if defined(OS_CHROMEOS)
+  // Wait for the network manager to initialize.
+  // The observer will delete itself when done.
+  network_library_initialized_ = false;
+  new NetworkManagerInitObserver(this);
+#endif
+
   TRACE_EVENT_END("AutomationProvider::InitializeChannel", 0, "");
 
   return true;
@@ -188,14 +196,20 @@ std::string AutomationProvider::GetProtocolVersion() {
 
 void AutomationProvider::SetExpectedTabCount(size_t expected_tabs) {
   if (expected_tabs == 0)
-    OnInitialLoadsComplete();
+    OnInitialTabLoadsComplete();
   else
     initial_load_observer_.reset(new InitialLoadObserver(expected_tabs, this));
 }
 
-void AutomationProvider::OnInitialLoadsComplete() {
-  initial_loads_complete_ = true;
-  if (is_connected_)
+void AutomationProvider::OnInitialTabLoadsComplete() {
+  initial_tab_loads_complete_ = true;
+  if (is_connected_ && network_library_initialized_)
+    Send(new AutomationMsg_InitialLoadsComplete());
+}
+
+void AutomationProvider::OnNetworkLibraryInit() {
+  network_library_initialized_ = true;
+  if (is_connected_ && initial_tab_loads_complete_)
     Send(new AutomationMsg_InitialLoadsComplete());
 }
 
@@ -320,7 +334,7 @@ void AutomationProvider::OnChannelConnected(int pid) {
 
   // Send a hello message with our current automation protocol version.
   channel_->Send(new AutomationMsg_Hello(GetProtocolVersion()));
-  if (initial_loads_complete_)
+  if (initial_tab_loads_complete_ && network_library_initialized_)
     Send(new AutomationMsg_InitialLoadsComplete());
 }
 
diff --git a/chrome/browser/automation/automation_provider.h b/chrome/browser/automation/automation_provider.h
index 78bd424..82639ad 100644
--- a/chrome/browser/automation/automation_provider.h
+++ b/chrome/browser/automation/automation_provider.h
@@ -103,7 +103,10 @@ class AutomationProvider
 
   // Called when the inital set of tabs has finished loading.
   // Call SetExpectedTabCount(0) to set this to true immediately.
-  void OnInitialLoadsComplete();
+  void OnInitialTabLoadsComplete();
+
+  // Called when the ChromeOS network library has finished its first update.
+  void OnNetworkLibraryInit();
 
   // Get the index of a particular NavigationController object
   // in the given parent window.  This method uses
@@ -399,7 +402,10 @@ class AutomationProvider
   bool is_connected_;
 
   // True iff browser finished loading initial set of tabs.
-  bool initial_loads_complete_;
+  bool initial_tab_loads_complete_;
+
+  // True iff the Chrome OS network library finished initialization.
+  bool network_library_initialized_;
 
   // ID of automation channel.
   std::string channel_id_;
diff --git a/chrome/browser/automation/automation_provider_observers.cc b/chrome/browser/automation/automation_provider_observers.cc
index b3239a0..080aa5e 100644
--- a/chrome/browser/automation/automation_provider_observers.cc
+++ b/chrome/browser/automation/automation_provider_observers.cc
@@ -24,6 +24,10 @@
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/browser_list.h"
 #include "chrome/browser/browser_process.h"
+#if defined(OS_CHROMEOS)
+#include "chrome/browser/chromeos/cros/cros_library.h"
+#include "chrome/browser/chromeos/login/authentication_notification_details.h"
+#endif  // defined(OS_CHROMEOS)
 #include "chrome/browser/dom_operation_notification_details.h"
 #include "chrome/browser/download/download_item.h"
 #include "chrome/browser/download/save_package.h"
@@ -62,10 +66,6 @@
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/rect.h"
 
-#if defined(OS_CHROMEOS)
-#include "chrome/browser/chromeos/login/authentication_notification_details.h"
-#endif
-
 // Holds onto start and stop timestamps for a particular tab
 class InitialLoadObserver::TabTime {
  public:
@@ -150,8 +150,33 @@ DictionaryValue* InitialLoadObserver::GetTimingInformation() const {
 void InitialLoadObserver::ConditionMet() {
   registrar_.RemoveAll();
   if (automation_)
-    automation_->OnInitialLoadsComplete();
+    automation_->OnInitialTabLoadsComplete();
+}
+
+#if defined(OS_CHROMEOS)
+NetworkManagerInitObserver::NetworkManagerInitObserver(
+    AutomationProvider* automation)
+    : automation_(automation->AsWeakPtr()) {
+  if (chromeos::CrosLibrary::Get()->EnsureLoaded()) {
+    chromeos::CrosLibrary::Get()->GetNetworkLibrary()->
+        AddNetworkManagerObserver(this);
+  } else {
+    automation_->OnNetworkLibraryInit();
+    delete this;
+  }
+}
+
+NetworkManagerInitObserver::~NetworkManagerInitObserver() {}
+
+void NetworkManagerInitObserver::OnNetworkManagerChanged(
+    chromeos::NetworkLibrary* obj) {
+  if (!obj->wifi_scanning()) {
+    obj->RemoveNetworkManagerObserver(this);
+    automation_->OnNetworkLibraryInit();
+    delete this;
+  }
 }
+#endif  // defined(OS_CHROMEOS)
 
 NewTabUILoadObserver::NewTabUILoadObserver(AutomationProvider* automation)
     : automation_(automation->AsWeakPtr()) {
@@ -1282,7 +1307,7 @@ void ScreenLockUnlockObserver::Observe(NotificationType type,
     reply.SendError("Screen lock failure.");
   delete this;
 }
-#endif
+#endif  // defined(OS_CHROMEOS)
 
 AutomationProviderBookmarkModelObserver::
 AutomationProviderBookmarkModelObserver(
diff --git a/chrome/browser/automation/automation_provider_observers.h b/chrome/browser/automation/automation_provider_observers.h
index 2887389..5eed0ad 100644
--- a/chrome/browser/automation/automation_provider_observers.h
+++ b/chrome/browser/automation/automation_provider_observers.h
@@ -18,6 +18,9 @@
 #include "chrome/browser/automation/automation_provider_json.h"
 #include "chrome/browser/bookmarks/bookmark_model_observer.h"
 #include "chrome/browser/browsing_data_remover.h"
+#if defined(OS_CHROMEOS)
+#include "chrome/browser/chromeos/cros/network_library.h"
+#endif  // defined(OS_CHROMEOS)
 #include "chrome/browser/download/download_item.h"
 #include "chrome/browser/download/download_manager.h"
 #include "chrome/browser/history/history.h"
@@ -90,6 +93,23 @@ class InitialLoadObserver : public NotificationObserver {
   DISALLOW_COPY_AND_ASSIGN(InitialLoadObserver);
 };
 
+#if defined(OS_CHROMEOS)
+// Watches for NetworkManager events. Because NetworkLibrary loads
+// asynchronously, this is used to make sure it is done before tests are run.
+class NetworkManagerInitObserver
+    : public chromeos::NetworkLibrary::NetworkManagerObserver {
+ public:
+  explicit NetworkManagerInitObserver(AutomationProvider* automation);
+  virtual ~NetworkManagerInitObserver();
+  virtual void OnNetworkManagerChanged(chromeos::NetworkLibrary* obj);
+
+ private:
+  base::WeakPtr<AutomationProvider> automation_;
+
+  DISALLOW_COPY_AND_ASSIGN(NetworkManagerInitObserver);
+};
+#endif  // defined(OS_CHROMEOS)
+
 // Watches for NewTabUI page loads for performance timing purposes.
 class NewTabUILoadObserver : public NotificationObserver {
  public:
@@ -674,7 +694,7 @@ class ScreenLockUnlockObserver : public NotificationObserver {
 
   DISALLOW_COPY_AND_ASSIGN(ScreenLockUnlockObserver);
 };
-#endif
+#endif  // defined(OS_CHROMEOS)
 
 // Waits for the bookmark model to load.
 class AutomationProviderBookmarkModelObserver : BookmarkModelObserver {
diff --git a/chrome/browser/automation/testing_automation_provider.cc b/chrome/browser/automation/testing_automation_provider.cc
index a9d212e..d948dc0 100644
--- a/chrome/browser/automation/testing_automation_provider.cc
+++ b/chrome/browser/automation/testing_automation_provider.cc
@@ -2150,6 +2150,10 @@ void TestingAutomationProvider::SendJSONRequest(int handle,
   handler_map["Logout"] = &TestingAutomationProvider::Logout;
   handler_map["ScreenLock"] = &TestingAutomationProvider::ScreenLock;
   handler_map["ScreenUnlock"] = &TestingAutomationProvider::ScreenUnlock;
+
+  handler_map["GetNetworkInfo"] = &TestingAutomationProvider::GetNetworkInfo;
+  handler_map["ConnectToWifiNetwork"] =
+      &TestingAutomationProvider::ConnectToWifiNetwork;
 #endif  // defined(OS_CHROMEOS)
 
   std::map<std::string, BrowserJsonHandler> browser_handler_map;
diff --git a/chrome/browser/automation/testing_automation_provider.h b/chrome/browser/automation/testing_automation_provider.h
index e391579..b6b369a 100644
--- a/chrome/browser/automation/testing_automation_provider.h
+++ b/chrome/browser/automation/testing_automation_provider.h
@@ -977,6 +977,10 @@ class TestingAutomationProvider : public AutomationProvider,
   void ScreenLock(DictionaryValue* args, IPC::Message* reply_message);
 
   void ScreenUnlock(DictionaryValue* args, IPC::Message* reply_message);
+
+  void GetNetworkInfo(DictionaryValue* args, IPC::Message* reply_message);
+
+  void ConnectToWifiNetwork(DictionaryValue* args, IPC::Message* reply_message);
 #endif  // defined(OS_CHROMEOS)
 
   void WaitForTabCountToBecome(int browser_handle,
diff --git a/chrome/browser/automation/testing_automation_provider_chromeos.cc b/chrome/browser/automation/testing_automation_provider_chromeos.cc
index c34f02a..f8efa05 100644
--- a/chrome/browser/automation/testing_automation_provider_chromeos.cc
+++ b/chrome/browser/automation/testing_automation_provider_chromeos.cc
@@ -8,9 +8,27 @@
 #include "chrome/browser/automation/automation_provider_json.h"
 #include "chrome/browser/automation/automation_provider_observers.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
+#include "chrome/browser/chromeos/cros/network_library.h"
 #include "chrome/browser/chromeos/cros/screen_lock_library.h"
 #include "chrome/browser/chromeos/login/existing_user_controller.h"
 
+using chromeos::CrosLibrary;
+using chromeos::NetworkLibrary;
+
+namespace {
+
+DictionaryValue* GetNetworkInfoDict(const chromeos::Network* network) {
+  DictionaryValue* item = new DictionaryValue;
+  item->SetString("service_path", network->service_path());
+  item->SetString("name", network->name());
+  item->SetString("device_path", network->device_path());
+  item->SetString("ip_address", network->ip_address());
+  item->SetString("status", network->GetStateString());
+  return item;
+}
+
+}  // namespace
+
 void TestingAutomationProvider::LoginAsGuest(DictionaryValue* args,
                                              IPC::Message* reply_message) {
   chromeos::ExistingUserController* controller =
@@ -62,3 +80,104 @@ void TestingAutomationProvider::ScreenUnlock(DictionaryValue* args,
   chromeos::CrosLibrary::Get()->GetScreenLockLibrary()->
       NotifyScreenUnlockRequested();
 }
+
+void TestingAutomationProvider::GetNetworkInfo(DictionaryValue* args,
+                                               IPC::Message* reply_message) {
+  AutomationJSONReply reply(this, reply_message);
+
+  if (!CrosLibrary::Get()->EnsureLoaded()) {
+    reply.SendError("Could not load cros library.");
+    return;
+  }
+
+  NetworkLibrary* network_library = CrosLibrary::Get()->GetNetworkLibrary();
+  scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
+
+  // IP address.
+  return_value->SetString("ip_address", network_library->IPAddress());
+
+  // Ethernet network.
+  bool ethernet_available = network_library->ethernet_available();
+  bool ethernet_enabled = network_library->ethernet_enabled();
+  if (ethernet_available && ethernet_enabled) {
+    const chromeos::EthernetNetwork* ethernet_network =
+        network_library->ethernet_network();
+    if (ethernet_network)
+      return_value->Set("ethernet_network",
+                        GetNetworkInfoDict(ethernet_network));
+  }
+
+  // Wi-fi networks.
+  bool wifi_available = network_library->wifi_available();
+  bool wifi_enabled = network_library->wifi_enabled();
+  if (wifi_available && wifi_enabled) {
+    const chromeos::WifiNetworkVector& wifi_networks =
+        network_library->wifi_networks();
+    ListValue* items = new ListValue;
+    for (size_t i = 0; i < wifi_networks.size(); ++i) {
+      DictionaryValue* item = GetNetworkInfoDict(wifi_networks[i]);
+      item->SetInteger("strength", wifi_networks[i]->strength());
+      item->SetBoolean("encrypted", wifi_networks[i]->encrypted());
+      item->SetString("encryption", wifi_networks[i]->GetEncryptionString());
+      items->Append(item);
+    }
+    return_value->Set("wifi_networks", items);
+  }
+
+  // Cellular networks.
+  bool cellular_available = network_library->cellular_available();
+  bool cellular_enabled = network_library->cellular_enabled();
+  if (cellular_available && cellular_enabled) {
+    const chromeos::CellularNetworkVector& cellular_networks =
+        network_library->cellular_networks();
+    ListValue* items = new ListValue;
+    for (size_t i = 0; i < cellular_networks.size(); ++i) {
+      DictionaryValue* item = GetNetworkInfoDict(cellular_networks[i]);
+      item->SetInteger("strength", cellular_networks[i]->strength());
+      item->SetString("operator_name", cellular_networks[i]->operator_name());
+      item->SetString("operator_code", cellular_networks[i]->operator_code());
+      item->SetString("payment_url", cellular_networks[i]->payment_url());
+      item->SetString("usage_url", cellular_networks[i]->usage_url());
+      item->SetString("network_technology",
+                      cellular_networks[i]->GetNetworkTechnologyString());
+      item->SetString("connectivity_state",
+                      cellular_networks[i]->GetConnectivityStateString());
+      item->SetString("activation_state",
+                      cellular_networks[i]->GetActivationStateString());
+      item->SetString("roaming_state",
+                      cellular_networks[i]->GetRoamingStateString());
+      items->Append(item);
+    }
+    return_value->Set("cellular_networks", items);
+  }
+
+  reply.SendSuccess(return_value.get());
+}
+
+void TestingAutomationProvider::ConnectToWifiNetwork(
+    DictionaryValue* args, IPC::Message* reply_message) {
+  AutomationJSONReply reply(this, reply_message);
+  std::string service_path, password, identity, certpath;
+  if (!args->GetString("service_path", &service_path) ||
+      !args->GetString("password", &password) ||
+      !args->GetString("identity", &identity) ||
+      !args->GetString("certpath", &certpath)) {
+    reply.SendError("Invalid or missing args");
+    return;
+  }
+
+  if (!CrosLibrary::Get()->EnsureLoaded()) {
+    reply.SendError("Could not load cros library.");
+    return;
+  }
+
+  NetworkLibrary* network_library = CrosLibrary::Get()->GetNetworkLibrary();
+  if (!network_library->ConnectToWifiNetwork(
+      service_path, password, identity, certpath)) {
+    reply.SendError("Failed to connect");
+    return;
+  }
+
+  reply.SendSuccess(NULL);
+}
+
diff --git a/chrome/test/functional/chromeos_basic.py b/chrome/test/functional/chromeos_basic.py
index 30cf789..7bd00d2 100644
--- a/chrome/test/functional/chromeos_basic.py
+++ b/chrome/test/functional/chromeos_basic.py
@@ -3,6 +3,7 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
+import logging
 import pyauto_functional
 import pyauto
 
@@ -26,6 +27,12 @@ class ChromeosBasic(pyauto.PyUITest):
     self.RestartBrowser(clear_profile=False)
     self.assertEqual(1, len(self.GetHistoryInfo().History()))
 
+  def testNetworkInfo(self):
+    """Get basic info on networks."""
+    result = self.GetNetworkInfo()
+    self.assertTrue(result)
+    logging.debug(result)
+
 
 if __name__ == '__main__':
   pyauto_functional.Main()
diff --git a/chrome/test/pyautolib/pyauto.py b/chrome/test/pyautolib/pyauto.py
index 9b0f47c..ca782be 100644
--- a/chrome/test/pyautolib/pyauto.py
+++ b/chrome/test/pyautolib/pyauto.py
@@ -2286,6 +2286,31 @@ class PyUITest(pyautolib.PyUITestBase, unittest.TestCase):
     }
     return self._GetResultFromJSONRequest(cmd_dict, windex=-1)
 
+  def GetNetworkInfo(self):
+    """Get details about ethernet, wifi, and cellular networks on chromeos.
+
+    Raises:
+      pyauto_errors.JSONInterfaceError if the automation call returns an error.
+    """
+    cmd_dict = { 'command': 'GetNetworkInfo' }
+    return self._GetResultFromJSONRequest(cmd_dict, windex=-1)
+
+  def ConnectToWifiNetwork(self, service_path,
+                           password='', identity='', certpath=''):
+    """Connect to a wifi network by its service path.
+
+    Raises:
+      pyauto_errors.JSONInterfaceError if the automation call returns an error.
+    """
+    cmd_dict = {
+        'command': 'ConnectToWifiNetwork',
+        'service_path': service_path,
+        'password': password,
+        'identity': identity,
+        'certpath': certpath,
+    }
+    return self._GetResultFromJSONRequest(cmd_dict, windex=-1)
+
   ## ChromeOS section -- end