Add support for deferring app initialization when testing.

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() {
+void RemoteDesktopBrowserTest::LaunchChromotingApp(bool defer_start) {
   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);
+
+  extensions::FeatureSwitch::ScopedOverride enable_trace_app_source(
+      extensions::FeatureSwitch::trace_app_source(),
+      true);
+
+  // Lacking any other convenient mechanism for passing a URL parameter to the
+  // web-app, we use the |source| field. Since there's no way to launch the
+  // app from the About page, this should never be encountered by real users,
+  // even if they have the trace_app_source command-line option enabled.

[Jamie, 2014/12/02 01:30:13]

cylee@: What I would like to do here is add a BROWSER_TEST member to the
AppLaunchSource enum, but the comment about its inclusion in UMA stats makes me
suspect that I don't fully understand the ramifications of doing so. Would you
be supportive of a separate CL to add that so that I can use it in this one? If
not, then I think this is safe, but it's a bit of a hack.

[cylee1, 2014/12/02 14:10:32]

Adding a new enum BROWSER_TEST sounds much reasonable than using
SOURCE_ABOUT_PAGE to me.
It would be recorded in ChromeOS UMA system but I guess it's fine.

Note that you'll need to modify 
extensions/common/api/app_runtime.idl
tools/metrics/histograms/histograms.xml
extensions/common/constants.h
and 
extensions/browser/api/app_runtime/app_runtime_api.cc
for the enum mapping.

+  extensions::AppLaunchSource source =
+      defer_start ? extensions::SOURCE_ABOUT_PAGE
+                  : extensions::SOURCE_UNTRACKED;
 
   OpenApplication(AppLaunchParams(browser()->profile(), extension_,
                                   is_platform_app()
                                       ? extensions::LAUNCH_CONTAINER_NONE
                                       : extensions::LAUNCH_CONTAINER_TAB,
                                   is_platform_app() ? NEW_WINDOW : CURRENT_TAB,
-                                  extensions::SOURCE_UNTRACKED));
+                                  source));
 
   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();
   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());
   }
 
   EXPECT_EQ(Chromoting_Main_URL(), GetCurrentURL());
 }
 
+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).
   ASSERT_EQ(Chromoting_Main_URL(), GetCurrentURL());
   ASSERT_FALSE(IsAuthenticated());
 
   // The second observer monitors the loading of the Google login page.
@@ skipping 235 matching lines @@
   // 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() {
   VerifyInternetAccess();
   Install();
-  LaunchChromotingApp();
+  LaunchChromotingApp(false);
   Auth();
   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();
 }
 
@@ skipping 408 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