Rename apps::ShellWindow to apps::AppWindow

chrome/browser/apps/app_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 "apps/app_window.h"
+#include "apps/app_window_registry.h"
 #include "apps/launcher.h"
-#include "apps/shell_window.h"
-#include "apps/shell_window_registry.h"
 #include "apps/ui/native_app_window.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/prefs/pref_service.h"
 #include "base/stl_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/apps/app_browsertest_util.h"
@@ skipping 31 matching lines @@
 
 #if defined(OS_CHROMEOS)
 #include "base/memory/scoped_ptr.h"
 #include "chrome/browser/chromeos/login/mock_user_manager.h"
 #include "chrome/browser/chromeos/login/user_manager.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/fake_dbus_thread_manager.h"
 #include "chromeos/dbus/fake_power_manager_client.h"
 #endif
 
-using apps::ShellWindow;
-using apps::ShellWindowRegistry;
+using apps::AppWindow;
+using apps::AppWindowRegistry;
 using content::WebContents;
 using web_modal::WebContentsModalDialogManager;
 
 namespace extensions {
 
 namespace app_runtime = api::app_runtime;
 
 namespace {
 
 // Non-abstract RenderViewContextMenu class.
@@ skipping 118 matching lines @@
   return true;
 }
 #endif  // !defined(OS_CHROMEOS) && !defined(OS_WIN)
 
 #if !defined(OS_CHROMEOS)
 const char kTestFilePath[] = "platform_apps/launch_files/test.txt";
 #endif
 
 }  // namespace
 
-// Tests that CreateShellWindow doesn't crash if you close it straight away.
+// Tests that CreateAppWindow 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) {
+IN_PROC_BROWSER_TEST_F(PlatformAppBrowserTest, CreateAndCloseAppWindow) {
   const Extension* extension = LoadAndLaunchPlatformApp("minimal");
-  ShellWindow* window = CreateShellWindow(extension);
-  CloseShellWindow(window);
+  AppWindow* window = CreateAppWindow(extension);
+  CloseAppWindow(window);
 }
 
 // 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 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();
+  WebContents* web_contents = GetFirstAppWindowWebContents();
   ASSERT_TRUE(web_contents);
   content::ContextMenuParams params;
   scoped_ptr<PlatformAppContextMenu> menu;
   menu.reset(new PlatformAppContextMenu(web_contents->GetMainFrame(), 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));
 }
 
 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();
+  WebContents* web_contents = GetFirstAppWindowWebContents();
   ASSERT_TRUE(web_contents);
   content::ContextMenuParams params;
   scoped_ptr<PlatformAppContextMenu> menu;
   menu.reset(new PlatformAppContextMenu(web_contents->GetMainFrame(), 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));
 }
 
 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();
+  WebContents* web_contents = GetFirstAppWindowWebContents();
   ASSERT_TRUE(web_contents);
   content::ContextMenuParams params;
   scoped_ptr<PlatformAppContextMenu> menu;
   menu.reset(new PlatformAppContextMenu(web_contents->GetMainFrame(), 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));
 }
 
 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();
+  WebContents* web_contents = GetFirstAppWindowWebContents();
   ASSERT_TRUE(web_contents);
   content::ContextMenuParams params;
   params.is_editable = true;
   scoped_ptr<PlatformAppContextMenu> menu;
   menu.reset(new PlatformAppContextMenu(web_contents->GetMainFrame(), 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));
 }
 
 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();
+  WebContents* web_contents = GetFirstAppWindowWebContents();
   ASSERT_TRUE(web_contents);
   content::ContextMenuParams params;
   params.selection_text = base::ASCIIToUTF16("Hello World");
   scoped_ptr<PlatformAppContextMenu> menu;
   menu.reset(new PlatformAppContextMenu(web_contents->GetMainFrame(), 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));
 }
 
 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();
+  WebContents* web_contents = GetFirstAppWindowWebContents();
   ASSERT_TRUE(web_contents);
   content::ContextMenuParams params;
   params.page_url = GURL("http://foo.bar");
   scoped_ptr<PlatformAppContextMenu> menu;
   menu.reset(new PlatformAppContextMenu(web_contents->GetMainFrame(), params));
   menu->Init();
   ASSERT_TRUE(menu->HasCommandWithId(IDC_EXTENSIONS_CONTEXT_CUSTOM_FIRST));
 
   // Execute the menu item
   ExtensionTestMessageListener onclicked_listener("onClicked fired for id1",
@@ skipping 82 matching lines @@
 #define MAYBE_ExtensionWindowingApis ExtensionWindowingApis
 #endif
 
 IN_PROC_BROWSER_TEST_F(PlatformAppBrowserTest, MAYBE_ExtensionWindowingApis) {
   // 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());
+  // And no app windows.
+  ASSERT_EQ(0U, GetAppWindowCount());
 
   // Launch a platform app that shows a window.
   ExtensionTestMessageListener launched_listener("Launched", false);
   LoadAndLaunchPlatformApp("minimal");
   ASSERT_TRUE(launched_listener.WaitUntilSatisfied());
-  ASSERT_EQ(1U, GetShellWindowCount());
-  int shell_window_id = GetFirstShellWindow()->session_id().id();
+  ASSERT_EQ(1U, GetAppWindowCount());
+  int app_window_id = GetFirstAppWindow()->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));
+  ASSERT_FALSE(RunGetWindowFunctionForExtension(app_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.
+  // TODO(jeremya): add an extension function to get an app window by ID, and
+  // to get a list of all the app 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());
+  // There are two total app windows, but each app can only see its own.
+  ASSERT_EQ(2U, GetAppWindowCount());
   // TODO(jeremya): as above, this requires more extension functions.
 }
 
 // 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.
 // TODO(benwells/jeremya): tests need a way to specify a handler ID.
 IN_PROC_BROWSER_TEST_F(PlatformAppBrowserTest, LaunchWithFile) {
@@ skipping 207 matching lines @@
   ASSERT_EQ(2, browser()->tab_strip_model()->count());
 }
 
 IN_PROC_BROWSER_TEST_F(PlatformAppBrowserTest, MutationEventsDisabled) {
   ASSERT_TRUE(RunPlatformAppTest("platform_apps/mutation_events")) << message_;
 }
 
 // This appears to be unreliable on linux.
 // TODO(stevenjb): Investigate and enable
 #if defined(OS_LINUX) && !defined(USE_ASH)
-#define MAYBE_ShellWindowRestoreState DISABLED_ShellWindowRestoreState
+#define MAYBE_AppWindowRestoreState DISABLED_AppWindowRestoreState
 #else
-#define MAYBE_ShellWindowRestoreState ShellWindowRestoreState
+#define MAYBE_AppWindowRestoreState AppWindowRestoreState
 #endif
-IN_PROC_BROWSER_TEST_F(PlatformAppBrowserTest,
-                       MAYBE_ShellWindowRestoreState) {
+IN_PROC_BROWSER_TEST_F(PlatformAppBrowserTest, MAYBE_AppWindowRestoreState) {
   ASSERT_TRUE(RunPlatformAppTest("platform_apps/restore_state"));
 }
 
 IN_PROC_BROWSER_TEST_F(PlatformAppBrowserTest,
-                       ShellWindowAdjustBoundsToBeVisibleOnScreen) {
+                       AppWindowAdjustBoundsToBeVisibleOnScreen) {
   const Extension* extension = LoadAndLaunchPlatformApp("minimal");
-  ShellWindow* window = CreateShellWindow(extension);
+  AppWindow* window = CreateAppWindow(extension);
 
   // The screen bounds didn't change, the cached bounds didn't need to adjust.
   gfx::Rect cached_bounds(80, 100, 400, 400);
   gfx::Rect cached_screen_bounds(0, 0, 1600, 900);
   gfx::Rect current_screen_bounds(0, 0, 1600, 900);
   gfx::Size minimum_size(200, 200);
   gfx::Rect bounds;
-  CallAdjustBoundsToBeVisibleOnScreenForShellWindow(window,
-                                                    cached_bounds,
-                                                    cached_screen_bounds,
-                                                    current_screen_bounds,
-                                                    minimum_size,
-                                                    &bounds);
+  CallAdjustBoundsToBeVisibleOnScreenForAppWindow(window,
+                                                  cached_bounds,
+                                                  cached_screen_bounds,
+                                                  current_screen_bounds,
+                                                  minimum_size,
+                                                  &bounds);
   EXPECT_EQ(bounds, cached_bounds);
 
   // We have an empty screen bounds, the cached bounds didn't need to adjust.
   gfx::Rect empty_screen_bounds;
-  CallAdjustBoundsToBeVisibleOnScreenForShellWindow(window,
-                                                    cached_bounds,
-                                                    empty_screen_bounds,
-                                                    current_screen_bounds,
-                                                    minimum_size,
-                                                    &bounds);
+  CallAdjustBoundsToBeVisibleOnScreenForAppWindow(window,
+                                                  cached_bounds,
+                                                  empty_screen_bounds,
+                                                  current_screen_bounds,
+                                                  minimum_size,
+                                                  &bounds);
   EXPECT_EQ(bounds, cached_bounds);
 
   // Cached bounds is completely off the new screen bounds in horizontal
   // locations. Expect to reposition the bounds.
   gfx::Rect horizontal_out_of_screen_bounds(-800, 100, 400, 400);
-  CallAdjustBoundsToBeVisibleOnScreenForShellWindow(
+  CallAdjustBoundsToBeVisibleOnScreenForAppWindow(
       window,
       horizontal_out_of_screen_bounds,
       gfx::Rect(-1366, 0, 1600, 900),
       current_screen_bounds,
       minimum_size,
       &bounds);
   EXPECT_EQ(bounds, gfx::Rect(0, 100, 400, 400));
 
   // Cached bounds is completely off the new screen bounds in vertical
   // locations. Expect to reposition the bounds.
   gfx::Rect vertical_out_of_screen_bounds(10, 1000, 400, 400);
-  CallAdjustBoundsToBeVisibleOnScreenForShellWindow(
+  CallAdjustBoundsToBeVisibleOnScreenForAppWindow(
       window,
       vertical_out_of_screen_bounds,
       gfx::Rect(-1366, 0, 1600, 900),
       current_screen_bounds,
       minimum_size,
       &bounds);
   EXPECT_EQ(bounds, gfx::Rect(10, 500, 400, 400));
 
   // From a large screen resulotion to a small one. Expect it fit on screen.
   gfx::Rect big_cache_bounds(10, 10, 1000, 1000);
-  CallAdjustBoundsToBeVisibleOnScreenForShellWindow(
-      window,
-      big_cache_bounds,
-      gfx::Rect(0, 0, 1600, 1000),
-      gfx::Rect(0, 0, 800, 600),
-      minimum_size,
-      &bounds);
+  CallAdjustBoundsToBeVisibleOnScreenForAppWindow(window,
+                                                  big_cache_bounds,
+                                                  gfx::Rect(0, 0, 1600, 1000),
+                                                  gfx::Rect(0, 0, 800, 600),
+                                                  minimum_size,
+                                                  &bounds);
   EXPECT_EQ(bounds, gfx::Rect(0, 0, 800, 600));
 
   // Don't resize the bounds smaller than minimum size, when the minimum size is
   // larger than the screen.
-  CallAdjustBoundsToBeVisibleOnScreenForShellWindow(
-      window,
-      big_cache_bounds,
-      gfx::Rect(0, 0, 1600, 1000),
-      gfx::Rect(0, 0, 800, 600),
-      gfx::Size(900, 900),
-      &bounds);
+  CallAdjustBoundsToBeVisibleOnScreenForAppWindow(window,
+                                                  big_cache_bounds,
+                                                  gfx::Rect(0, 0, 1600, 1000),
+                                                  gfx::Rect(0, 0, 800, 600),
+                                                  gfx::Size(900, 900),
+                                                  &bounds);
   EXPECT_EQ(bounds, gfx::Rect(0, 0, 900, 900));
 }
 
 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.
+  // Runs a test inside a harness that opens DevTools on an app window.
   void RunTestWithDevTools(const char* name, int test_flags);
 };
 
 void PlatformAppDevToolsBrowserTest::RunTestWithDevTools(
     const char* name, int test_flags) {
   using content::DevToolsAgentHost;
   ExtensionTestMessageListener launched_listener("Launched", false);
   const Extension* extension = LoadAndLaunchPlatformApp(name);
   ASSERT_TRUE(extension);
   ASSERT_TRUE(launched_listener.WaitUntilSatisfied());
-  ShellWindow* window = GetFirstShellWindow();
+  AppWindow* window = GetFirstAppWindow();
   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.
+  // Ensure no DevTools open for the AppWindow, then open one.
   ASSERT_FALSE(DevToolsAgentHost::HasFor(rvh));
   DevToolsWindow::OpenDevToolsWindow(rvh);
   ASSERT_TRUE(DevToolsAgentHost::HasFor(rvh));
 
   if (test_flags & RELAUNCH) {
-    // Close the ShellWindow, and ensure it is gone.
-    CloseShellWindow(window);
-    ASSERT_FALSE(GetFirstShellWindow());
+    // Close the AppWindow, and ensure it is gone.
+    CloseAppWindow(window);
+    ASSERT_FALSE(GetFirstAppWindow());
 
-    // Relaunch the app and get a new ShellWindow.
+    // Relaunch the app and get a new AppWindow.
     content::WindowedNotificationObserver app_loaded_observer(
         content::NOTIFICATION_LOAD_COMPLETED_MAIN_FRAME,
         content::NotificationService::AllSources());
     OpenApplication(AppLaunchParams(
         browser()->profile(), extension, LAUNCH_CONTAINER_NONE, NEW_WINDOW));
     app_loaded_observer.Wait();
-    window = GetFirstShellWindow();
+    window = GetFirstAppWindow();
     ASSERT_TRUE(window);
 
     // DevTools should have reopened with the relaunch.
     rvh = window->web_contents()->GetRenderViewHost();
     ASSERT_TRUE(rvh);
     ASSERT_TRUE(DevToolsAgentHost::HasFor(rvh));
   }
 }
 
 }  // namespace
@@ skipping 32 matching lines @@
 // fixed.
 #define MAYBE_ConstrainedWindowRequest DISABLED_ConstrainedWindowRequest
 #endif
 
 IN_PROC_BROWSER_TEST_F(PlatformAppBrowserTest, MAYBE_ConstrainedWindowRequest) {
   PermissionsRequestFunction::SetIgnoreUserGestureForTests(true);
   const Extension* extension =
       LoadAndLaunchPlatformApp("optional_permission_request");
   ASSERT_TRUE(extension) << "Failed to load extension.";
 
-  WebContents* web_contents = GetFirstShellWindowWebContents();
+  WebContents* web_contents = GetFirstAppWindowWebContents();
   ASSERT_TRUE(web_contents);
 
-  // Verify that the shell window has a dialog attached.
+  // Verify that the app window has a dialog attached.
   WebContentsModalDialogManager* web_contents_modal_dialog_manager =
       WebContentsModalDialogManager::FromWebContents(web_contents);
   EXPECT_TRUE(web_contents_modal_dialog_manager->IsDialogActive());
 
   // Close the constrained window and wait for the reply to the permission
   // request.
   ExtensionTestMessageListener listener("PermissionRequestDone", false);
   WebContentsModalDialogManager::TestApi test_api(
       web_contents_modal_dialog_manager);
   test_api.CloseAllDialogs();
   ASSERT_TRUE(listener.WaitUntilSatisfied());
 }
 
 // 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");
   ASSERT_TRUE(extension);
   ASSERT_TRUE(launched_listener.WaitUntilSatisfied());
-  ASSERT_TRUE(GetFirstShellWindow());
+  ASSERT_TRUE(GetFirstAppWindow());
 
   // Now tell the app to reload itself
   ExtensionTestMessageListener launched_listener2("Launched", false);
   launched_listener.Reply("reload");
   ASSERT_TRUE(launched_listener2.WaitUntilSatisfied());
-  ASSERT_TRUE(GetFirstShellWindow());
+  ASSERT_TRUE(GetFirstAppWindow());
 }
 
 namespace {
 
 // Simple observer to check for NOTIFICATION_EXTENSION_INSTALLED events to
 // ensure installation does or does not occur in certain scenarios.
 class CheckExtensionInstalledObserver : public content::NotificationObserver {
  public:
   CheckExtensionInstalledObserver() : seen_(false) {
     registrar_.Add(this,
@@ skipping 16 matching lines @@
  private:
   bool seen_;
   content::NotificationRegistrar registrar_;
 };
 
 }  // namespace
 
 // Component App Test 1 of 3: ensure that the initial load of a component
 // extension utilizing a background page (e.g. a v2 platform app) has its
 // background page run and is launchable. Waits for the Launched response from
-// the script resource in the opened shell window.
+// the script resource in the opened app window.
 IN_PROC_BROWSER_TEST_F(PlatformAppBrowserTest,
                        PRE_PRE_ComponentAppBackgroundPage) {
   CheckExtensionInstalledObserver should_install;
 
   // Ensure that we wait until the background page is run (to register the
   // OnLaunched listener) before trying to open the application. This is similar
   // to LoadAndLaunchPlatformApp, but we want to load as a component extension.
   content::WindowedNotificationObserver app_loaded_observer(
       content::NOTIFICATION_LOAD_COMPLETED_MAIN_FRAME,
       content::NotificationService::AllSources());
@@ skipping 93 matching lines @@
 #else
 // This test depends on focus and so needs to be in interactive_ui_tests.
 // http://crbug.com/227041
 #define MAYBE_WebContentsHasFocus DISABLED_WebContentsHasFocus
 #endif
 IN_PROC_BROWSER_TEST_F(PlatformAppBrowserTest, MAYBE_WebContentsHasFocus) {
   ExtensionTestMessageListener launched_listener("Launched", true);
   LoadAndLaunchPlatformApp("minimal");
   ASSERT_TRUE(launched_listener.WaitUntilSatisfied());
 
-  EXPECT_EQ(1LU, GetShellWindowCount());
-  EXPECT_TRUE(GetFirstShellWindow()->web_contents()->
-      GetRenderWidgetHostView()->HasFocus());
+  EXPECT_EQ(1LU, GetAppWindowCount());
+  EXPECT_TRUE(GetFirstAppWindow()
+                  ->web_contents()
+                  ->GetRenderWidgetHostView()
+                  ->HasFocus());
 }
 
 // The next three tests will only run automatically with Chrome branded builds
 // because they require the PDF preview plug-in. To run these tests manually for
 // Chromium (non-Chrome branded) builds in a development environment:
 //
 //   1) Remove "MAYBE_" in the first line of each test definition
 //   2) Build Chromium browser_tests
 //   3) Make a copy of the PDF plug-in from a recent version of Chrome (Canary
 //      or a recent development build) to your Chromium build:
@@ skipping 27 matching lines @@
 #define MAYBE_ClosingWindowWhilePrintingShouldNotCrash \
     ClosingWindowWhilePrintingShouldNotCrash
 #endif
 
 // This test verifies that http://crbug.com/297179 is fixed.
 IN_PROC_BROWSER_TEST_F(PlatformAppBrowserTest,
                        MAYBE_ClosingWindowWhilePrintingShouldNotCrash) {
   ScopedPreviewTestingDelegate preview_delegate(false);
   ASSERT_TRUE(RunPlatformAppTest("platform_apps/print_api")) << message_;
   preview_delegate.WaitUntilPreviewIsReady();
-  GetFirstShellWindow()->GetBaseWindow()->Close();
+  GetFirstAppWindow()->GetBaseWindow()->Close();
 }
 
 // This test currently only passes on OS X (on other platforms the print preview
 // dialog's size is limited by the size of the window being printed).
 #if !defined(GOOGLE_CHROME_BUILD) || !defined(OS_MACOSX)
 #define MAYBE_PrintPreviewShouldNotBeTooSmall \
     DISABLED_PrintPreviewShouldNotBeTooSmall
 #else
 #define MAYBE_PrintPreviewShouldNotBeTooSmall \
     PrintPreviewShouldNotBeTooSmall
 #endif
 
 IN_PROC_BROWSER_TEST_F(PlatformAppBrowserTest,
                        MAYBE_PrintPreviewShouldNotBeTooSmall) {
   // Print preview dialogs with widths less than 410 pixels will have preview
   // areas that are too small, and ones with heights less than 191 pixels will
   // have vertical scrollers for their controls that are too small.
   gfx::Size minimum_dialog_size(410, 191);
   ScopedPreviewTestingDelegate preview_delegate(false);
   ASSERT_TRUE(RunPlatformAppTest("platform_apps/print_api")) << message_;
   preview_delegate.WaitUntilPreviewIsReady();
   EXPECT_GE(preview_delegate.dialog_size().width(),
             minimum_dialog_size.width());
   EXPECT_GE(preview_delegate.dialog_size().height(),
             minimum_dialog_size.height());
-  GetFirstShellWindow()->GetBaseWindow()->Close();
+  GetFirstAppWindow()->GetBaseWindow()->Close();
 }
 
 
 #if defined(OS_CHROMEOS)
 
 class PlatformAppIncognitoBrowserTest : public PlatformAppBrowserTest,
-                                        public ShellWindowRegistry::Observer {
+                                        public AppWindowRegistry::Observer {
  public:
   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
     // Tell chromeos to launch in Guest mode, aka incognito.
     command_line->AppendSwitch(switches::kIncognito);
     PlatformAppBrowserTest::SetUpCommandLine(command_line);
   }
   virtual void SetUp() OVERRIDE {
     // Make sure the file manager actually gets loaded.
     ComponentLoader::EnableBackgroundExtensionsForTesting();
     PlatformAppBrowserTest::SetUp();
   }
 
-  // ShellWindowRegistry::Observer implementation.
-  virtual void OnShellWindowAdded(ShellWindow* shell_window) OVERRIDE {
-    opener_app_ids_.insert(shell_window->extension()->id());
+  // AppWindowRegistry::Observer implementation.
+  virtual void OnAppWindowAdded(AppWindow* app_window) OVERRIDE {
+    opener_app_ids_.insert(app_window->extension()->id());
   }
-  virtual void OnShellWindowIconChanged(ShellWindow* shell_window) OVERRIDE {}
-  virtual void OnShellWindowRemoved(ShellWindow* shell_window) OVERRIDE {}
+  virtual void OnAppWindowIconChanged(AppWindow* app_window) OVERRIDE {}
+  virtual void OnAppWindowRemoved(AppWindow* app_window) OVERRIDE {}
 
  protected:
-  // A set of ids of apps we've seen open a shell window.
+  // A set of ids of apps we've seen open a app window.
   std::set<std::string> opener_app_ids_;
 };
 
 IN_PROC_BROWSER_TEST_F(PlatformAppIncognitoBrowserTest, IncognitoComponentApp) {
   // Get the file manager app.
   const Extension* file_manager = extension_service()->GetExtensionById(
       "hhaomjibdihmijegdhdafkllkbggdgoj", false);
   ASSERT_TRUE(file_manager != NULL);
   Profile* incognito_profile = profile()->GetOffTheRecordProfile();
   ASSERT_TRUE(incognito_profile != NULL);
 
   // Wait until the file manager has had a chance to register its listener
   // for the launch event.
   EventRouter* router = ExtensionSystem::Get(incognito_profile)->event_router();
   ASSERT_TRUE(router != NULL);
   while (!router->ExtensionHasEventListener(
       file_manager->id(), app_runtime::OnLaunched::kEventName)) {
     content::RunAllPendingInMessageLoop();
   }
 
-  // Listen for new shell windows so we see the file manager app launch itself.
-  ShellWindowRegistry* registry = ShellWindowRegistry::Get(incognito_profile);
+  // Listen for new app windows so we see the file manager app launch itself.
+  AppWindowRegistry* registry = AppWindowRegistry::Get(incognito_profile);
   ASSERT_TRUE(registry != NULL);
   registry->AddObserver(this);
 
   OpenApplication(AppLaunchParams(
       incognito_profile, file_manager, 0, chrome::HOST_DESKTOP_TYPE_NATIVE));
 
   while (!ContainsKey(opener_app_ids_, file_manager->id())) {
     content::RunAllPendingInMessageLoop();
   }
 }
@@ skipping 106 matching lines @@
 
     ExtensionApiTest::ResultCatcher result_catcher;
 
     ASSERT_TRUE(launched_listener.WaitUntilSatisfied());
 
     EXPECT_TRUE(result_catcher.GetNextResult());
   }
 }
 
 }  // namespace extensions