Keep browser process alive while there are platform apps with background pages running.

chrome/browser/extensions/platform_app_browsertest.cc

 // Copyright (c) 2012 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 "base/bind.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/platform_thread.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/automation/automation_util.h"
 #include "chrome/browser/debugger/devtools_window.h"
 #include "chrome/browser/extensions/api/permissions/permissions_api.h"
 #include "chrome/browser/extensions/app_restore_service_factory.h"
 #include "chrome/browser/extensions/app_restore_service.h"
 #include "chrome/browser/extensions/extension_browsertest.h"
 #include "chrome/browser/extensions/extension_prefs.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/extension_test_message_listener.h"
 #include "chrome/browser/extensions/platform_app_browsertest_util.h"
 #include "chrome/browser/extensions/platform_app_launcher.h"
 #include "chrome/browser/extensions/shell_window_registry.h"
+#include "chrome/browser/lifetime/application_lifetime.h"
 #include "chrome/browser/tab_contents/render_view_context_menu.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
+#include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/constrained_window_tab_helper.h"
 #include "chrome/browser/ui/extensions/application_launch.h"
 #include "chrome/browser/ui/extensions/shell_window.h"
 #include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/browser/devtools_agent_host_registry.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/web_intents_dispatcher.h"
@@ skipping 102 matching lines @@
   size_t observations_;
   std::vector<content::WebContents*> observed_tabs_;
 
   DISALLOW_COPY_AND_ASSIGN(TabsAddedNotificationObserver);
 };
 
 const char kTestFilePath[] = "platform_apps/launch_files/test.txt";
 
 }  // namespace
 
+// TODO(benwells): Break up this file into some sensible smaller files.
+
 // Tests that CreateShellWindow doesn't crash if you close it straight away.
 // LauncherPlatformAppBrowserTest relies on this behaviour, but is only run for
 // ash, so we test that it works here.
 IN_PROC_BROWSER_TEST_F(PlatformAppBrowserTest, CreateAndCloseShellWindow) {
   const Extension* extension = LoadAndLaunchPlatformApp("minimal");
   ShellWindow* window = CreateShellWindow(extension);
   CloseShellWindow(window);
+  CloseShellWindowsAndWaitForAppToExit();
 }
 
 // Tests that platform apps can be launched in incognito mode without crashing.
 // Times out on ChromeOS: http://crbug.com/159392
 #if defined(OS_CHROMEOS)
 #define MAYBE_LaunchAppIncognito DISABLED_LaunchAppIncognito
 #else
 #define MAYBE_LaunchAppIncognito LaunchAppIncognito
 #endif
 IN_PROC_BROWSER_TEST_F(PlatformAppBrowserTest, MAYBE_LaunchAppIncognito) {
   Browser* browser_incognito = ui_test_utils::OpenURLOffTheRecord(
       browser()->profile(), GURL("about:blank"));
 
   ExtensionTestMessageListener launched_listener("Launched", false);
 
   const Extension* extension = LoadExtensionIncognito(
       test_data_dir_.AppendASCII("platform_apps").AppendASCII("minimal"));
   EXPECT_TRUE(extension);
 
   application_launch::OpenApplication(application_launch::LaunchParams(
           browser_incognito->profile(), extension, extension_misc::LAUNCH_NONE,
           NEW_WINDOW));
 
   ASSERT_TRUE(launched_listener.WaitUntilSatisfied());
+  CloseShellWindowsAndWaitForAppToExit();
+}
+
+// Tests that the browser process is kept alive by the platform app's background
+// page.
+IN_PROC_BROWSER_TEST_F(PlatformAppBrowserTest, AppEventPageKeepsBrowserAlive) {
+  LoadAndLaunchPlatformApp("minimal");
+  browser()->window()->Close();
+  ASSERT_TRUE(browser::WillKeepAlive());
+  CloseShellWindowsAndWaitForAppToExit();
 }
 
 // Tests that platform apps received the "launch" event when launched.
 IN_PROC_BROWSER_TEST_F(PlatformAppBrowserTest, OnLaunchedEvent) {
   ASSERT_TRUE(RunPlatformAppTest("platform_apps/launch")) << message_;
 }
 
 // Tests that platform apps can reply to "launch" events that contain a Web
 // Intent. This test does not test the mechanics of invoking a Web Intent
 // from a source page, and short-circuits to LaunchPlatformAppWithWebIntent.
@@ skipping 14 matching lines @@
   WebContents* web_contents = chrome::GetActiveWebContents(browser());
   ASSERT_TRUE(web_contents);
 
   extensions::LaunchPlatformAppWithWebIntent(
       browser()->profile(),
       extension,
       handler.intents_dispatcher(),
       web_contents);
 
   ASSERT_TRUE(handler.WaitUntilReply());
+  CloseShellWindowsAndWaitForAppToExit();
 }
 
 // Tests that platform apps cannot use certain disabled window properties, but
 // can override them and then use them.
 IN_PROC_BROWSER_TEST_F(PlatformAppBrowserTest, DisabledWindowProperties) {
   ASSERT_TRUE(RunPlatformAppTest("platform_apps/disabled_window_properties"))
       << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(PlatformAppBrowserTest, EmptyContextMenu) {
-  ExtensionTestMessageListener launched_listener("Launched", false);
   LoadAndLaunchPlatformApp("minimal");
 
-  ASSERT_TRUE(launched_listener.WaitUntilSatisfied());
-
   // The empty app doesn't add any context menu items, so its menu should
   // only include the developer tools.
   WebContents* web_contents = GetFirstShellWindowWebContents();
   ASSERT_TRUE(web_contents);
   WebKit::WebContextMenuData data;
   content::ContextMenuParams params(data);
   scoped_ptr<PlatformAppContextMenu> menu;
   menu.reset(new PlatformAppContextMenu(web_contents, params));
   menu->Init();
   ASSERT_TRUE(menu->HasCommandWithId(IDC_CONTENT_CONTEXT_INSPECTELEMENT));
   ASSERT_TRUE(
       menu->HasCommandWithId(IDC_CONTENT_CONTEXT_INSPECTBACKGROUNDPAGE));
   ASSERT_TRUE(menu->HasCommandWithId(IDC_CONTENT_CONTEXT_RELOAD_PACKAGED_APP));
   ASSERT_FALSE(menu->HasCommandWithId(IDC_BACK));
   ASSERT_FALSE(menu->HasCommandWithId(IDC_SAVE_PAGE));
+  CloseShellWindowsAndWaitForAppToExit();
 }
 
 IN_PROC_BROWSER_TEST_F(PlatformAppBrowserTest, AppWithContextMenu) {
-  ExtensionTestMessageListener launched_listener("Launched", false);
   LoadAndLaunchPlatformApp("context_menu");
 
-  // Wait for the extension to tell us it's initialized its context menus and
-  // launched a window.
-  ASSERT_TRUE(launched_listener.WaitUntilSatisfied());
-
   // The context_menu app has two context menu items. These, along with a
   // separator and the developer tools, is all that should be in the menu.
   WebContents* web_contents = GetFirstShellWindowWebContents();
   ASSERT_TRUE(web_contents);
   WebKit::WebContextMenuData data;
   content::ContextMenuParams params(data);
   scoped_ptr<PlatformAppContextMenu> menu;
   menu.reset(new PlatformAppContextMenu(web_contents, params));
   menu->Init();
   ASSERT_TRUE(menu->HasCommandWithId(IDC_EXTENSIONS_CONTEXT_CUSTOM_FIRST));
   ASSERT_TRUE(menu->HasCommandWithId(IDC_EXTENSIONS_CONTEXT_CUSTOM_FIRST + 1));
   ASSERT_TRUE(menu->HasCommandWithId(IDC_CONTENT_CONTEXT_INSPECTELEMENT));
   ASSERT_TRUE(
       menu->HasCommandWithId(IDC_CONTENT_CONTEXT_INSPECTBACKGROUNDPAGE));
   ASSERT_TRUE(menu->HasCommandWithId(IDC_CONTENT_CONTEXT_RELOAD_PACKAGED_APP));
   ASSERT_FALSE(menu->HasCommandWithId(IDC_BACK));
   ASSERT_FALSE(menu->HasCommandWithId(IDC_SAVE_PAGE));
   ASSERT_FALSE(menu->HasCommandWithId(IDC_CONTENT_CONTEXT_UNDO));
+  CloseShellWindowsAndWaitForAppToExit();
 }
 
 IN_PROC_BROWSER_TEST_F(PlatformAppBrowserTest, InstalledAppWithContextMenu) {
-  ExtensionTestMessageListener launched_listener("Launched", false);
   InstallAndLaunchPlatformApp("context_menu");
 
-  // Wait for the extension to tell us it's initialized its context menus and
-  // launched a window.
-  ASSERT_TRUE(launched_listener.WaitUntilSatisfied());
-
   // The context_menu app has two context menu items. For an installed app
   // these are all that should be in the menu.
   WebContents* web_contents = GetFirstShellWindowWebContents();
   ASSERT_TRUE(web_contents);
   WebKit::WebContextMenuData data;
   content::ContextMenuParams params(data);
   scoped_ptr<PlatformAppContextMenu> menu;
   menu.reset(new PlatformAppContextMenu(web_contents, params));
   menu->Init();
   ASSERT_TRUE(menu->HasCommandWithId(IDC_EXTENSIONS_CONTEXT_CUSTOM_FIRST));
   ASSERT_TRUE(menu->HasCommandWithId(IDC_EXTENSIONS_CONTEXT_CUSTOM_FIRST + 1));
   ASSERT_FALSE(menu->HasCommandWithId(IDC_CONTENT_CONTEXT_INSPECTELEMENT));
   ASSERT_FALSE(
       menu->HasCommandWithId(IDC_CONTENT_CONTEXT_INSPECTBACKGROUNDPAGE));
   ASSERT_FALSE(menu->HasCommandWithId(IDC_CONTENT_CONTEXT_RELOAD_PACKAGED_APP));
   ASSERT_FALSE(menu->HasCommandWithId(IDC_BACK));
   ASSERT_FALSE(menu->HasCommandWithId(IDC_SAVE_PAGE));
   ASSERT_FALSE(menu->HasCommandWithId(IDC_CONTENT_CONTEXT_UNDO));
+  CloseShellWindowsAndWaitForAppToExit();
 }
 
 IN_PROC_BROWSER_TEST_F(PlatformAppBrowserTest, AppWithContextMenuTextField) {
-  ExtensionTestMessageListener launched_listener("Launched", false);
   LoadAndLaunchPlatformApp("context_menu");
 
-  // Wait for the extension to tell us it's initialized its context menus and
-  // launched a window.
-  ASSERT_TRUE(launched_listener.WaitUntilSatisfied());
-
   // The context_menu app has one context menu item. This, along with a
   // separator and the developer tools, is all that should be in the menu.
   WebContents* web_contents = GetFirstShellWindowWebContents();
   ASSERT_TRUE(web_contents);
   WebKit::WebContextMenuData data;
   content::ContextMenuParams params(data);
   params.is_editable = true;
   scoped_ptr<PlatformAppContextMenu> menu;
   menu.reset(new PlatformAppContextMenu(web_contents, params));
   menu->Init();
   ASSERT_TRUE(menu->HasCommandWithId(IDC_EXTENSIONS_CONTEXT_CUSTOM_FIRST));
   ASSERT_TRUE(menu->HasCommandWithId(IDC_CONTENT_CONTEXT_INSPECTELEMENT));
   ASSERT_TRUE(
       menu->HasCommandWithId(IDC_CONTENT_CONTEXT_INSPECTBACKGROUNDPAGE));
   ASSERT_TRUE(menu->HasCommandWithId(IDC_CONTENT_CONTEXT_RELOAD_PACKAGED_APP));
   ASSERT_TRUE(menu->HasCommandWithId(IDC_CONTENT_CONTEXT_UNDO));
   ASSERT_TRUE(menu->HasCommandWithId(IDC_CONTENT_CONTEXT_COPY));
   ASSERT_FALSE(menu->HasCommandWithId(IDC_BACK));
   ASSERT_FALSE(menu->HasCommandWithId(IDC_SAVE_PAGE));
+  CloseShellWindowsAndWaitForAppToExit();
 }
 
 IN_PROC_BROWSER_TEST_F(PlatformAppBrowserTest, AppWithContextMenuSelection) {
-  ExtensionTestMessageListener launched_listener("Launched", false);
   LoadAndLaunchPlatformApp("context_menu");
 
-  // Wait for the extension to tell us it's initialized its context menus and
-  // launched a window.
-  ASSERT_TRUE(launched_listener.WaitUntilSatisfied());
-
   // The context_menu app has one context menu item. This, along with a
   // separator and the developer tools, is all that should be in the menu.
   WebContents* web_contents = GetFirstShellWindowWebContents();
   ASSERT_TRUE(web_contents);
   WebKit::WebContextMenuData data;
   content::ContextMenuParams params(data);
   params.selection_text = ASCIIToUTF16("Hello World");
   scoped_ptr<PlatformAppContextMenu> menu;
   menu.reset(new PlatformAppContextMenu(web_contents, params));
   menu->Init();
   ASSERT_TRUE(menu->HasCommandWithId(IDC_EXTENSIONS_CONTEXT_CUSTOM_FIRST));
   ASSERT_TRUE(menu->HasCommandWithId(IDC_CONTENT_CONTEXT_INSPECTELEMENT));
   ASSERT_TRUE(
       menu->HasCommandWithId(IDC_CONTENT_CONTEXT_INSPECTBACKGROUNDPAGE));
   ASSERT_TRUE(menu->HasCommandWithId(IDC_CONTENT_CONTEXT_RELOAD_PACKAGED_APP));
   ASSERT_FALSE(menu->HasCommandWithId(IDC_CONTENT_CONTEXT_UNDO));
   ASSERT_TRUE(menu->HasCommandWithId(IDC_CONTENT_CONTEXT_COPY));
   ASSERT_FALSE(menu->HasCommandWithId(IDC_BACK));
   ASSERT_FALSE(menu->HasCommandWithId(IDC_SAVE_PAGE));
+  CloseShellWindowsAndWaitForAppToExit();
 }
 
 IN_PROC_BROWSER_TEST_F(PlatformAppBrowserTest, AppWithContextMenuClicked) {
-  ExtensionTestMessageListener launched_listener("Launched", false);
   LoadAndLaunchPlatformApp("context_menu_click");
 
-  // Wait for the extension to tell us it's initialized its context menus and
-  // launched a window.
-  ASSERT_TRUE(launched_listener.WaitUntilSatisfied());
-
   // Test that the menu item shows up
   WebContents* web_contents = GetFirstShellWindowWebContents();
   ASSERT_TRUE(web_contents);
   WebKit::WebContextMenuData data;
   content::ContextMenuParams params(data);
   params.page_url = GURL("http://foo.bar");
   scoped_ptr<PlatformAppContextMenu> menu;
   menu.reset(new PlatformAppContextMenu(web_contents, params));
   menu->Init();
   ASSERT_TRUE(menu->HasCommandWithId(IDC_EXTENSIONS_CONTEXT_CUSTOM_FIRST));
 
   // Execute the menu item
   ExtensionTestMessageListener onclicked_listener("onClicked fired for id1",
                                                   false);
   menu->ExecuteCommand(IDC_EXTENSIONS_CONTEXT_CUSTOM_FIRST);
 
   ASSERT_TRUE(onclicked_listener.WaitUntilSatisfied());
+  CloseShellWindowsAndWaitForAppToExit();
 }
 
 IN_PROC_BROWSER_TEST_F(PlatformAppBrowserTest, DisallowNavigation) {
   TabsAddedNotificationObserver observer(2);
 
   ASSERT_TRUE(StartTestServer());
-  ASSERT_TRUE(RunPlatformAppTest("platform_apps/navigation")) << message_;
+  ASSERT_TRUE(RunPlatformAppTestReturnImmediately("platform_apps/navigation"))
+      << message_;
 
   observer.Wait();
   ASSERT_EQ(2U, observer.tabs().size());
   EXPECT_EQ(std::string(chrome::kExtensionInvalidRequestURL),
             observer.tabs()[0]->GetURL().spec());
   EXPECT_EQ("http://chromium.org/",
             observer.tabs()[1]->GetURL().spec());
+  browser()->window()->Close();
+  CloseShellWindowsAndWaitForAppToExit();
 }
 
 IN_PROC_BROWSER_TEST_F(PlatformAppBrowserTest, Iframes) {
   ASSERT_TRUE(StartTestServer());
   ASSERT_TRUE(RunPlatformAppTest("platform_apps/iframes")) << message_;
 }
 
 // Tests that localStorage and WebSQL are disabled for platform apps.
 IN_PROC_BROWSER_TEST_F(PlatformAppBrowserTest, DisallowStorage) {
   ASSERT_TRUE(RunPlatformAppTest("platform_apps/storage")) << message_;
@@ skipping 49 matching lines @@
   // Initially there should be just the one browser window visible to the
   // extensions API.
   const Extension* extension = LoadExtension(
       test_data_dir_.AppendASCII("common/background_page"));
   ASSERT_EQ(1U, RunGetWindowsFunctionForExtension(extension));
 
   // And no shell windows.
   ASSERT_EQ(0U, GetShellWindowCount());
 
   // Launch a platform app that shows a window.
-  ExtensionTestMessageListener launched_listener("Launched", false);
   LoadAndLaunchPlatformApp("minimal");
-  ASSERT_TRUE(launched_listener.WaitUntilSatisfied());
   ASSERT_EQ(1U, GetShellWindowCount());
   ShellWindowRegistry::ShellWindowSet shell_windows =
       ShellWindowRegistry::Get(browser()->profile())->shell_windows();
   int shell_window_id = (*shell_windows.begin())->session_id().id();
 
   // But it's not visible to the extensions API, it still thinks there's just
   // one browser window.
   ASSERT_EQ(1U, RunGetWindowsFunctionForExtension(extension));
   // It can't look it up by ID either
   ASSERT_FALSE(RunGetWindowFunctionForExtension(shell_window_id, extension));
 
   // The app can also only see one window (its own).
   // TODO(jeremya): add an extension function to get a shell window by ID, and
   // to get a list of all the shell windows, so we can test this.
 
   // Launch another platform app that also shows a window.
-  ExtensionTestMessageListener launched_listener2("Launched", false);
   LoadAndLaunchPlatformApp("context_menu");
-  ASSERT_TRUE(launched_listener2.WaitUntilSatisfied());
 
   // There are two total shell windows, but each app can only see its own.
   ASSERT_EQ(2U, GetShellWindowCount());
   // TODO(jeremya): as above, this requires more extension functions.
+  CloseShellWindowsAndWaitForAppToExit();
 }
 
 // ChromeOS does not support passing arguments on the command line, so the tests
 // that rely on this functionality are disabled.
 #if !defined(OS_CHROMEOS)
 // Tests that command line parameters get passed through to platform apps
 // via launchData correctly when launching with a file.
 IN_PROC_BROWSER_TEST_F(PlatformAppBrowserTest, LaunchWithFile) {
   SetCommandLineArg(kTestFilePath);
   ASSERT_TRUE(RunPlatformAppTest("platform_apps/launch_file"))
@@ skipping 23 matching lines @@
                                           extension_misc::LAUNCH_NONE,
                                           NEW_WINDOW);
   params.command_line = CommandLine::ForCurrentProcess();
   params.current_directory = test_data_dir_;
   application_launch::OpenApplication(params);
 
   if (!catcher.GetNextResult()) {
     message_ = catcher.message();
     ASSERT_TRUE(0);
   }
+  CloseShellWindowsAndWaitForAppToExit();
 }
 
 // Tests that no launch data is sent through if the file is of the wrong MIME
 // type.
 IN_PROC_BROWSER_TEST_F(PlatformAppBrowserTest, LaunchWithWrongType) {
   SetCommandLineArg(kTestFilePath);
   ASSERT_TRUE(RunPlatformAppTest("platform_apps/launch_wrong_type"))
       << message_;
 }
 
@@ skipping 46 matching lines @@
 #endif  // defined(OS_CHROMEOS)
 
 IN_PROC_BROWSER_TEST_F(PlatformAppBrowserTest, OpenLink) {
   ASSERT_TRUE(StartTestServer());
   content::WindowedNotificationObserver observer(
       chrome::NOTIFICATION_TAB_ADDED,
       content::Source<content::WebContentsDelegate>(browser()));
   LoadAndLaunchPlatformApp("open_link");
   observer.Wait();
   ASSERT_EQ(2, browser()->tab_count());
+  browser()->window()->Close();
+  CloseShellWindowsAndWaitForAppToExit();
 }
 
 IN_PROC_BROWSER_TEST_F(PlatformAppBrowserTest, MutationEventsDisabled) {
   ASSERT_TRUE(RunPlatformAppTest("platform_apps/mutation_events")) << message_;
 }
 
 // Test that windows created with an id will remember and restore their
 // geometry when opening new windows.
 // Originally disabled due to flakiness (see http://crbug.com/155459)
 // but now because a regression breaks the test (http://crbug.com/160343).
@@ skipping 56 matching lines @@
   // Wait for javascript to verify that the second window got the updated
   // coordinates, ignoring the default coordinates passed to the create method.
   ASSERT_TRUE(done2_listener.WaitUntilSatisfied());
 
   // Tell javascript to open a third window.
   page3_listener.Reply("continue");
 
   // Wait for javascript to verify that the third window got the restored size
   // and explicitly specified coordinates.
   ASSERT_TRUE(done3_listener.WaitUntilSatisfied());
+  CloseShellWindowsAndWaitForAppToExit();
 }
 
 // Tests that a running app is recorded in the preferences as such.
 IN_PROC_BROWSER_TEST_F(PlatformAppBrowserTest, RunningAppsAreRecorded) {
   content::WindowedNotificationObserver extension_suspended(
       chrome::NOTIFICATION_EXTENSION_HOST_DESTROYED,
       content::NotificationService::AllSources());
 
   const Extension* extension = LoadExtension(
       test_data_dir_.AppendASCII("platform_apps/restart_test"));
@@ skipping 11 matching lines @@
   // App isn't running because it got suspended.
   ASSERT_FALSE(extension_prefs->IsExtensionRunning(extension->id()));
 
   // Pretend that the app is supposed to be running.
   extension_prefs->SetExtensionRunning(extension->id(), true);
 
   ExtensionTestMessageListener restart_listener("onRestarted", false);
   AppRestoreServiceFactory::GetForProfile(browser()->profile())->
       HandleStartup(true);
   restart_listener.WaitUntilSatisfied();
+  CloseShellWindowsAndWaitForAppToExit();
 }
 
 namespace {
 
 class PlatformAppDevToolsBrowserTest : public PlatformAppBrowserTest {
  protected:
   enum TestFlags {
     RELAUNCH = 0x1,
     HAS_ID = 0x2,
   };
   // Runs a test inside a harness that opens DevTools on a shell window.
   void RunTestWithDevTools(const char* name, int test_flags);
 };
 
 void PlatformAppDevToolsBrowserTest::RunTestWithDevTools(
     const char* name, int test_flags) {
   using content::DevToolsAgentHostRegistry;
-  ExtensionTestMessageListener launched_listener("Launched", false);
   const Extension* extension = LoadAndLaunchPlatformApp(name);
   ASSERT_TRUE(extension);
-  ASSERT_TRUE(launched_listener.WaitUntilSatisfied());
   ShellWindow* window = GetFirstShellWindow();
   ASSERT_TRUE(window);
   ASSERT_EQ(window->window_key().empty(), (test_flags & HAS_ID) == 0);
   content::RenderViewHost* rvh = window->web_contents()->GetRenderViewHost();
   ASSERT_TRUE(rvh);
 
   // Ensure no DevTools open for the ShellWindow, then open one.
   ASSERT_FALSE(DevToolsAgentHostRegistry::HasDevToolsAgentHost(rvh));
   DevToolsWindow* devtools_window = DevToolsWindow::OpenDevToolsWindow(rvh);
   content::WindowedNotificationObserver loaded_observer(
@@ skipping 17 matching lines @@
         NEW_WINDOW));
     app_loaded_observer.Wait();
     window = GetFirstShellWindow();
     ASSERT_TRUE(window);
 
     // DevTools should have reopened with the relaunch.
     rvh = window->web_contents()->GetRenderViewHost();
     ASSERT_TRUE(rvh);
     ASSERT_TRUE(DevToolsAgentHostRegistry::HasDevToolsAgentHost(rvh));
   }
+  CloseShellWindowsAndWaitForAppToExit();
 }
 
 }  // namespace
 
 IN_PROC_BROWSER_TEST_F(PlatformAppDevToolsBrowserTest, ReOpenedWithID) {
   RunTestWithDevTools("minimal_id", RELAUNCH | HAS_ID);
 }
 
 IN_PROC_BROWSER_TEST_F(PlatformAppDevToolsBrowserTest, ReOpenedWithURL) {
   RunTestWithDevTools("minimal", RELAUNCH);
@@ skipping 21 matching lines @@
   // Verify that the shell window has a constrained window attached.
   ConstrainedWindowTabHelper* constrained_window_tab_helper =
       ConstrainedWindowTabHelper::FromWebContents(web_contents);
   EXPECT_EQ(1u, constrained_window_tab_helper->constrained_window_count());
 
   // Close the constrained window and wait for the reply to the permission
   // request.
   ExtensionTestMessageListener listener("PermissionRequestDone", false);
   constrained_window_tab_helper->CloseConstrainedWindows();
   ASSERT_TRUE(listener.WaitUntilSatisfied());
+
+  CloseShellWindowsAndWaitForAppToExit();
 }
 
 // Tests that an app calling chrome.runtime.reload will reload the app and
 // relaunch it if it was running.
 IN_PROC_BROWSER_TEST_F(PlatformAppBrowserTest, ReloadRelaunches) {
   ExtensionTestMessageListener launched_listener("Launched", true);
-  const Extension* extension = LoadAndLaunchPlatformApp("reload");
+  const Extension* extension = LoadPlatformApp("reload");
   ASSERT_TRUE(extension);
+  application_launch::OpenApplication(application_launch::LaunchParams(
+      browser()->profile(), extension, extension_misc::LAUNCH_NONE,
+      NEW_WINDOW));
   ASSERT_TRUE(launched_listener.WaitUntilSatisfied());
   ASSERT_TRUE(GetFirstShellWindow());
 
   // Now tell the app to reload itself
   ExtensionTestMessageListener launched_listener2("Launched", false);
   launched_listener.Reply("reload");
   ASSERT_TRUE(launched_listener2.WaitUntilSatisfied());
   ASSERT_TRUE(GetFirstShellWindow());
+  CloseShellWindowsAndWaitForAppToExit();
 }
 
 }  // namespace extensions