Implement browser test for It2Me

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 148 matching lines @@
     extensions::Manifest::Type type = extension_->GetType();
     EXPECT_TRUE(type == extensions::Manifest::TYPE_PLATFORM_APP ||
                 type == extensions::Manifest::TYPE_LEGACY_PACKAGED_APP);
 
     EXPECT_TRUE(extension_->ShouldDisplayInAppLauncher());
   }
 
   ASSERT_EQ(installed, expected);
 }
 
-void RemoteDesktopBrowserTest::LaunchChromotingApp(bool defer_start) {
+void RemoteDesktopBrowserTest::LaunchChromotingApp(
+    bool defer_start,
+    WindowOpenDisposition window_open_disposition,
+    content::WebContents** app_web_contents) {
   ASSERT_TRUE(extension_);
+  ASSERT_EQ(*app_web_contents, nullptr);
 
   GURL chromoting_main = Chromoting_Main_URL();
   // We cannot simply wait for any page load because the first page
   // loaded could be the generated background page. We need to wait
   // till the chromoting main page is loaded.
   PageLoadNotificationObserver observer(chromoting_main);
   observer.set_ignore_url_parameters(true);
 
   // If the app should be started in deferred mode, ensure that a "source" URL
   // parameter; if not, ensure that no such parameter is present. The value of
   // the parameter is determined by the AppLaunchParams ("test", in this case).
   extensions::FeatureSwitch::ScopedOverride override_trace_app_source(
       extensions::FeatureSwitch::trace_app_source(),
       defer_start);
 
+  if (is_platform_app()) {
+    window_open_disposition = NEW_WINDOW;

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

Could we get rid of the disposition parameter if we made the It2Me test v2-only?
It's a shame to need a separate version of this method just so that we can pass
in a disposition for one test (especially when that disposition is overridden
for v2 anyway).

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

V2 test currently doesn't run reliably.  I prefer to keep the parameter now and
remove it when our v2 test becomes reliable

+  }
+
   OpenApplication(AppLaunchParams(browser()->profile(), extension_,
                                   is_platform_app()
                                       ? extensions::LAUNCH_CONTAINER_NONE
                                       : extensions::LAUNCH_CONTAINER_TAB,
-                                  is_platform_app() ? NEW_WINDOW : CURRENT_TAB,
+                                  window_open_disposition,
                                   extensions::SOURCE_TEST));
 
   observer.Wait();
 
 
   // The active WebContents instance should be the source of the LOAD_STOP
   // notification.
   content::NavigationController* controller =
       content::Source<content::NavigationController>(observer.source()).ptr();
 
   content::WebContents* web_contents = controller->GetWebContents();
+  ASSERT_TRUE(web_contents);
+
   if (web_contents != active_web_contents())
     web_contents_stack_.push_back(web_contents);
 
-  app_web_content_ = web_contents;
+  *app_web_contents = web_contents;
 
   if (is_platform_app()) {
     EXPECT_EQ(GetFirstAppWindowWebContents(), active_web_contents());
   } else {
     // For apps v1 only, the DOMOperationObserver is not ready at the LOAD_STOP
     // event. A half second wait is necessary for the subsequent javascript
     // injection to work.
     // TODO(weitaosu): Find out whether there is a more appropriate notification
     // to wait for so we can get rid of this wait.
     ASSERT_TRUE(TimeoutWaiter(base::TimeDelta::FromSeconds(5)).Wait());
   }
 
   EXPECT_EQ(Chromoting_Main_URL(), GetCurrentURL());
 }
 
+void RemoteDesktopBrowserTest::LaunchChromotingApp(
+    bool defer_start,
+    content::WebContents** app_web_contents) {
+  LaunchChromotingApp(defer_start, CURRENT_TAB, app_web_contents);
+}
+
+void RemoteDesktopBrowserTest::LaunchChromotingApp(bool defer_start) {
+  content::WebContents* app_web_contents = nullptr;
+  LaunchChromotingApp(defer_start, CURRENT_TAB, &app_web_contents);
+}
+
 void RemoteDesktopBrowserTest::StartChromotingApp() {
   ClickOnControl("browser-test-continue-init");
 };
 
 void RemoteDesktopBrowserTest::Authorize() {
   // The chromoting extension should be installed.
   ASSERT_TRUE(extension_);
 
   // The chromoting main page should be loaded in the current tab
   // and isAuthenticated() should be false (auth dialog visible).
@@ skipping 232 matching lines @@
     VerifyChromotingLoaded(false);
   }
 
   // TODO(chaitali): Remove this additional timeout after we figure out
   // why this is needed for the v1 app to work.
   // Without this timeout the test fail with a "CloseWebContents called for
   // tab not in our strip" error for the v1 app.
   ASSERT_TRUE(TimeoutWaiter(base::TimeDelta::FromSeconds(2)).Wait());
 }
 
-void RemoteDesktopBrowserTest::SetUpTestForMe2Me() {
+content::WebContents* RemoteDesktopBrowserTest::SetUpTest() {
+  content::WebContents* app_web_content = nullptr;
   VerifyInternetAccess();
   Install();
-  LaunchChromotingApp(false);
+  LaunchChromotingApp(false, &app_web_content);
   Auth();
-  LoadScript(app_web_content(), FILE_PATH_LITERAL("browser_test.js"));
+  LoadScript(app_web_content, FILE_PATH_LITERAL("browser_test.js"));
   ExpandMe2Me();
   // The call to EnsureRemoteConnectionEnabled() does a PIN reset.
   // This causes the test to fail because of a recent bug:
   // crbug.com/430676
   // TODO(anandc): Reactivate this call after above bug is fixed.
-  //EnsureRemoteConnectionEnabled();
+  //EnsureRemoteConnectionEnabled(app_web_content);
+  return app_web_content;
 }
 
 void RemoteDesktopBrowserTest::Auth() {
   // For this test, we must be given the user-name and password.
   ASSERT_TRUE(!username_.empty() && !password_.empty());
 
   Authorize();
   Authenticate();
   Approve();
 }
 
-void RemoteDesktopBrowserTest::EnsureRemoteConnectionEnabled() {
+void RemoteDesktopBrowserTest::EnsureRemoteConnectionEnabled(
+    content::WebContents* app_web_content) {
   // browser_test.ensureRemoteConnectionEnabled is defined in
   // browser_test.js, which must be loaded before calling this function.
   // TODO(kelvinp): This function currently only works on linux when the user is
   // already part of the chrome-remote-desktop group.  Extend this functionality
   // to Mac (https://crbug.com/397576) and Windows (https://crbug.com/397575).
   bool result;
   EXPECT_TRUE(content::ExecuteScriptAndExtractBool(
-      app_web_content(),
+      app_web_content,
       "browserTest.ensureRemoteConnectionEnabled(" + me2me_pin() + ")",
       &result));
   EXPECT_TRUE(result) << "Cannot start the host with Pin:" << me2me_pin();
 }
 
 void RemoteDesktopBrowserTest::ConnectToLocalHost(bool remember_pin) {
   // Wait for local-host to be ready.
   ConditionalTimeoutWaiter waiter(
         base::TimeDelta::FromSeconds(5),
         base::TimeDelta::FromMilliseconds(500),
@@ skipping 195 matching lines @@
   base::FilePath script_path = src_dir.Append(path);
 
   if (!base::ReadFileToString(script_path, &script)) {
     LOG(ERROR) << "Failed to load script " << script_path.value();
     return false;
   }
 
   return content::ExecuteScript(web_contents, script);
 }
 
-// static
 void RemoteDesktopBrowserTest::RunJavaScriptTest(
     content::WebContents* web_contents,
     const std::string& testName,
     const std::string& testData) {
   std::string result;
   std::string script = "browserTest.runTest(browserTest." + testName + ", " +
                        testData + ");";
 
   DVLOG(1) << "Executing " << script;
 
@@ skipping 164 matching lines @@
 // static
 bool RemoteDesktopBrowserTest::IsEnabled(
     content::WebContents* client_web_content,
     const std::string& element_name) {
   return !ExecuteScriptAndExtractBool(
     client_web_content,
     "document.getElementById(\"" + element_name + "\").disabled");
 }
 
 }  // namespace remoting