// 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 "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 "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 kkPassword[] = "password"; 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) { ASSERT_TRUE(condition); return; } } // namespace using extensions::Extension; namespace remoting { class RemoteDesktopBrowserTest : public extensions::PlatformAppBrowserTest { public: RemoteDesktopBrowserTest(); virtual ~RemoteDesktopBrowserTest(); // InProcessBrowserTest Overrides virtual void SetUp() OVERRIDE; virtual void SetUpOnMainThread() OVERRIDE; protected: // InProcessBrowserTest Overrides virtual void SetUpInProcessBrowserTestFixture() OVERRIDE; // InProcessBrowserTest Overrides virtual void TearDownInProcessBrowserTestFixture() OVERRIDE; // The following helpers each perform a simple task. // Verify the test has access to the internet (specifically google.com) void VerifyInternetAccess(); // Open the client page for the browser test to get status of host actions void OpenClientBrowserPage(); // Install the chromoting extension from a crx file. void InstallChromotingAppCrx(); // Install the unpacked chromoting extension. void InstallChromotingAppUnpacked(); // Uninstall the chromoting extension. void UninstallChromotingApp(); // Test whether the chromoting extension is installed. void VerifyChromotingLoaded(bool expected); // Launch the chromoting app. void LaunchChromotingApp(); // Authorize: grant extended access permission to the user's computer. void Authorize(); // Authenticate: sign in to google using the credentials provided. void Authenticate(); // Approve: grant the chromoting app necessary permissions. void Approve(); // Click on "Get Started" in the Me2Me section and show the host list. void ExpandMe2Me(); // Disconnect the active Me2Me session. void DisconnectMe2Me(); // Simulate a key event. void SimulateKeyPressWithCode(ui::KeyboardCode keyCode, const char* code); void SimulateKeyPressWithCode(ui::KeyboardCode keyCode, const char* code, bool control, bool shift, bool alt, bool command); // Simulate typing a character void SimulateCharInput(char c); // Simulate typing a string void SimulateStringInput(const std::string& input); // Helper to simulate a left button mouse click. void SimulateMouseLeftClickAt(int x, int y); // Helper to simulate a mouse click. void SimulateMouseClickAt( int modifiers, blink::WebMouseEvent::Button button, int x, int y); // The following helpers each perform a composite task. // Install the chromoting extension void Install(); // Clean up after the test. void Cleanup(); // Perform all the auth steps: authorization, authenticattion, etc. // It starts from the chromoting main page unauthenticated and ends up back // on the chromoting main page authenticated and ready to go. void Auth(); // Connect to the local host through Me2Me. void ConnectToLocalHost(bool remember_pin); // Connect to a remote host through Me2Me. void ConnectToRemoteHost(const std::string& host_name, bool remember_pin); // Enter the pin number and connect. void EnterPin(const std::string& name, bool remember_pin); // Helper to get the pin number used for me2me authentication. std::string me2me_pin() { return me2me_pin_; } // Helper to get the name of the remote host to connect to. std::string remote_host_name() { return remote_host_name_; } // Helper to get the test controller URL. std::string http_server() { return http_server_; } // Change behavior of the default host resolver to allow DNS lookup // to proceed instead of being blocked by the test infrastructure. void EnableDNSLookupForThisTest( net::RuleBasedHostResolverProc* host_resolver); // We need to reset the DNS lookup when we finish, or the test will fail. void DisableDNSLookupForThisTest(); void ParseCommandLine(); // Accessor methods. // Helper to get the path to the crx file of the webapp to be tested. base::FilePath WebAppCrxPath() { return webapp_crx_; } // Helper to get the extension ID of the installed chromoting webapp. std::string ChromotingID() { return extension_->id(); } // Is this a appsv2 web app? bool is_platform_app() { return extension_->GetType() == extensions::Manifest::TYPE_PLATFORM_APP; } // Are we testing an unpacked extension? bool is_unpacked() { return !webapp_unpacked_.empty(); } // The "active" WebContents instance the test needs to interact with. content::WebContents* active_web_contents() { DCHECK(!web_contents_stack_.empty()); return web_contents_stack_.back(); } // The client WebContents instance the test needs to interact with. content::WebContents* client_web_content() { return client_web_content_; } // 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() { return GURL("chrome-extension://" + ChromotingID() + "/main.html"); } // Helper to retrieve the current URL in the active WebContents. GURL GetCurrentURL() { return active_web_contents()->GetURL(); } // Helpers to execute javascript code on a web page. // 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); } // 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); } // 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); } // 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 check whether an html element with the given name exists in // the active WebContents. bool HtmlElementExists(const std::string& name) { return ExecuteScriptAndExtractBool( "document.getElementById(\"" + name + "\") != null"); } // Helper to check whether a html element with the given name is visible in // the active WebContents. bool HtmlElementVisible(const std::string& name); // Click on the named HTML control in the active WebContents. void ClickOnControl(const std::string& name); // Wait for the me2me connection to be established. void WaitForConnection(); // Checking whether the localHost has been initialized. bool IsLocalHostReady(); // Callback used by EnterPin to check whether the pin form is visible // and to dismiss the host-needs-update dialog. bool IsPinFormVisible(); // Callback used by WaitForConnection to check whether the connection // has been established. bool IsSessionConnected(); // Callback used by Approve to check whether the chromoting app has // successfully authenticated with the Google services. bool IsAuthenticated() { return IsAuthenticatedInWindow(active_web_contents()); } // If the "Host version out-of-date" form is visible, dismiss it. void DismissHostVersionWarningIfVisible(); // Callback used by Approve to check whether the chromoting app has // successfully authenticated with the Google services. static bool IsAuthenticatedInWindow(content::WebContents* web_contents); // Callback used to check whether a host action is completed. // Used by browser tests while conditionally waiting for host actions. static bool IsHostActionComplete( content::WebContents* client_web_content, std::string host_action_var); private: // Fields // This test needs to make live DNS requests for access to // GAIA and sync server URLs under google.com. We use a scoped version // to override the default resolver while the test is active. scoped_ptr<net::ScopedDefaultHostResolverProc> mock_host_resolver_override_; // Stores all the WebContents instance in a stack so that we can easily // return to the previous instance. // The active WebContents instance is always stored at the top of the stack. // Initially the stack contains the WebContents instance created by // InProcessBrowserTest as the initial context to run test in. // Whenever a WebContents instance is spawned and needs attention we // 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_; 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_