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 151 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) {
-  ASSERT_TRUE(extension_);
+content::WebContents* RemoteDesktopBrowserTest::LaunchChromotingApp(
+    bool defer_start,
+    WindowOpenDisposition window_open_disposition) {
+  _ASSERT_TRUE(extension_);
 
   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;
+  }
+
   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;
-
   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());
+    _ASSERT_TRUE(TimeoutWaiter(base::TimeDelta::FromSeconds(5)).Wait());
   }
 
   EXPECT_EQ(Chromoting_Main_URL(), GetCurrentURL());
+  return web_contents;
+}
+
+content::WebContents* RemoteDesktopBrowserTest::LaunchChromotingApp(
+    bool defer_start) {
+  return LaunchChromotingApp(defer_start, CURRENT_TAB);
 }
 
 void RemoteDesktopBrowserTest::StartChromotingApp() {
   ClickOnControl("browser-test-continue-init");
 };
 
 void RemoteDesktopBrowserTest::Authorize() {
   // The chromoting extension should be installed.
   ASSERT_TRUE(extension_);
 
@@ skipping 246 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() {
   VerifyInternetAccess();
   Install();
-  LaunchChromotingApp(false);
-  LoadBrowserTestJavaScript(app_web_content());
+  content::WebContents* app_web_content = LaunchChromotingApp(false);
   Auth();
+  LoadBrowserTestJavaScript(app_web_content);
   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_contents) {
   // 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_contents,
       "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 344 matching lines @@
 // static
 bool RemoteDesktopBrowserTest::IsEnabled(
     content::WebContents* client_web_content,
     const std::string& element_name) {
   return !RemoteTestHelper::ExecuteScriptAndExtractBool(
     client_web_content,
     "document.getElementById(\"" + element_name + "\").disabled");
 }
 
 }  // namespace remoting