Adding the first set of remote test cases and associated framework.

chrome/test/remoting/remote_desktop_browsertest.cc

 // Copyright 2013 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/test/remoting/remote_desktop_browsertest.h"
 
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/path_service.h"
@@ skipping 11 matching lines @@
 #include "extensions/browser/extension_registry.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_set.h"
 #include "extensions/common/switches.h"
 #include "ui/base/window_open_disposition.h"
 
 namespace remoting {
 
 RemoteDesktopBrowserTest::RemoteDesktopBrowserTest()
-    : extension_(NULL) {
+    : remote_test_helper_(nullptr), extension_(nullptr) {
 }
 
 RemoteDesktopBrowserTest::~RemoteDesktopBrowserTest() {}
 
 void RemoteDesktopBrowserTest::SetUp() {
   ParseCommandLine();
   PlatformAppBrowserTest::SetUp();
 }
 
 void RemoteDesktopBrowserTest::SetUpOnMainThread() {
@@ skipping 22 matching lines @@
   ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(
       browser(), GURL("http://www.google.com"), 1);
 
   EXPECT_EQ(GetCurrentURL().host(), "www.google.com");
 }
 
 void RemoteDesktopBrowserTest::OpenClientBrowserPage() {
   // Open the client browser page in a new tab
   ui_test_utils::NavigateToURLWithDisposition(
       browser(),
-      GURL(http_server() + "/clientpage.html"),
+      GURL(http_server() + "/client.html"),
       NEW_FOREGROUND_TAB, ui_test_utils::BROWSER_TEST_WAIT_FOR_TAB);
 
   // Save this web content for later reference
   client_web_content_ = browser()->tab_strip_model()->GetActiveWebContents();
 
   // Go back to the previous tab that has chromoting opened
   browser()->tab_strip_model()->SelectPreviousTab();
+
+  // Create the RemoteTestHelper object to use.
+  remote_test_helper_.reset(new RemoteTestHelper(client_web_content_));
 }
 
 bool RemoteDesktopBrowserTest::HtmlElementVisible(const std::string& name) {
   _ASSERT_TRUE(HtmlElementExists(name));
 
   ExecuteScript(
       "function isElementVisible(name) {"
       "  var element = document.getElementById(name);"
       "  /* The existence of the element has already been ASSERTed. */"
       "  do {"
@@ skipping 577 matching lines @@
       content::Source<content::NavigationController>(
           &active_web_contents()->
               GetController()));
 
   ExecuteScript(script);
 
   observer.Wait();
 }
 
 // static
-bool RemoteDesktopBrowserTest::ExecuteScriptAndExtractBool(
-    content::WebContents* web_contents, const std::string& script) {
-  bool result;
-  EXPECT_TRUE(content::ExecuteScriptAndExtractBool(
-      web_contents,
-      "window.domAutomationController.send(" + script + ");",
-      &result));
-
-  return result;
-}
-
-// static
-int RemoteDesktopBrowserTest::ExecuteScriptAndExtractInt(
-    content::WebContents* web_contents, const std::string& script) {
-  int result;
-  _ASSERT_TRUE(content::ExecuteScriptAndExtractInt(
-      web_contents,
-      "window.domAutomationController.send(" + script + ");",
-      &result));
-
-  return result;
-}
-
-// static
-std::string RemoteDesktopBrowserTest::ExecuteScriptAndExtractString(
-    content::WebContents* web_contents, const std::string& script) {
-  std::string result;
-  _ASSERT_TRUE(content::ExecuteScriptAndExtractString(
-      web_contents,
-      "window.domAutomationController.send(" + script + ");",
-      &result));
-
-  return result;
-}
-
-// static
 bool RemoteDesktopBrowserTest::LoadScript(
     content::WebContents* web_contents,
     const base::FilePath::StringType& path) {
   std::string script;
   base::FilePath src_dir;
   _ASSERT_TRUE(PathService::Get(base::DIR_EXE, &src_dir));
   base::FilePath script_path = src_dir.Append(path);
 
   if (!base::ReadFileToString(script_path, &script)) {
     LOG(ERROR) << "Failed to load script " << script_path.value();
@@ skipping 37 matching lines @@
 
   EXPECT_TRUE(succeeded) << error_message << "\n" << stack_trace;
 }
 
 void RemoteDesktopBrowserTest::ClickOnControl(const std::string& name) {
   ASSERT_TRUE(HtmlElementVisible(name));
 
   std::string has_disabled_attribute =
     "document.getElementById('" + name + "').hasAttribute('disabled')";
 
-  if (ExecuteScriptAndExtractBool(active_web_contents(),
-                                  has_disabled_attribute)) {
+  if (RemoteTestHelper::ExecuteScriptAndExtractBool(active_web_contents(),
+                                                    has_disabled_attribute)) {
     // This element has a disabled attribute. Wait for it become enabled.
     ConditionalTimeoutWaiter waiter(
           base::TimeDelta::FromSeconds(5),
           base::TimeDelta::FromMilliseconds(500),
           base::Bind(&RemoteDesktopBrowserTest::IsEnabled,
             active_web_contents(), name));
     ASSERT_TRUE(waiter.Wait());
   }
 
   ExecuteScript("document.getElementById(\"" + name + "\").click();");
@@ skipping 99 matching lines @@
   // Now get the dictionary for the specified account type.
   const base::DictionaryValue* account_dict = NULL;
   ASSERT_TRUE(root_dict->GetDictionary(account_type, &account_dict));
   ASSERT_TRUE(account_dict->GetString(kUserName, &username_));
   ASSERT_TRUE(account_dict->GetString(kUserPassword, &password_));
 }
 
 // static
 bool RemoteDesktopBrowserTest::IsAuthenticatedInWindow(
     content::WebContents* web_contents) {
-  return ExecuteScriptAndExtractBool(
+  return RemoteTestHelper::ExecuteScriptAndExtractBool(
       web_contents, "remoting.identity.isAuthenticated()");
 }
 
 // static
 bool RemoteDesktopBrowserTest::IsHostActionComplete(
     content::WebContents* client_web_content,
     std::string host_action_var) {
-  return ExecuteScriptAndExtractBool(
+  return RemoteTestHelper::ExecuteScriptAndExtractBool(
       client_web_content,
       host_action_var);
 }
 
 // static
 bool RemoteDesktopBrowserTest::IsEnabled(
     content::WebContents* client_web_content,
     const std::string& element_name) {
-  return !ExecuteScriptAndExtractBool(
+  return !RemoteTestHelper::ExecuteScriptAndExtractBool(
     client_web_content,
     "document.getElementById(\"" + element_name + "\").disabled");
 }
 
 }  // namespace remoting