Rename apps::ShellWindow to apps::AppWindow

chrome/browser/ui/ash/launcher/chrome_launcher_controller_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/browser/ui/ash/launcher/chrome_launcher_controller.h"
 
-#include "apps/shell_window.h"
-#include "apps/shell_window_registry.h"
+#include "apps/app_window.h"
+#include "apps/app_window_registry.h"
 #include "apps/ui/native_app_window.h"
 #include "ash/ash_switches.h"
 #include "ash/display/display_controller.h"
 #include "ash/shelf/shelf.h"
 #include "ash/shelf/shelf_button.h"
 #include "ash/shelf/shelf_model.h"
 #include "ash/shelf/shelf_util.h"
 #include "ash/shelf/shelf_view.h"
 #include "ash/shell.h"
 #include "ash/test/app_list_controller_test_api.h"
@@ skipping 34 matching lines @@
 #include "extensions/browser/extension_system.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/switches.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/app_list/views/apps_grid_view.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/test/event_generator.h"
 #include "ui/aura/window.h"
 #include "ui/events/event.h"
 
-using apps::ShellWindow;
+using apps::AppWindow;
 using extensions::Extension;
 using content::WebContents;
 
 namespace {
 
 class TestEvent : public ui::Event {
  public:
   explicit TestEvent(ui::EventType type)
       : ui::Event(type, base::TimeDelta(), 0) {
   }
   virtual ~TestEvent() {
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestEvent);
 };
 
-class TestShellWindowRegistryObserver
-    : public apps::ShellWindowRegistry::Observer {
+class TestAppWindowRegistryObserver : public apps::AppWindowRegistry::Observer {
  public:
-  explicit TestShellWindowRegistryObserver(Profile* profile)
-      : profile_(profile),
-        icon_updates_(0) {
-    apps::ShellWindowRegistry::Get(profile_)->AddObserver(this);
+  explicit TestAppWindowRegistryObserver(Profile* profile)
+      : profile_(profile), icon_updates_(0) {
+    apps::AppWindowRegistry::Get(profile_)->AddObserver(this);
   }
 
-  virtual ~TestShellWindowRegistryObserver() {
-    apps::ShellWindowRegistry::Get(profile_)->RemoveObserver(this);
+  virtual ~TestAppWindowRegistryObserver() {
+    apps::AppWindowRegistry::Get(profile_)->RemoveObserver(this);
   }
 
-  // Overridden from ShellWindowRegistry::Observer:
-  virtual void OnShellWindowAdded(ShellWindow* shell_window) OVERRIDE {}
+  // Overridden from AppWindowRegistry::Observer:
+  virtual void OnAppWindowAdded(AppWindow* app_window) OVERRIDE {}
 
-  virtual void OnShellWindowIconChanged(ShellWindow* shell_window) OVERRIDE {
+  virtual void OnAppWindowIconChanged(AppWindow* app_window) OVERRIDE {
     ++icon_updates_;
   }
 
-  virtual void OnShellWindowRemoved(ShellWindow* shell_window) OVERRIDE {}
+  virtual void OnAppWindowRemoved(AppWindow* app_window) OVERRIDE {}
 
   int icon_updates() { return icon_updates_; }
 
  private:
   Profile* profile_;
   int icon_updates_;
 
-  DISALLOW_COPY_AND_ASSIGN(TestShellWindowRegistryObserver);
+  DISALLOW_COPY_AND_ASSIGN(TestAppWindowRegistryObserver);
 };
 
 }  // namespace
 
 class LauncherPlatformAppBrowserTest
     : public extensions::PlatformAppBrowserTest {
  protected:
   LauncherPlatformAppBrowserTest() : shelf_(NULL), controller_(NULL) {
   }
 
@@ skipping 221 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(ShelfAppBrowserNoMinimizeOnClick);
 };
 
 typedef LauncherPlatformAppBrowserTest ShelfAppBrowserMinimizeOnClick;
 
 // Test that we can launch a platform app and get a running item.
 IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest, LaunchUnpinned) {
   int item_count = shelf_model()->item_count();
   const Extension* extension = LoadAndLaunchPlatformApp("launch");
-  ShellWindow* window = CreateShellWindow(extension);
+  AppWindow* window = CreateAppWindow(extension);
   ++item_count;
   ASSERT_EQ(item_count, shelf_model()->item_count());
   const ash::ShelfItem& item = GetLastLauncherItem();
   EXPECT_EQ(ash::TYPE_PLATFORM_APP, item.type);
   EXPECT_EQ(ash::STATUS_ACTIVE, item.status);
-  CloseShellWindow(window);
+  CloseAppWindow(window);
   --item_count;
   EXPECT_EQ(item_count, shelf_model()->item_count());
 }
 
 // Test that we can launch a platform app that already has a shortcut.
 IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest, LaunchPinned) {
   int item_count = shelf_model()->item_count();
 
   // First get app_id.
   const Extension* extension = LoadAndLaunchPlatformApp("launch");
   const std::string app_id = extension->id();
 
   // Then create a shortcut.
   ash::ShelfID shortcut_id = CreateAppShortcutLauncherItem(app_id);
   ++item_count;
   ASSERT_EQ(item_count, shelf_model()->item_count());
   ash::ShelfItem item = *shelf_model()->ItemByID(shortcut_id);
   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, item.type);
   EXPECT_EQ(ash::STATUS_CLOSED, item.status);
 
   // Open a window. Confirm the item is now running.
-  ShellWindow* window = CreateShellWindow(extension);
+  AppWindow* window = CreateAppWindow(extension);
   ash::wm::ActivateWindow(window->GetNativeWindow());
   ASSERT_EQ(item_count, shelf_model()->item_count());
   item = *shelf_model()->ItemByID(shortcut_id);
   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, item.type);
   EXPECT_EQ(ash::STATUS_ACTIVE, item.status);
 
   // Then close it, make sure there's still an item.
-  CloseShellWindow(window);
+  CloseAppWindow(window);
   ASSERT_EQ(item_count, shelf_model()->item_count());
   item = *shelf_model()->ItemByID(shortcut_id);
   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, item.type);
   EXPECT_EQ(ash::STATUS_CLOSED, item.status);
 }
 
 IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest, PinRunning) {
   // Run.
   int item_count = shelf_model()->item_count();
   const Extension* extension = LoadAndLaunchPlatformApp("launch");
-  ShellWindow* window = CreateShellWindow(extension);
+  AppWindow* window = CreateAppWindow(extension);
   ++item_count;
   ASSERT_EQ(item_count, shelf_model()->item_count());
   const ash::ShelfItem& item1 = GetLastLauncherItem();
   ash::ShelfID id = item1.id;
   EXPECT_EQ(ash::TYPE_PLATFORM_APP, item1.type);
   EXPECT_EQ(ash::STATUS_ACTIVE, item1.status);
 
   // Create a shortcut. The app item should be after it.
   ash::ShelfID foo_id = CreateAppShortcutLauncherItem("foo");
   ++item_count;
   ASSERT_EQ(item_count, shelf_model()->item_count());
   EXPECT_LT(shelf_model()->ItemIndexByID(foo_id),
             shelf_model()->ItemIndexByID(id));
 
   // Pin the app. The item should remain.
   controller_->Pin(id);
   ASSERT_EQ(item_count, shelf_model()->item_count());
   const ash::ShelfItem& item2 = *shelf_model()->ItemByID(id);
   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, item2.type);
   EXPECT_EQ(ash::STATUS_ACTIVE, item2.status);
 
   // New shortcuts should come after the item.
   ash::ShelfID bar_id = CreateAppShortcutLauncherItem("bar");
   ++item_count;
   ASSERT_EQ(item_count, shelf_model()->item_count());
   EXPECT_LT(shelf_model()->ItemIndexByID(id),
             shelf_model()->ItemIndexByID(bar_id));
 
   // Then close it, make sure the item remains.
-  CloseShellWindow(window);
+  CloseAppWindow(window);
   ASSERT_EQ(item_count, shelf_model()->item_count());
 }
 
 IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest, UnpinRunning) {
   int item_count = shelf_model()->item_count();
 
   // First get app_id.
   const Extension* extension = LoadAndLaunchPlatformApp("launch");
   const std::string app_id = extension->id();
 
   // Then create a shortcut.
   ash::ShelfID shortcut_id = CreateAppShortcutLauncherItem(app_id);
   ++item_count;
   ASSERT_EQ(item_count, shelf_model()->item_count());
   ash::ShelfItem item = *shelf_model()->ItemByID(shortcut_id);
   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, item.type);
   EXPECT_EQ(ash::STATUS_CLOSED, item.status);
 
   // Create a second shortcut. This will be needed to force the first one to
   // move once it gets unpinned.
   ash::ShelfID foo_id = CreateAppShortcutLauncherItem("foo");
   ++item_count;
   ASSERT_EQ(item_count, shelf_model()->item_count());
   EXPECT_LT(shelf_model()->ItemIndexByID(shortcut_id),
             shelf_model()->ItemIndexByID(foo_id));
 
   // Open a window. Confirm the item is now running.
-  ShellWindow* window = CreateShellWindow(extension);
+  AppWindow* window = CreateAppWindow(extension);
   ash::wm::ActivateWindow(window->GetNativeWindow());
   ASSERT_EQ(item_count, shelf_model()->item_count());
   item = *shelf_model()->ItemByID(shortcut_id);
   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, item.type);
   EXPECT_EQ(ash::STATUS_ACTIVE, item.status);
 
   // Unpin the app. The item should remain.
   controller_->Unpin(shortcut_id);
   ASSERT_EQ(item_count, shelf_model()->item_count());
   item = *shelf_model()->ItemByID(shortcut_id);
   EXPECT_EQ(ash::TYPE_PLATFORM_APP, item.type);
   EXPECT_EQ(ash::STATUS_ACTIVE, item.status);
   // The item should have moved after the other shortcuts.
   EXPECT_GT(shelf_model()->ItemIndexByID(shortcut_id),
             shelf_model()->ItemIndexByID(foo_id));
 
   // Then close it, make sure the item's gone.
-  CloseShellWindow(window);
+  CloseAppWindow(window);
   --item_count;
   ASSERT_EQ(item_count, shelf_model()->item_count());
 }
 
 // Test that we can launch a platform app with more than one window.
 IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest, MultipleWindows) {
   int item_count = shelf_model()->item_count();
 
   // First run app.
   const Extension* extension = LoadAndLaunchPlatformApp("launch");
-  ShellWindow* window1 = CreateShellWindow(extension);
+  AppWindow* window1 = CreateAppWindow(extension);
   ++item_count;
   ASSERT_EQ(item_count, shelf_model()->item_count());
   const ash::ShelfItem& item1 = GetLastLauncherItem();
   ash::ShelfID item_id = item1.id;
   EXPECT_EQ(ash::TYPE_PLATFORM_APP, item1.type);
   EXPECT_EQ(ash::STATUS_ACTIVE, item1.status);
   EXPECT_EQ(2, GetNumApplicationMenuItems(item1));  // Title + 1 window
 
   // Add second window.
-  ShellWindow* window2 = CreateShellWindow(extension);
+  AppWindow* window2 = CreateAppWindow(extension);
   // Confirm item stays.
   ASSERT_EQ(item_count, shelf_model()->item_count());
   const ash::ShelfItem& item2 = *shelf_model()->ItemByID(item_id);
   EXPECT_EQ(ash::STATUS_ACTIVE, item2.status);
   EXPECT_EQ(3, GetNumApplicationMenuItems(item2));  // Title + 2 windows
 
   // Close second window.
-  CloseShellWindow(window2);
+  CloseAppWindow(window2);
   // Confirm item stays.
   ASSERT_EQ(item_count, shelf_model()->item_count());
   const ash::ShelfItem& item3 = *shelf_model()->ItemByID(item_id);
   EXPECT_EQ(ash::STATUS_ACTIVE, item3.status);
   EXPECT_EQ(2, GetNumApplicationMenuItems(item3));  // Title + 1 window
 
   // Close first window.
-  CloseShellWindow(window1);
+  CloseAppWindow(window1);
   // Confirm item is removed.
   --item_count;
   ASSERT_EQ(item_count, shelf_model()->item_count());
 }
 
 IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest, MultipleApps) {
   int item_count = shelf_model()->item_count();
 
   // First run app.
   const Extension* extension1 = LoadAndLaunchPlatformApp("launch");
-  ShellWindow* window1 = CreateShellWindow(extension1);
+  AppWindow* window1 = CreateAppWindow(extension1);
   ++item_count;
   ASSERT_EQ(item_count, shelf_model()->item_count());
   const ash::ShelfItem& item1 = GetLastLauncherItem();
   ash::ShelfID item_id1 = item1.id;
   EXPECT_EQ(ash::TYPE_PLATFORM_APP, item1.type);
   EXPECT_EQ(ash::STATUS_ACTIVE, item1.status);
 
   // Then run second app.
   const Extension* extension2 = LoadAndLaunchPlatformApp("launch_2");
-  ShellWindow* window2 = CreateShellWindow(extension2);
+  AppWindow* window2 = CreateAppWindow(extension2);
   ++item_count;
   ASSERT_EQ(item_count, shelf_model()->item_count());
   const ash::ShelfItem& item2 = GetLastLauncherItem();
   ash::ShelfID item_id2 = item2.id;
   EXPECT_EQ(ash::TYPE_PLATFORM_APP, item2.type);
   EXPECT_EQ(ash::STATUS_ACTIVE, item2.status);
 
   EXPECT_NE(item_id1, item_id2);
   EXPECT_EQ(ash::STATUS_RUNNING, shelf_model()->ItemByID(item_id1)->status);
 
   // Close second app.
-  CloseShellWindow(window2);
+  CloseAppWindow(window2);
   --item_count;
   ASSERT_EQ(item_count, shelf_model()->item_count());
   // First app should be active again.
   EXPECT_EQ(ash::STATUS_ACTIVE, shelf_model()->ItemByID(item_id1)->status);
 
   // Close first app.
-  CloseShellWindow(window1);
+  CloseAppWindow(window1);
   --item_count;
   ASSERT_EQ(item_count, shelf_model()->item_count());
 }
 
 // Confirm that app windows can be reactivated by clicking their icons and that
 // the correct activation order is maintained.
 IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest, WindowActivation) {
   int item_count = shelf_model()->item_count();
 
   // First run app.
   const Extension* extension1 = LoadAndLaunchPlatformApp("launch");
-  ShellWindow* window1 = CreateShellWindow(extension1);
+  AppWindow* window1 = CreateAppWindow(extension1);
   ++item_count;
   ASSERT_EQ(item_count, shelf_model()->item_count());
   const ash::ShelfItem& item1 = GetLastLauncherItem();
   ash::ShelfID item_id1 = item1.id;
   EXPECT_EQ(ash::TYPE_PLATFORM_APP, item1.type);
   EXPECT_EQ(ash::STATUS_ACTIVE, item1.status);
 
   // Then run second app.
   const Extension* extension2 = LoadAndLaunchPlatformApp("launch_2");
-  ShellWindow* window2 = CreateShellWindow(extension2);
+  AppWindow* window2 = CreateAppWindow(extension2);
   ++item_count;
   ASSERT_EQ(item_count, shelf_model()->item_count());
   const ash::ShelfItem& item2 = GetLastLauncherItem();
   ash::ShelfID item_id2 = item2.id;
   EXPECT_EQ(ash::TYPE_PLATFORM_APP, item2.type);
   EXPECT_EQ(ash::STATUS_ACTIVE, item2.status);
 
   EXPECT_NE(item_id1, item_id2);
   EXPECT_EQ(ash::STATUS_RUNNING, shelf_model()->ItemByID(item_id1)->status);
 
   // Activate first one.
   ActivateShelfItem(shelf_model()->ItemIndexByID(item_id1));
   EXPECT_EQ(ash::STATUS_ACTIVE, shelf_model()->ItemByID(item_id1)->status);
   EXPECT_EQ(ash::STATUS_RUNNING, shelf_model()->ItemByID(item_id2)->status);
   EXPECT_TRUE(ash::wm::IsActiveWindow(window1->GetNativeWindow()));
   EXPECT_FALSE(ash::wm::IsActiveWindow(window2->GetNativeWindow()));
 
   // Activate second one.
   ActivateShelfItem(shelf_model()->ItemIndexByID(item_id2));
   EXPECT_EQ(ash::STATUS_RUNNING, shelf_model()->ItemByID(item_id1)->status);
   EXPECT_EQ(ash::STATUS_ACTIVE, shelf_model()->ItemByID(item_id2)->status);
   EXPECT_FALSE(ash::wm::IsActiveWindow(window1->GetNativeWindow()));
   EXPECT_TRUE(ash::wm::IsActiveWindow(window2->GetNativeWindow()));
 
   // Add window for app1. This will activate it.
-  ShellWindow* window1b = CreateShellWindow(extension1);
+  AppWindow* window1b = CreateAppWindow(extension1);
   ash::wm::ActivateWindow(window1b->GetNativeWindow());
   EXPECT_FALSE(ash::wm::IsActiveWindow(window1->GetNativeWindow()));
   EXPECT_FALSE(ash::wm::IsActiveWindow(window2->GetNativeWindow()));
   EXPECT_TRUE(ash::wm::IsActiveWindow(window1b->GetNativeWindow()));
 
   // Activate launcher item for app1, this will activate the first app window.
   ActivateShelfItem(shelf_model()->ItemIndexByID(item_id1));
   EXPECT_TRUE(ash::wm::IsActiveWindow(window1->GetNativeWindow()));
   EXPECT_FALSE(ash::wm::IsActiveWindow(window1b->GetNativeWindow()));
   ActivateShelfItem(shelf_model()->ItemIndexByID(item_id1));
   EXPECT_TRUE(ash::wm::IsActiveWindow(window1b->GetNativeWindow()));
 
   // Activate the second app again
   ActivateShelfItem(shelf_model()->ItemIndexByID(item_id2));
   EXPECT_FALSE(ash::wm::IsActiveWindow(window1->GetNativeWindow()));
   EXPECT_TRUE(ash::wm::IsActiveWindow(window2->GetNativeWindow()));
   EXPECT_FALSE(ash::wm::IsActiveWindow(window1b->GetNativeWindow()));
 
   // Activate the first app again
   ActivateShelfItem(shelf_model()->ItemIndexByID(item_id1));
   EXPECT_TRUE(ash::wm::IsActiveWindow(window1b->GetNativeWindow()));
   EXPECT_FALSE(ash::wm::IsActiveWindow(window2->GetNativeWindow()));
   EXPECT_FALSE(ash::wm::IsActiveWindow(window1->GetNativeWindow()));
 
   // Close second app.
-  CloseShellWindow(window2);
+  CloseAppWindow(window2);
   --item_count;
   EXPECT_EQ(item_count, shelf_model()->item_count());
   // First app should be active again.
   EXPECT_EQ(ash::STATUS_ACTIVE, shelf_model()->ItemByID(item_id1)->status);
 
   // Close first app.
-  CloseShellWindow(window1b);
-  CloseShellWindow(window1);
+  CloseAppWindow(window1b);
+  CloseAppWindow(window1);
   --item_count;
   EXPECT_EQ(item_count, shelf_model()->item_count());
 }
 
 // Confirm that Click behavior for app windows is correnct.
 IN_PROC_BROWSER_TEST_F(ShelfAppBrowserNoMinimizeOnClick, AppClickBehavior) {
   // Launch a platform app and create a window for it.
   const Extension* extension1 = LoadAndLaunchPlatformApp("launch");
-  ShellWindow* window1 = CreateShellWindow(extension1);
+  AppWindow* window1 = CreateAppWindow(extension1);
   EXPECT_TRUE(window1->GetNativeWindow()->IsVisible());
   EXPECT_TRUE(window1->GetBaseWindow()->IsActive());
   // Confirm that a controller item was created and is the correct state.
   const ash::ShelfItem& item1 = GetLastLauncherItem();
   LauncherItemController* item1_controller = GetItemController(item1.id);
   EXPECT_EQ(ash::TYPE_PLATFORM_APP, item1.type);
   EXPECT_EQ(ash::STATUS_ACTIVE, item1.status);
   EXPECT_EQ(LauncherItemController::TYPE_APP, item1_controller->type());
   // Clicking the item should have no effect.
   TestEvent click_event(ui::ET_MOUSE_PRESSED);
@@ skipping 17 matching lines @@
   EXPECT_TRUE(window1->GetNativeWindow()->IsVisible());
   EXPECT_TRUE(window1->GetBaseWindow()->IsActive());
   EXPECT_TRUE(window1->GetBaseWindow()->IsMaximized());
 }
 
 // Confirm the minimizing click behavior for apps.
 IN_PROC_BROWSER_TEST_F(ShelfAppBrowserMinimizeOnClick,
                        PackagedAppClickBehaviorInMinimizeMode) {
   // Launch one platform app and create a window for it.
   const Extension* extension1 = LoadAndLaunchPlatformApp("launch");
-  ShellWindow* window1 = CreateShellWindow(extension1);
+  AppWindow* window1 = CreateAppWindow(extension1);
   EXPECT_TRUE(window1->GetNativeWindow()->IsVisible());
   EXPECT_TRUE(window1->GetBaseWindow()->IsActive());
 
   // Confirm that a controller item was created and is the correct state.
   const ash::ShelfItem& item1 = GetLastLauncherItem();
   LauncherItemController* item1_controller = GetItemController(item1.id);
   EXPECT_EQ(ash::TYPE_PLATFORM_APP, item1.type);
   EXPECT_EQ(ash::STATUS_ACTIVE, item1.status);
   EXPECT_EQ(LauncherItemController::TYPE_APP, item1_controller->type());
   // Since it is already active, clicking it should minimize.
@@ skipping 15 matching lines @@
   EXPECT_TRUE(window1->GetNativeWindow()->IsVisible());
   EXPECT_TRUE(window1->GetBaseWindow()->IsActive());
   EXPECT_TRUE(window1->GetBaseWindow()->IsMaximized());
   window1->GetBaseWindow()->Restore();
   EXPECT_TRUE(window1->GetNativeWindow()->IsVisible());
   EXPECT_TRUE(window1->GetBaseWindow()->IsActive());
   EXPECT_FALSE(window1->GetBaseWindow()->IsMaximized());
 
   // Creating a second window of the same type should change the behavior so
   // that a click does not change the activation state.
-  ShellWindow* window1a = CreateShellWindow(extension1);
+  AppWindow* window1a = CreateAppWindow(extension1);
   EXPECT_TRUE(window1a->GetNativeWindow()->IsVisible());
   EXPECT_TRUE(window1a->GetBaseWindow()->IsActive());
   // The first click does nothing.
   item1_controller->ItemSelected(click_event);
   EXPECT_TRUE(window1->GetNativeWindow()->IsVisible());
   EXPECT_TRUE(window1a->GetNativeWindow()->IsVisible());
   EXPECT_TRUE(window1->GetBaseWindow()->IsActive());
   EXPECT_FALSE(window1a->GetBaseWindow()->IsActive());
   // The second neither.
   item1_controller->ItemSelected(click_event);
   EXPECT_TRUE(window1->GetNativeWindow()->IsVisible());
   EXPECT_TRUE(window1a->GetNativeWindow()->IsVisible());
   EXPECT_TRUE(window1->GetBaseWindow()->IsActive());
   EXPECT_FALSE(window1a->GetBaseWindow()->IsActive());
 }
 
 // Confirm that click behavior for app panels is correct.
 IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest, AppPanelClickBehavior) {
   // Enable experimental APIs to allow panel creation.
   CommandLine::ForCurrentProcess()->AppendSwitch(
       extensions::switches::kEnableExperimentalExtensionApis);
   // Launch a platform app and create a panel window for it.
   const Extension* extension1 = LoadAndLaunchPlatformApp("launch");
-  ShellWindow::CreateParams params;
-  params.window_type = ShellWindow::WINDOW_TYPE_PANEL;
+  AppWindow::CreateParams params;
+  params.window_type = AppWindow::WINDOW_TYPE_PANEL;
   params.focused = false;
-  ShellWindow* panel = CreateShellWindowFromParams(extension1, params);
+  AppWindow* panel = CreateAppWindowFromParams(extension1, params);
   EXPECT_TRUE(panel->GetNativeWindow()->IsVisible());
   // Panels should not be active by default.
   EXPECT_FALSE(panel->GetBaseWindow()->IsActive());
   // Confirm that a controller item was created and is the correct state.
   const ash::ShelfItem& item1 = GetLastLauncherPanelItem();
   LauncherItemController* item1_controller = GetItemController(item1.id);
   EXPECT_EQ(ash::TYPE_APP_PANEL, item1.type);
   EXPECT_EQ(ash::STATUS_RUNNING, item1.status);
   EXPECT_EQ(LauncherItemController::TYPE_APP_PANEL, item1_controller->type());
   // Click the item and confirm that the panel is activated.
@@ skipping 10 matching lines @@
   EXPECT_TRUE(panel->GetNativeWindow()->IsVisible());
   EXPECT_TRUE(panel->GetBaseWindow()->IsActive());
   EXPECT_EQ(ash::STATUS_ACTIVE, item1.status);
 }
 
 IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest, BrowserActivation) {
   int item_count = shelf_model()->item_count();
 
   // First run app.
   const Extension* extension1 = LoadAndLaunchPlatformApp("launch");
-  CreateShellWindow(extension1);
+  CreateAppWindow(extension1);
   ++item_count;
   ASSERT_EQ(item_count, shelf_model()->item_count());
   const ash::ShelfItem& item1 = GetLastLauncherItem();
   ash::ShelfID item_id1 = item1.id;
   EXPECT_EQ(ash::TYPE_PLATFORM_APP, item1.type);
   EXPECT_EQ(ash::STATUS_ACTIVE, item1.status);
 
   ash::wm::ActivateWindow(browser()->window()->GetNativeWindow());
   EXPECT_EQ(ash::STATUS_RUNNING, shelf_model()->ItemByID(item_id1)->status);
 }
 
 // Test that opening an app sets the correct icon
 IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest, SetIcon) {
-  TestShellWindowRegistryObserver test_observer(browser()->profile());
+  TestAppWindowRegistryObserver test_observer(browser()->profile());
 
   // Enable experimental APIs to allow panel creation.
   CommandLine::ForCurrentProcess()->AppendSwitch(
       extensions::switches::kEnableExperimentalExtensionApis);
 
   int base_shelf_item_count = shelf_model()->item_count();
   ExtensionTestMessageListener launched_listener("Launched", false);
   ExtensionTestMessageListener completed_listener("Completed", false);
   LoadAndLaunchPlatformApp("app_icon");
   ASSERT_TRUE(launched_listener.WaitUntilSatisfied());
   ASSERT_TRUE(completed_listener.WaitUntilSatisfied());
 
   // Now wait until the WebContent has decoded the icons and chrome has
   // processed it. This needs to be in a loop since the renderer runs in a
   // different process.
   while (test_observer.icon_updates() < 3) {
     base::RunLoop run_loop;
     run_loop.RunUntilIdle();
   }
 
-  // This test creates one shell window and one panel window.
+  // This test creates one app window and one panel window.
   int shelf_item_count = shelf_model()->item_count();
   ASSERT_EQ(base_shelf_item_count + 2, shelf_item_count);
   // The Panel will be the last item, the app second-to-last.
   const ash::ShelfItem& app_item =
       shelf_model()->items()[shelf_item_count - 2];
   const ash::ShelfItem& panel_item =
       shelf_model()->items()[shelf_item_count - 1];
   const LauncherItemController* app_item_controller =
       GetItemController(app_item.id);
   const LauncherItemController* panel_item_controller =
@@ skipping 507 matching lines @@
   ActivateShelfItem(shortcut_index);
   EXPECT_EQ(content2, browser()->tab_strip_model()->GetActiveWebContents());
 }
 
 // Check that the keyboard activation of a launcher item tabs properly through
 // the items at hand.
 IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest,
                        AltNumberAppsTabbing) {
   // First run app.
   const Extension* extension1 = LoadAndLaunchPlatformApp("launch");
-  ui::BaseWindow* window1 = CreateShellWindow(extension1)->GetBaseWindow();
+  ui::BaseWindow* window1 = CreateAppWindow(extension1)->GetBaseWindow();
   const ash::ShelfItem& item1 = GetLastLauncherItem();
   ash::ShelfID app_id = item1.id;
   int app_index = shelf_model()->ItemIndexByID(app_id);
 
   EXPECT_EQ(ash::TYPE_PLATFORM_APP, item1.type);
   EXPECT_EQ(ash::STATUS_ACTIVE, item1.status);
 
   const Extension* extension2 = LoadAndLaunchPlatformApp("launch_2");
-  ui::BaseWindow* window2 = CreateShellWindow(extension2)->GetBaseWindow();
+  ui::BaseWindow* window2 = CreateAppWindow(extension2)->GetBaseWindow();
 
   // By now the browser should be active. Issue Alt keystrokes several times to
   // see that we stay on that application.
   EXPECT_TRUE(window2->IsActive());
   ActivateShelfItem(app_index);
   EXPECT_TRUE(window1->IsActive());
   ActivateShelfItem(app_index);
   EXPECT_TRUE(window1->IsActive());
 
-  ui::BaseWindow* window1a = CreateShellWindow(extension1)->GetBaseWindow();
+  ui::BaseWindow* window1a = CreateAppWindow(extension1)->GetBaseWindow();
 
   EXPECT_TRUE(window1a->IsActive());
   EXPECT_FALSE(window1->IsActive());
   ActivateShelfItem(app_index);
   EXPECT_TRUE(window1->IsActive());
   ActivateShelfItem(app_index);
   EXPECT_TRUE(window1a->IsActive());
 }
 
 // Test that we can launch a platform app panel and get a running item.
 IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest, LaunchPanelWindow) {
   int item_count = shelf_model()->item_count();
   const Extension* extension = LoadAndLaunchPlatformApp("launch");
-  ShellWindow::CreateParams params;
-  params.window_type = ShellWindow::WINDOW_TYPE_PANEL;
+  AppWindow::CreateParams params;
+  params.window_type = AppWindow::WINDOW_TYPE_PANEL;
   params.focused = false;
-  ShellWindow* window = CreateShellWindowFromParams(extension, params);
+  AppWindow* window = CreateAppWindowFromParams(extension, params);
   ++item_count;
   ASSERT_EQ(item_count, shelf_model()->item_count());
   const ash::ShelfItem& item = GetLastLauncherPanelItem();
   EXPECT_EQ(ash::TYPE_APP_PANEL, item.type);
   // Opening a panel does not activate it.
   EXPECT_EQ(ash::STATUS_RUNNING, item.status);
-  CloseShellWindow(window);
+  CloseAppWindow(window);
   --item_count;
   EXPECT_EQ(item_count, shelf_model()->item_count());
 }
 
 // Test attention states of windows.
 IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest, WindowAttentionStatus) {
   const Extension* extension = LoadAndLaunchPlatformApp("launch");
-  ShellWindow::CreateParams params;
-  params.window_type = ShellWindow::WINDOW_TYPE_PANEL;
+  AppWindow::CreateParams params;
+  params.window_type = AppWindow::WINDOW_TYPE_PANEL;
   params.focused = false;
-  ShellWindow* panel = CreateShellWindowFromParams(extension, params);
+  AppWindow* panel = CreateAppWindowFromParams(extension, params);
   EXPECT_TRUE(panel->GetNativeWindow()->IsVisible());
   // Panels should not be active by default.
   EXPECT_FALSE(panel->GetBaseWindow()->IsActive());
   // Confirm that a controller item was created and is the correct state.
   const ash::ShelfItem& item = GetLastLauncherPanelItem();
   LauncherItemController* item_controller = GetItemController(item.id);
   EXPECT_EQ(ash::TYPE_APP_PANEL, item.type);
   EXPECT_EQ(ash::STATUS_RUNNING, item.status);
   EXPECT_EQ(LauncherItemController::TYPE_APP_PANEL, item_controller->type());
 
@@ skipping 622 matching lines @@
                                GURL("http://www.foo.com/bar.html"));
   // Make sure the navigation was entirely performed.
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(ash::STATUS_ACTIVE, model_->ItemByID(id)->status);
   app_browser->tab_strip_model()->CloseWebContentsAt(0,
                                                      TabStripModel::CLOSE_NONE);
   // Make sure that the app is really gone.
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(ash::STATUS_CLOSED, model_->ItemByID(id)->status);
 }