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

chrome/test/remoting/remote_desktop_browsertest.h

 // 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.
 
 #ifndef CHROME_TEST_REMOTING_REMOTE_DESKTOP_BROWSERTEST_H_
 #define CHROME_TEST_REMOTING_REMOTE_DESKTOP_BROWSERTEST_H_
 
 #include "base/debug/stack_trace.h"
 #include "chrome/browser/apps/app_browsertest_util.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/test/base/ui_test_utils.h"
+#include "chrome/test/remoting/remote_test_helper.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/test/browser_test_utils.h"
 #include "net/dns/mock_host_resolver.h"
 
 namespace {
 // Command line arguments specific to the chromoting browser tests.
 const char kOverrideUserDataDir[] = "override-user-data-dir";
 const char kNoCleanup[] = "no-cleanup";
 const char kNoInstall[] = "no-install";
 const char kWebAppCrx[] = "webapp-crx";
 const char kWebAppUnpacked[] = "webapp-unpacked";
 const char kUserName[] = "username";
 const char kUserPassword[] = "password";
 const char kAccountsFile[] = "accounts-file";
 const char kAccountType[] = "account-type";
 const char kMe2MePin[] = "me2me-pin";
 const char kRemoteHostName[] = "remote-host-name";
 const char kExtensionName[] = "extension-name";
 const char kHttpServer[] = "http-server";
 
-// ASSERT_TRUE can only be used in void returning functions. This version
-// should be used in non-void-returning functions.
-inline void _ASSERT_TRUE(bool condition) {
-  if (!condition) {
-    // ASSERT_TRUE only prints the first call frame in the error message.
-    // In our case, this is the _ASSERT_TRUE wrapper function, which is not
-    // useful.  To help with debugging, we will dump the full callstack.
-    LOG(ERROR) << "Assertion failed.";
-    LOG(ERROR) << base::debug::StackTrace().ToString();
-  }
-  ASSERT_TRUE(condition);
-  return;
-}
-
 }  // namespace
 
 using extensions::Extension;
 
 namespace remoting {
 
 class RemoteDesktopBrowserTest : public extensions::PlatformAppBrowserTest {
  public:
   RemoteDesktopBrowserTest();
   ~RemoteDesktopBrowserTest() override;
@@ skipping 157 matching lines @@
 
   // The client WebContents instance the test needs to interact with.
   content::WebContents* client_web_content() {
     return client_web_content_;
   }
 
   content::WebContents* app_web_content() {
     return app_web_content_;
   }
 
+  RemoteTestHelper* remote_test_helper() const {
+    return remote_test_helper_.get();
+  }
+
   // Whether to perform the cleanup tasks (uninstalling chromoting, etc).
   // This is useful for diagnostic purposes.
   bool NoCleanup() { return no_cleanup_; }
 
   // Whether to install the chromoting extension before running the test cases.
   // This is useful for diagnostic purposes.
   bool NoInstall() { return no_install_; }
 
   // Helper to construct the starting URL of the installed chromoting webapp.
   GURL Chromoting_Main_URL() {
@@ skipping 14 matching lines @@
   // Helper to execute a JavaScript code snippet in the active WebContents.
   void ExecuteScript(const std::string& script);
 
   // Helper to execute a JavaScript code snippet in the active WebContents
   // and wait for page load to complete.
   void ExecuteScriptAndWaitForAnyPageLoad(const std::string& script);
 
   // Helper to execute a JavaScript code snippet in the active WebContents
   // and extract the boolean result.
   bool ExecuteScriptAndExtractBool(const std::string& script) {
-    return ExecuteScriptAndExtractBool(active_web_contents(), script);
+    return RemoteTestHelper::ExecuteScriptAndExtractBool(
+        active_web_contents(), script);
   }
 
-  // Helper to execute a JavaScript code snippet and extract the boolean result.
-  static bool ExecuteScriptAndExtractBool(content::WebContents* web_contents,
-                                          const std::string& script);
-
   // Helper to execute a JavaScript code snippet in the active WebContents
   // and extract the int result.
   int ExecuteScriptAndExtractInt(const std::string& script) {
-    return ExecuteScriptAndExtractInt(active_web_contents(), script);
+    return RemoteTestHelper::ExecuteScriptAndExtractInt(
+        active_web_contents(), script);
   }
 
-  // Helper to execute a JavaScript code snippet and extract the int result.
-  static int ExecuteScriptAndExtractInt(content::WebContents* web_contents,
-                                        const std::string& script);
-
   // Helper to execute a JavaScript code snippet in the active WebContents
   // and extract the string result.
   std::string ExecuteScriptAndExtractString(const std::string& script) {
-    return ExecuteScriptAndExtractString(active_web_contents(), script);
+    return RemoteTestHelper::ExecuteScriptAndExtractString(
+        active_web_contents(), script);
   }
 
-  // Helper to execute a JavaScript code snippet and extract the string result.
-  static std::string ExecuteScriptAndExtractString(
-      content::WebContents* web_contents, const std::string& script);
-
   // Helper to load a JavaScript file from |path| and inject it to
   // current web_content.  The variable |path| is relative to the directory of
   // the |browsertest| executable.
   static bool LoadScript(content::WebContents* web_contents,
                          const base::FilePath::StringType& path);
 
   // Helper to execute a JavaScript browser test.  It creates an object using
   // the |browserTest.testName| ctor and calls |run| on the created object with
   // |testData|, which can be any arbitrary object literal. The script
   // browser_test.js must be loaded (using LoadScript) before calling this
@@ skipping 73 matching lines @@
   // push it onto the stack and that becomes the active instance.
   // And once we are done with the current WebContents instance
   // we pop it off the stack, returning to the previous instance.
   std::vector<content::WebContents*> web_contents_stack_;
 
   // WebContent of the client page that facilitates communication with
   // the HTTP server. This is how the remoting browser tests
   // will get acknowledgments of actions completed on the host.
   content::WebContents* client_web_content_;
 
+  // Helper class to assist in performing and verifying remote operations.
+  scoped_ptr<RemoteTestHelper> remote_test_helper_;
+
   // WebContent of the landing page in the chromoting app.
   content::WebContents* app_web_content_;
 
   bool no_cleanup_;
   bool no_install_;
   const Extension* extension_;
   base::FilePath webapp_crx_;
   base::FilePath webapp_unpacked_;
   std::string username_;
   std::string password_;
   std::string me2me_pin_;
   std::string remote_host_name_;
   std::string extension_name_;
   std::string http_server_;
 };
 
 }  // namespace remoting
 
 #endif  // CHROME_TEST_REMOTING_REMOTE_DESKTOP_BROWSERTEST_H_