Implement browser test for It2Me

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"
@@ skipping 73 matching lines @@
   void UninstallChromotingApp();
 
   // Test whether the chromoting extension is installed.
   void VerifyChromotingLoaded(bool expected);
 
   // Launch the Chromoting app. If |defer_start| is true, an additional URL
   // parameter is passed to the application, causing it to defer start-up
   // until StartChromotingApp is invoked. Test code can execute arbitrary
   // JavaScript in the context of the app between these two calls, for example
   // to set up appropriate mocks.
+  // |window_open_disposition| controls where the app will be launched.  For v2
+  // app, the value of |window_open_disposition| will always be NEW_WINDOW.
+  // Returns |app_web_content| that allow the caller to interact with the
+  // content::WebContents of the launched app. The lifetime of |app_web_content|
+  // is managed by LaunchChromotingApp().
   void LaunchChromotingApp(bool defer_start);
+  void LaunchChromotingApp(bool defer_start,
+                           content::WebContents** app_web_content);

[Jamie, 2015/01/10 00:14:24]

Why not just return the WebContents pointer? It would save you defining a
separate version that doesn't take the additional OUT parameter.

[kelvinp, 2015/01/12 21:15:24]

LaunchChromotingApp uses the ASSERT_MACRO which uses the return statement to do
early returns.  As a result, the calling function must return void.

+  void LaunchChromotingApp(bool defer_start,
+                           WindowOpenDisposition window_open_disposition,
+                           content::WebContents** app_web_content);
 
   // If the Chromoting app was launched in deferred mode, tell it to continue
   // its regular start-up sequence.
   void StartChromotingApp();
 
   // Authorize: grant extended access permission to the user's computer.
   void Authorize();
 
   // Authenticate: sign in to google using the credentials provided.
   void Authenticate();
@@ skipping 32 matching lines @@
 
   void SetUserNameAndPassword(
       const base::FilePath &accounts_file, const std::string& account_type);
 
   // The following helpers each perform a composite task.
 
   // Install the chromoting extension
   void Install();
 
   // Perform all necessary steps (installation, authorization, authentication,
-  // expanding the me2me section) so that the app is ready for a me2me
-  // connection.
-  void SetUpTestForMe2Me();
+  // expanding the me2me section) so that the app is ready for a connection.
+  // Returns the content::WebContents instance of the Chromoting app.
+  content::WebContents* SetUpTest();
 
   // Clean up after the test.
   void Cleanup();
 
   // Perform all the auth steps: authorization, authentication, 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();
 
   // Ensures that the host is started locally with |me2me_pin()|.
   // Browser_test.js must be loaded before calling this function.
-  void EnsureRemoteConnectionEnabled();
+  void EnsureRemoteConnectionEnabled(content::WebContents* app_web_content);
 
   // 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);
 
@@ skipping 38 matching lines @@
   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_;
   }
 
-  content::WebContents* app_web_content() {
-    return app_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() {
@@ skipping 134 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_;
 
-  // 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_