Remove PerBrowser launcher, reland step 1 of 2

chrome/browser/ui/ash/launcher/chrome_launcher_controller_per_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 "chrome/browser/ui/ash/launcher/chrome_launcher_controller.h"
+#include "chrome/browser/ui/ash/launcher/chrome_launcher_controller_per_app.h"
 
 #include "apps/native_app_window.h"
 #include "apps/shell_window.h"
 #include "apps/shell_window_registry.h"
 #include "ash/ash_switches.h"
 #include "ash/display/display_controller.h"
 #include "ash/launcher/launcher.h"
 #include "ash/launcher/launcher_model.h"
 #include "ash/launcher/launcher_util.h"
 #include "ash/launcher/launcher_view.h"
 #include "ash/shell.h"
 #include "ash/test/launcher_view_test_api.h"
 #include "ash/test/shell_test_api.h"
 #include "ash/wm/window_util.h"
+#include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/apps/app_browsertest_util.h"
 #include "chrome/browser/automation/automation_util.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/extension_apitest.h"
 #include "chrome/browser/extensions/extension_browsertest.h"
 #include "chrome/browser/extensions/extension_function_test_utils.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/profiles/profile.h"
 #include "chrome/browser/ui/app_list/app_list_service.h"
 #include "chrome/browser/ui/ash/launcher/browser_shortcut_launcher_item_controller.h"
-#include "chrome/browser/ui/ash/launcher/chrome_launcher_controller_per_app.h"
 #include "chrome/browser/ui/ash/launcher/launcher_item_controller.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/extensions/application_launch.h"
 #include "chrome/browser/ui/host_desktop.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/web_contents.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/base/events/event.h"
 
 using apps::ShellWindow;
 using extensions::Extension;
 using content::WebContents;
 
 namespace {
 
@@ skipping 35 matching lines @@
 
  private:
   Profile* profile_;
   int icon_updates_;
 
   DISALLOW_COPY_AND_ASSIGN(TestShellWindowRegistryObserver);
 };
 
 }  // namespace
 
-// TODO(skuhne): Change name back to LauncherPlatformAppBrowserTest when the
-// old launcher gets ripped out.
-class LauncherPlatformPerAppAppBrowserTest
+class LauncherPlatformAppBrowserTest
     : public extensions::PlatformAppBrowserTest {
  protected:
-  LauncherPlatformPerAppAppBrowserTest()
-      : launcher_(NULL),
-        controller_(NULL) {
+  LauncherPlatformAppBrowserTest() : launcher_(NULL), controller_(NULL) {
   }
 
-  virtual ~LauncherPlatformPerAppAppBrowserTest() {}
+  virtual ~LauncherPlatformAppBrowserTest() {}
 
   virtual void RunTestOnMainThreadLoop() OVERRIDE {
     launcher_ = ash::Launcher::ForPrimaryDisplay();
-    controller_ =
-        static_cast<ChromeLauncherControllerPerApp*>(launcher_->delegate());
+    controller_ = ChromeLauncherController::instance();
     return extensions::PlatformAppBrowserTest::RunTestOnMainThreadLoop();
   }
 
   ash::LauncherModel* launcher_model() {
     return ash::test::ShellTestApi(ash::Shell::GetInstance()).launcher_model();
   }
 
   ash::LauncherID CreateAppShortcutLauncherItem(const std::string& name) {
     return controller_->CreateAppShortcutLauncherItem(
         name, controller_->model()->item_count());
@@ skipping 27 matching lines @@
     }
     return num_items;
   }
 
   // Activate the launcher item with the given |id|.
   void ActivateLauncherItem(int id) {
     launcher_->ActivateLauncherItem(id);
   }
 
   ash::Launcher* launcher_;
-  ChromeLauncherControllerPerApp* controller_;
+  ChromeLauncherController* controller_;
 
  private:
 
-  DISALLOW_COPY_AND_ASSIGN(LauncherPlatformPerAppAppBrowserTest);
+  DISALLOW_COPY_AND_ASSIGN(LauncherPlatformAppBrowserTest);
 };
 
-// TODO(skuhne): Change name back to LauncherAppBrowserTest when the
-// old launcher gets ripped out.
-class LauncherPerAppAppBrowserTest : public ExtensionBrowserTest {
+class LauncherAppBrowserTest : public ExtensionBrowserTest {
  protected:
-  LauncherPerAppAppBrowserTest()
-      : launcher_(NULL),
-        model_(NULL) {
+  LauncherAppBrowserTest() : launcher_(NULL), model_(NULL), controller_(NULL) {
   }
 
-  virtual ~LauncherPerAppAppBrowserTest() {}
+  virtual ~LauncherAppBrowserTest() {}
 
   virtual void RunTestOnMainThreadLoop() OVERRIDE {
     launcher_ = ash::Launcher::ForPrimaryDisplay();
     model_ =
         ash::test::ShellTestApi(ash::Shell::GetInstance()).launcher_model();
+    controller_ = ChromeLauncherController::instance();
     return ExtensionBrowserTest::RunTestOnMainThreadLoop();
   }
 
   size_t NumberOfDetectedLauncherBrowsers(bool show_all_tabs) {
-    ChromeLauncherControllerPerApp* controller =
-        static_cast<ChromeLauncherControllerPerApp*>(launcher_->delegate());
     LauncherItemController* item_controller =
-      controller->GetBrowserShortcutLauncherItemController();
+      controller_->GetBrowserShortcutLauncherItemController();
     int items = item_controller->GetApplicationList(
         show_all_tabs ? ui::EF_SHIFT_DOWN : 0).size();
     // If we have at least one item, we have also a title which we remove here.
     return items ? (items - 1) : 0;
   }
 
   const Extension* LoadAndLaunchExtension(
       const char* name,
       extension_misc::LaunchContainer container,
       WindowOpenDisposition disposition) {
@@ skipping 16 matching lines @@
     ExtensionService* service = extensions::ExtensionSystem::Get(
         profile())->extension_service();
     LoadExtension(test_data_dir_.AppendASCII(name));
 
     // First get app_id.
     const Extension* extension =
         service->GetExtensionById(last_loaded_extension_id_, false);
     const std::string app_id = extension->id();
 
     // Then create a shortcut.
-    ChromeLauncherController* controller =
-        static_cast<ChromeLauncherController*>(launcher_->delegate());
     int item_count = model_->item_count();
-    ash::LauncherID shortcut_id = controller->CreateAppShortcutLauncherItem(
+    ash::LauncherID shortcut_id = controller_->CreateAppShortcutLauncherItem(
         app_id,
         item_count);
-    controller->PersistPinnedState();
+    controller_->PersistPinnedState();
     EXPECT_EQ(++item_count, model_->item_count());
     const ash::LauncherItem& item = *model_->ItemByID(shortcut_id);
     EXPECT_EQ(ash::TYPE_APP_SHORTCUT, item.type);
     return item.id;
   }
 
   // Activate the launcher item with the given |id|.
   void ActivateLauncherItem(int id) {
     launcher_->ActivateLauncherItem(id);
   }
 
+  ash::LauncherID PinFakeApp(const std::string& name) {
+    return controller_->CreateAppShortcutLauncherItem(
+        name, model_->item_count());
+  }
+
   ash::Launcher* launcher_;
   ash::LauncherModel* model_;
+  ChromeLauncherController* controller_;
 
  private:
 
-  DISALLOW_COPY_AND_ASSIGN(LauncherPerAppAppBrowserTest);
+  DISALLOW_COPY_AND_ASSIGN(LauncherAppBrowserTest);
 };
 
-// TODO(skuhne): Change name to LauncherAppBrowserTestNoBrowser when the
-// old launcher gets ripped out.
-class LauncherPerAppAppBrowserTestNoDefaultBrowser
-    : public LauncherPerAppAppBrowserTest {
+class LauncherAppBrowserTestNoDefaultBrowser : public LauncherAppBrowserTest {
  protected:
-  LauncherPerAppAppBrowserTestNoDefaultBrowser() {}
-  virtual ~LauncherPerAppAppBrowserTestNoDefaultBrowser() {}
+  LauncherAppBrowserTestNoDefaultBrowser() {}
+  virtual ~LauncherAppBrowserTestNoDefaultBrowser() {}
 
   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
-    LauncherPerAppAppBrowserTest::SetUpCommandLine(command_line);
+    LauncherAppBrowserTest::SetUpCommandLine(command_line);
     command_line->AppendSwitch(switches::kNoStartupWindow);
   }
 
  private:
 
-  DISALLOW_COPY_AND_ASSIGN(LauncherPerAppAppBrowserTestNoDefaultBrowser);
+  DISALLOW_COPY_AND_ASSIGN(LauncherAppBrowserTestNoDefaultBrowser);
 };
 
 // Since the default for minimizing on click might change, I added both classes
 // to either get the minimize on click or not.
-class LauncherPerAppAppBrowserNoMinimizeOnClick
-    : public LauncherPlatformPerAppAppBrowserTest {
+class LauncherAppBrowserNoMinimizeOnClick
+    : public LauncherPlatformAppBrowserTest {
  protected:
-  LauncherPerAppAppBrowserNoMinimizeOnClick() {}
-  virtual ~LauncherPerAppAppBrowserNoMinimizeOnClick() {}
+  LauncherAppBrowserNoMinimizeOnClick() {}
+  virtual ~LauncherAppBrowserNoMinimizeOnClick() {}
 
   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
-    LauncherPlatformPerAppAppBrowserTest::SetUpCommandLine(command_line);
+    LauncherPlatformAppBrowserTest::SetUpCommandLine(command_line);
     command_line->AppendSwitch(
         switches::kDisableMinimizeOnSecondLauncherItemClick);
   }
 
  private:
 
-  DISALLOW_COPY_AND_ASSIGN(LauncherPerAppAppBrowserNoMinimizeOnClick);
+  DISALLOW_COPY_AND_ASSIGN(LauncherAppBrowserNoMinimizeOnClick);
 };
 
-typedef LauncherPlatformPerAppAppBrowserTest
-    LauncherPerAppAppBrowserMinimizeOnClick;
+typedef LauncherPlatformAppBrowserTest LauncherAppBrowserMinimizeOnClick;
 
 // Test that we can launch a platform app and get a running item.
-IN_PROC_BROWSER_TEST_F(LauncherPlatformPerAppAppBrowserTest, LaunchUnpinned) {
+IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest, LaunchUnpinned) {
   int item_count = launcher_model()->item_count();
   const Extension* extension = LoadAndLaunchPlatformApp("launch");
   ShellWindow* window = CreateShellWindow(extension);
   ++item_count;
   ASSERT_EQ(item_count, launcher_model()->item_count());
   const ash::LauncherItem& item = GetLastLauncherItem();
   EXPECT_EQ(ash::TYPE_PLATFORM_APP, item.type);
   EXPECT_EQ(ash::STATUS_ACTIVE, item.status);
   CloseShellWindow(window);
   --item_count;
   EXPECT_EQ(item_count, launcher_model()->item_count());
 }
 
 // Test that we can launch a platform app that already has a shortcut.
-IN_PROC_BROWSER_TEST_F(LauncherPlatformPerAppAppBrowserTest, LaunchPinned) {
+IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest, LaunchPinned) {
   int item_count = launcher_model()->item_count();
 
   // First get app_id.
   const Extension* extension = LoadAndLaunchPlatformApp("launch");
   const std::string app_id = extension->id();
 
   // Then create a shortcut.
   ash::LauncherID shortcut_id = CreateAppShortcutLauncherItem(app_id);
   ++item_count;
   ASSERT_EQ(item_count, launcher_model()->item_count());
@@ skipping 10 matching lines @@
   EXPECT_EQ(ash::STATUS_ACTIVE, item.status);
 
   // Then close it, make sure there's still an item.
   CloseShellWindow(window);
   ASSERT_EQ(item_count, launcher_model()->item_count());
   item = *launcher_model()->ItemByID(shortcut_id);
   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, item.type);
   EXPECT_EQ(ash::STATUS_CLOSED, item.status);
 }
 
-IN_PROC_BROWSER_TEST_F(LauncherPlatformPerAppAppBrowserTest, PinRunning) {
+IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest, PinRunning) {
   // Run.
   int item_count = launcher_model()->item_count();
   const Extension* extension = LoadAndLaunchPlatformApp("launch");
   ShellWindow* window = CreateShellWindow(extension);
   ++item_count;
   ASSERT_EQ(item_count, launcher_model()->item_count());
   const ash::LauncherItem& item1 = GetLastLauncherItem();
   ash::LauncherID id = item1.id;
   EXPECT_EQ(ash::TYPE_PLATFORM_APP, item1.type);
   EXPECT_EQ(ash::STATUS_ACTIVE, item1.status);
@@ skipping 17 matching lines @@
   ++item_count;
   ASSERT_EQ(item_count, launcher_model()->item_count());
   EXPECT_LT(launcher_model()->ItemIndexByID(id),
             launcher_model()->ItemIndexByID(bar_id));
 
   // Then close it, make sure the item remains.
   CloseShellWindow(window);
   ASSERT_EQ(item_count, launcher_model()->item_count());
 }
 
-IN_PROC_BROWSER_TEST_F(LauncherPlatformPerAppAppBrowserTest, UnpinRunning) {
+IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest, UnpinRunning) {
   int item_count = launcher_model()->item_count();
 
   // First get app_id.
   const Extension* extension = LoadAndLaunchPlatformApp("launch");
   const std::string app_id = extension->id();
 
   // Then create a shortcut.
   ash::LauncherID shortcut_id = CreateAppShortcutLauncherItem(app_id);
   ++item_count;
   ASSERT_EQ(item_count, launcher_model()->item_count());
@@ skipping 27 matching lines @@
   EXPECT_GT(launcher_model()->ItemIndexByID(shortcut_id),
             launcher_model()->ItemIndexByID(foo_id));
 
   // Then close it, make sure the item's gone.
   CloseShellWindow(window);
   --item_count;
   ASSERT_EQ(item_count, launcher_model()->item_count());
 }
 
 // Test that we can launch a platform app with more than one window.
-IN_PROC_BROWSER_TEST_F(LauncherPlatformPerAppAppBrowserTest, MultipleWindows) {
+IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest, MultipleWindows) {
   int item_count = launcher_model()->item_count();
 
   // First run app.
   const Extension* extension = LoadAndLaunchPlatformApp("launch");
   ShellWindow* window1 = CreateShellWindow(extension);
   ++item_count;
   ASSERT_EQ(item_count, launcher_model()->item_count());
-  const ash::LauncherItem& item = GetLastLauncherItem();
-  ash::LauncherID item_id = item.id;
-  EXPECT_EQ(ash::TYPE_PLATFORM_APP, item.type);
-  EXPECT_EQ(ash::STATUS_ACTIVE, item.status);
-  EXPECT_EQ(2, GetNumApplicationMenuItems(item));  // Title + 1 window
+  const ash::LauncherItem& item1 = GetLastLauncherItem();
+  ash::LauncherID 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);
   // Confirm item stays.
   ASSERT_EQ(item_count, launcher_model()->item_count());
   const ash::LauncherItem& item2 = *launcher_model()->ItemByID(item_id);
   EXPECT_EQ(ash::STATUS_ACTIVE, item2.status);
   EXPECT_EQ(3, GetNumApplicationMenuItems(item2));  // Title + 2 windows
 
   // Close second window.
   CloseShellWindow(window2);
   // Confirm item stays.
   ASSERT_EQ(item_count, launcher_model()->item_count());
   const ash::LauncherItem& item3 = *launcher_model()->ItemByID(item_id);
   EXPECT_EQ(ash::STATUS_ACTIVE, item3.status);
   EXPECT_EQ(2, GetNumApplicationMenuItems(item3));  // Title + 1 window
 
   // Close first window.
   CloseShellWindow(window1);
   // Confirm item is removed.
   --item_count;
   ASSERT_EQ(item_count, launcher_model()->item_count());
 }
 
-IN_PROC_BROWSER_TEST_F(LauncherPlatformPerAppAppBrowserTest, MultipleApps) {
+IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest, MultipleApps) {
   int item_count = launcher_model()->item_count();
 
   // First run app.
   const Extension* extension1 = LoadAndLaunchPlatformApp("launch");
   ShellWindow* window1 = CreateShellWindow(extension1);
   ++item_count;
   ASSERT_EQ(item_count, launcher_model()->item_count());
   const ash::LauncherItem& item1 = GetLastLauncherItem();
   ash::LauncherID item_id1 = item1.id;
   EXPECT_EQ(ash::TYPE_PLATFORM_APP, item1.type);
@@ skipping 18 matching lines @@
   --item_count;
   ASSERT_EQ(item_count, launcher_model()->item_count());
   // First app should be active again.
   EXPECT_EQ(ash::STATUS_ACTIVE,
             launcher_model()->ItemByID(item_id1)->status);
 
   // Close first app.
   CloseShellWindow(window1);
   --item_count;
   ASSERT_EQ(item_count, launcher_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(LauncherPlatformPerAppAppBrowserTest, WindowActivation) {
+IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest, WindowActivation) {
   int item_count = launcher_model()->item_count();
 
   // First run app.
   const Extension* extension1 = LoadAndLaunchPlatformApp("launch");
   ShellWindow* window1 = CreateShellWindow(extension1);
   ++item_count;
   ASSERT_EQ(item_count, launcher_model()->item_count());
   const ash::LauncherItem& item1 = GetLastLauncherItem();
   ash::LauncherID item_id1 = item1.id;
   EXPECT_EQ(ash::TYPE_PLATFORM_APP, item1.type);
@@ skipping 63 matching lines @@
   EXPECT_EQ(ash::STATUS_ACTIVE, launcher_model()->ItemByID(item_id1)->status);
 
   // Close first app.
   CloseShellWindow(window1b);
   CloseShellWindow(window1);
   --item_count;
   EXPECT_EQ(item_count, launcher_model()->item_count());
 }
 
 // Confirm that Click behavior for app windows is correnct.
-IN_PROC_BROWSER_TEST_F(LauncherPerAppAppBrowserNoMinimizeOnClick,
+IN_PROC_BROWSER_TEST_F(LauncherAppBrowserNoMinimizeOnClick,
                        AppClickBehavior) {
   // Launch a platform app and create a window for it.
   const Extension* extension1 = LoadAndLaunchPlatformApp("launch");
   ShellWindow* window1 = CreateShellWindow(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::LauncherItem& item1 = GetLastLauncherItem();
   LauncherItemController* item1_controller = GetItemController(item1.id);
   EXPECT_EQ(ash::TYPE_PLATFORM_APP, item1.type);
@@ skipping 17 matching lines @@
   // Maximizing a window should preserve state after minimize + click.
   window1->GetBaseWindow()->Maximize();
   window1->GetBaseWindow()->Minimize();
   item1_controller->Clicked(click_event);
   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(LauncherPerAppAppBrowserMinimizeOnClick,
+IN_PROC_BROWSER_TEST_F(LauncherAppBrowserMinimizeOnClick,
                        PackagedAppClickBehaviorInMinimizeMode) {
   // Launch one platform app and create a window for it.
   const Extension* extension1 = LoadAndLaunchPlatformApp("launch");
   ShellWindow* window1 = CreateShellWindow(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::LauncherItem& item1 = GetLastLauncherItem();
   LauncherItemController* item1_controller = GetItemController(item1.id);
@@ skipping 37 matching lines @@
   EXPECT_FALSE(window1a->GetBaseWindow()->IsActive());
   // The second neither.
   item1_controller->Clicked(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(LauncherPlatformPerAppAppBrowserTest,
-                       AppPanelClickBehavior) {
+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;
   params.focused = false;
   ShellWindow* panel = CreateShellWindowFromParams(extension1, params);
   EXPECT_TRUE(panel->GetNativeWindow()->IsVisible());
@@ skipping 14 matching lines @@
   item1_controller->Clicked(click_event);
   EXPECT_TRUE(panel->GetBaseWindow()->IsMinimized());
   EXPECT_EQ(ash::STATUS_RUNNING, item1.status);
   // Click the item again and confirm that the panel is activated.
   item1_controller->Clicked(click_event);
   EXPECT_TRUE(panel->GetNativeWindow()->IsVisible());
   EXPECT_TRUE(panel->GetBaseWindow()->IsActive());
   EXPECT_EQ(ash::STATUS_ACTIVE, item1.status);
 }
 
-IN_PROC_BROWSER_TEST_F(LauncherPlatformPerAppAppBrowserTest,
-    BrowserActivation) {
+IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest, BrowserActivation) {
   int item_count = launcher_model()->item_count();
 
   // First run app.
   const Extension* extension1 = LoadAndLaunchPlatformApp("launch");
   CreateShellWindow(extension1);
   ++item_count;
   ASSERT_EQ(item_count, launcher_model()->item_count());
   const ash::LauncherItem& item1 = GetLastLauncherItem();
   ash::LauncherID 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,
             launcher_model()->ItemByID(item_id1)->status);
 }
 
 // Test that opening an app sets the correct icon
-IN_PROC_BROWSER_TEST_F(LauncherPlatformPerAppAppBrowserTest, SetIcon) {
+IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest, SetIcon) {
   TestShellWindowRegistryObserver test_observer(browser()->profile());
 
   // Enable experimental APIs to allow panel creation.
   CommandLine::ForCurrentProcess()->AppendSwitch(
       extensions::switches::kEnableExperimentalExtensionApis);
 
   int base_launcher_item_count = launcher_model()->item_count();
   ExtensionTestMessageListener launched_listener("Launched", false);
   ExtensionTestMessageListener completed_listener("Completed", false);
   LoadAndLaunchPlatformApp("app_icon");
@@ skipping 24 matching lines @@
   // Icons for Apps are set by the ShellWindowLauncherController, so
   // image_set_by_controller() should be set.
   EXPECT_TRUE(app_item_controller->image_set_by_controller());
   EXPECT_TRUE(panel_item_controller->image_set_by_controller());
   // Ensure icon heights are correct (see test.js in app_icon/ test directory)
   EXPECT_EQ(48, app_item.image.height());
   EXPECT_EQ(64, panel_item.image.height());
 }
 
 // Test that we can launch an app with a shortcut.
-IN_PROC_BROWSER_TEST_F(LauncherPerAppAppBrowserTest, LaunchPinned) {
+IN_PROC_BROWSER_TEST_F(LauncherAppBrowserTest, LaunchPinned) {
   TabStripModel* tab_strip = browser()->tab_strip_model();
   int tab_count = tab_strip->count();
   ash::LauncherID shortcut_id = CreateShortcut("app1");
   EXPECT_EQ(ash::STATUS_CLOSED, (*model_->ItemByID(shortcut_id)).status);
   ActivateLauncherItem(model_->ItemIndexByID(shortcut_id));
   EXPECT_EQ(++tab_count, tab_strip->count());
   EXPECT_EQ(ash::STATUS_ACTIVE, (*model_->ItemByID(shortcut_id)).status);
   WebContents* tab = tab_strip->GetActiveWebContents();
   content::WindowedNotificationObserver close_observer(
       content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
       content::Source<WebContents>(tab));
   browser()->tab_strip_model()->CloseSelectedTabs();
   close_observer.Wait();
   EXPECT_EQ(--tab_count, tab_strip->count());
   EXPECT_EQ(ash::STATUS_CLOSED, (*model_->ItemByID(shortcut_id)).status);
 }
 
 // Launch the app first and then create the shortcut.
-IN_PROC_BROWSER_TEST_F(LauncherPerAppAppBrowserTest, LaunchUnpinned) {
+IN_PROC_BROWSER_TEST_F(LauncherAppBrowserTest, LaunchUnpinned) {
   TabStripModel* tab_strip = browser()->tab_strip_model();
   int tab_count = tab_strip->count();
   LoadAndLaunchExtension("app1", extension_misc::LAUNCH_TAB,
                          NEW_FOREGROUND_TAB);
   EXPECT_EQ(++tab_count, tab_strip->count());
   ash::LauncherID shortcut_id = CreateShortcut("app1");
   EXPECT_EQ(ash::STATUS_ACTIVE, (*model_->ItemByID(shortcut_id)).status);
   WebContents* tab = tab_strip->GetActiveWebContents();
   content::WindowedNotificationObserver close_observer(
       content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
       content::Source<WebContents>(tab));
   browser()->tab_strip_model()->CloseSelectedTabs();
   close_observer.Wait();
   EXPECT_EQ(--tab_count, tab_strip->count());
   EXPECT_EQ(ash::STATUS_CLOSED, (*model_->ItemByID(shortcut_id)).status);
 }
 
 // Launches an app in the background and then tries to open it. This is test for
 // a crash we had.
-IN_PROC_BROWSER_TEST_F(LauncherPerAppAppBrowserTest, LaunchInBackground) {
+IN_PROC_BROWSER_TEST_F(LauncherAppBrowserTest, LaunchInBackground) {
   TabStripModel* tab_strip = browser()->tab_strip_model();
   int tab_count = tab_strip->count();
   LoadAndLaunchExtension("app1", extension_misc::LAUNCH_TAB,
                          NEW_BACKGROUND_TAB);
   EXPECT_EQ(++tab_count, tab_strip->count());
   ChromeLauncherController::instance()->LaunchApp(last_loaded_extension_id_, 0);
 }
 
 // Confirm that clicking a icon for an app running in one of 2 maxmized windows
 // activates the right window.
-IN_PROC_BROWSER_TEST_F(LauncherPerAppAppBrowserTest, LaunchMaximized) {
+IN_PROC_BROWSER_TEST_F(LauncherAppBrowserTest, LaunchMaximized) {
   aura::Window* window1 = browser()->window()->GetNativeWindow();
   ash::wm::MaximizeWindow(window1);
   content::WindowedNotificationObserver open_observer(
       chrome::NOTIFICATION_BROWSER_WINDOW_READY,
       content::NotificationService::AllSources());
   chrome::NewEmptyWindow(browser()->profile(), chrome::HOST_DESKTOP_TYPE_ASH);
   open_observer.Wait();
   Browser* browser2 = content::Source<Browser>(open_observer.source()).ptr();
   aura::Window* window2 = browser2->window()->GetNativeWindow();
   TabStripModel* tab_strip = browser2->tab_strip_model();
   int tab_count = tab_strip->count();
   ash::wm::MaximizeWindow(window2);
 
   ash::LauncherID shortcut_id = CreateShortcut("app1");
   ActivateLauncherItem(model_->ItemIndexByID(shortcut_id));
   EXPECT_EQ(++tab_count, tab_strip->count());
   EXPECT_EQ(ash::STATUS_ACTIVE, (*model_->ItemByID(shortcut_id)).status);
 
   window1->Show();
   ash::wm::ActivateWindow(window1);
   EXPECT_EQ(ash::STATUS_RUNNING, (*model_->ItemByID(shortcut_id)).status);
 
   ActivateLauncherItem(model_->ItemIndexByID(shortcut_id));
   EXPECT_EQ(ash::STATUS_ACTIVE, (*model_->ItemByID(shortcut_id)).status);
 }
 
 // Activating the same app multiple times should launch only a single copy.
-IN_PROC_BROWSER_TEST_F(LauncherPerAppAppBrowserTest, ActivateApp) {
+IN_PROC_BROWSER_TEST_F(LauncherAppBrowserTest, ActivateApp) {
   TabStripModel* tab_strip = browser()->tab_strip_model();
   int tab_count = tab_strip->count();
   const Extension* extension =
       LoadExtension(test_data_dir_.AppendASCII("app1"));
 
   ChromeLauncherController::instance()->ActivateApp(extension->id(), 0);
   EXPECT_EQ(++tab_count, tab_strip->count());
   ChromeLauncherController::instance()->ActivateApp(extension->id(), 0);
   EXPECT_EQ(tab_count, tab_strip->count());
 }
 
 // Launching the same app multiple times should launch a copy for each call.
-IN_PROC_BROWSER_TEST_F(LauncherPerAppAppBrowserTest, LaunchApp) {
+IN_PROC_BROWSER_TEST_F(LauncherAppBrowserTest, LaunchApp) {
   TabStripModel* tab_strip = browser()->tab_strip_model();
   int tab_count = tab_strip->count();
   const Extension* extension =
       LoadExtension(test_data_dir_.AppendASCII("app1"));
 
   ChromeLauncherController::instance()->LaunchApp(extension->id(), 0);
   EXPECT_EQ(++tab_count, tab_strip->count());
   ChromeLauncherController::instance()->LaunchApp(extension->id(), 0);
   EXPECT_EQ(++tab_count, tab_strip->count());
 }
 
 // Launch 2 apps and toggle which is active.
-IN_PROC_BROWSER_TEST_F(LauncherPerAppAppBrowserTest, MultipleApps) {
+IN_PROC_BROWSER_TEST_F(LauncherAppBrowserTest, MultipleApps) {
   int item_count = model_->item_count();
   TabStripModel* tab_strip = browser()->tab_strip_model();
   int tab_count = tab_strip->count();
   ash::LauncherID shortcut1 = CreateShortcut("app1");
   EXPECT_EQ(++item_count, model_->item_count());
   ash::LauncherID shortcut2 = CreateShortcut("app2");
   EXPECT_EQ(++item_count, model_->item_count());
 
   // Launch first app.
   ActivateLauncherItem(model_->ItemIndexByID(shortcut1));
@@ skipping 36 matching lines @@
   // And second again. This time the second tab should become active.
   ActivateLauncherItem(model_->ItemIndexByID(shortcut2));
   EXPECT_EQ(tab_count, tab_strip->count());
   EXPECT_EQ(tab_strip->GetActiveWebContents(), tab2);
   EXPECT_EQ(ash::STATUS_RUNNING, (*model_->ItemByID(shortcut1)).status);
   EXPECT_EQ(ash::STATUS_ACTIVE, (*model_->ItemByID(shortcut2)).status);
 }
 
 // Confirm that a page can be navigated from and to while maintaining the
 // correct running state.
-IN_PROC_BROWSER_TEST_F(LauncherPerAppAppBrowserTest, Navigation) {
+IN_PROC_BROWSER_TEST_F(LauncherAppBrowserTest, Navigation) {
   ash::LauncherID shortcut_id = CreateShortcut("app1");
   EXPECT_EQ(ash::STATUS_CLOSED, (*model_->ItemByID(shortcut_id)).status);
   ActivateLauncherItem(model_->ItemIndexByID(shortcut_id));
   EXPECT_EQ(ash::STATUS_ACTIVE, (*model_->ItemByID(shortcut_id)).status);
 
   // Navigate away.
   ui_test_utils::NavigateToURL(
       browser(), GURL("http://www.example.com/path0/bar.html"));
   EXPECT_EQ(ash::STATUS_CLOSED, (*model_->ItemByID(shortcut_id)).status);
 
   // Navigate back.
   ui_test_utils::NavigateToURL(
       browser(), GURL("http://www.example.com/path1/foo.html"));
   EXPECT_EQ(ash::STATUS_ACTIVE, (*model_->ItemByID(shortcut_id)).status);
 }
 
-IN_PROC_BROWSER_TEST_F(LauncherPerAppAppBrowserTest, MultipleOwnedTabs) {
+IN_PROC_BROWSER_TEST_F(LauncherAppBrowserTest, MultipleOwnedTabs) {
   TabStripModel* tab_strip = browser()->tab_strip_model();
   int tab_count = tab_strip->count();
   ash::LauncherID shortcut_id = CreateShortcut("app1");
   ActivateLauncherItem(model_->ItemIndexByID(shortcut_id));
   EXPECT_EQ(++tab_count, tab_strip->count());
   EXPECT_EQ(ash::STATUS_ACTIVE, model_->ItemByID(shortcut_id)->status);
   WebContents* first_tab = tab_strip->GetActiveWebContents();
 
   // Create new tab owned by app.
   ui_test_utils::NavigateToURLWithDisposition(
@@ skipping 14 matching lines @@
   EXPECT_EQ(++tab_count, tab_strip->count());
   // No longer active.
   EXPECT_EQ(ash::STATUS_RUNNING, model_->ItemByID(shortcut_id)->status);
 
   // Activating app makes first tab active again.
   ActivateLauncherItem(model_->ItemIndexByID(shortcut_id));
   EXPECT_EQ(ash::STATUS_ACTIVE, model_->ItemByID(shortcut_id)->status);
   EXPECT_EQ(tab_strip->GetActiveWebContents(), first_tab);
 }
 
-IN_PROC_BROWSER_TEST_F(LauncherPerAppAppBrowserTest, RefocusFilter) {
-  ChromeLauncherController* controller =
-      static_cast<ChromeLauncherController*>(launcher_->delegate());
+IN_PROC_BROWSER_TEST_F(LauncherAppBrowserTest, RefocusFilter) {
   TabStripModel* tab_strip = browser()->tab_strip_model();
   int tab_count = tab_strip->count();
   ash::LauncherID shortcut_id = CreateShortcut("app1");
   ActivateLauncherItem(model_->ItemIndexByID(shortcut_id));
   EXPECT_EQ(++tab_count, tab_strip->count());
   EXPECT_EQ(ash::STATUS_ACTIVE, model_->ItemByID(shortcut_id)->status);
   WebContents* first_tab = tab_strip->GetActiveWebContents();
 
-  controller->SetRefocusURLPatternForTest(
+  controller_->SetRefocusURLPatternForTest(
       shortcut_id, GURL("http://www.example.com/path1/*"));
   // Create new tab owned by app.
   ui_test_utils::NavigateToURLWithDisposition(
       browser(),
       GURL("http://www.example.com/path2/bar.html"),
       NEW_FOREGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
   EXPECT_EQ(++tab_count, tab_strip->count());
   // Confirm app is still active.
   EXPECT_EQ(ash::STATUS_ACTIVE, model_->ItemByID(shortcut_id)->status);
 
   // Create new tab not owned by app.
   ui_test_utils::NavigateToURLWithDisposition(
       browser(),
       GURL("http://www.example.com/path3/foo.html"),
       NEW_FOREGROUND_TAB,
       0);
   EXPECT_EQ(++tab_count, tab_strip->count());
   // No longer active.
   EXPECT_EQ(ash::STATUS_RUNNING, model_->ItemByID(shortcut_id)->status);
 
   // Activating app makes first tab active again, because second tab isn't
   // in its refocus url path.
   ActivateLauncherItem(model_->ItemIndexByID(shortcut_id));
   EXPECT_EQ(ash::STATUS_ACTIVE, model_->ItemByID(shortcut_id)->status);
   EXPECT_EQ(tab_strip->GetActiveWebContents(), first_tab);
 }
 
-IN_PROC_BROWSER_TEST_F(LauncherPerAppAppBrowserTest, RefocusFilterLaunch) {
-  ChromeLauncherController* controller =
-      static_cast<ChromeLauncherController*>(launcher_->delegate());
+IN_PROC_BROWSER_TEST_F(LauncherAppBrowserTest, RefocusFilterLaunch) {
   TabStripModel* tab_strip = browser()->tab_strip_model();
   int tab_count = tab_strip->count();
   ash::LauncherID shortcut_id = CreateShortcut("app1");
-  controller->SetRefocusURLPatternForTest(
+  controller_->SetRefocusURLPatternForTest(
       shortcut_id, GURL("http://www.example.com/path1/*"));
 
   // Create new tab.
   ui_test_utils::NavigateToURLWithDisposition(
       browser(),
       GURL("http://www.example2.com/path2/bar.html"),
       NEW_FOREGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
   EXPECT_EQ(++tab_count, tab_strip->count());
   WebContents* first_tab = tab_strip->GetActiveWebContents();
   // Confirm app is not active.
   EXPECT_EQ(ash::STATUS_CLOSED, model_->ItemByID(shortcut_id)->status);
 
   // Activating app should launch new tab, because second tab isn't
   // in its refocus url path.
   ActivateLauncherItem(model_->ItemIndexByID(shortcut_id));
   EXPECT_EQ(++tab_count, tab_strip->count());
   WebContents* second_tab = tab_strip->GetActiveWebContents();
   EXPECT_EQ(ash::STATUS_ACTIVE, model_->ItemByID(shortcut_id)->status);
   EXPECT_NE(first_tab, second_tab);
   EXPECT_EQ(tab_strip->GetActiveWebContents(), second_tab);
 }
 
 // Check the launcher activation state for applications and browser.
-IN_PROC_BROWSER_TEST_F(LauncherPerAppAppBrowserTest, ActivationStateCheck) {
-  ChromeLauncherController* controller =
-      static_cast<ChromeLauncherController*>(launcher_->delegate());
+IN_PROC_BROWSER_TEST_F(LauncherAppBrowserTest, ActivationStateCheck) {
   TabStripModel* tab_strip = browser()->tab_strip_model();
   // Get the browser item index
-  int browser_index = ash::launcher::GetBrowserItemIndex(*controller->model());
+  int browser_index = ash::launcher::GetBrowserItemIndex(*controller_->model());
   EXPECT_TRUE(browser_index >= 0);
 
   // Even though we are just comming up, the browser should be active.
   EXPECT_EQ(ash::STATUS_ACTIVE, model_->items()[browser_index].status);
 
   ash::LauncherID shortcut_id = CreateShortcut("app1");
-  controller->SetRefocusURLPatternForTest(
+  controller_->SetRefocusURLPatternForTest(
       shortcut_id, GURL("http://www.example.com/path1/*"));
 
   EXPECT_EQ(ash::STATUS_CLOSED, model_->ItemByID(shortcut_id)->status);
   EXPECT_EQ(ash::STATUS_ACTIVE, model_->items()[browser_index].status);
 
   // Create new tab which would be the running app.
   ui_test_utils::NavigateToURLWithDisposition(
       browser(),
       GURL("http://www.example.com/path1/bar.html"),
       NEW_FOREGROUND_TAB,
@@ skipping 12 matching lines @@
   EXPECT_EQ(ash::STATUS_ACTIVE, model_->items()[browser_index].status);
 
   ash::wm::DeactivateWindow(browser()->window()->GetNativeWindow());
   EXPECT_EQ(ash::STATUS_CLOSED, model_->ItemByID(shortcut_id)->status);
   EXPECT_EQ(ash::STATUS_RUNNING, model_->items()[browser_index].status);
 }
 
 // Check that the launcher activation state for a V1 application stays closed
 // even after an asynchronous browser event comes in after the tab got
 // destroyed.
-IN_PROC_BROWSER_TEST_F(LauncherPerAppAppBrowserTest,
-                       AsyncActivationStateCheck) {
-  ChromeLauncherController* controller =
-      static_cast<ChromeLauncherController*>(launcher_->delegate());
+IN_PROC_BROWSER_TEST_F(LauncherAppBrowserTest, AsyncActivationStateCheck) {
   TabStripModel* tab_strip = browser()->tab_strip_model();
 
   ash::LauncherID shortcut_id = CreateShortcut("app1");
-  controller->SetRefocusURLPatternForTest(
+  controller_->SetRefocusURLPatternForTest(
       shortcut_id, GURL("http://www.example.com/path1/*"));
 
   EXPECT_EQ(ash::STATUS_CLOSED, model_->ItemByID(shortcut_id)->status);
 
   // Create new tab which would be the running app.
   ui_test_utils::NavigateToURLWithDisposition(
       browser(),
       GURL("http://www.example.com/path1/bar.html"),
       NEW_FOREGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 
   EXPECT_EQ(ash::STATUS_ACTIVE, model_->ItemByID(shortcut_id)->status);
   // To address the issue of crbug.com/174050, the tab we are about to close
   // has to be active.
   tab_strip->ActivateTabAt(1, false);
   EXPECT_EQ(1, tab_strip->active_index());
 
   // Close the web contents.
   tab_strip->CloseWebContentsAt(1, TabStripModel::CLOSE_NONE);
   // The status should now be set to closed.
   EXPECT_EQ(ash::STATUS_CLOSED, model_->ItemByID(shortcut_id)->status);
 }
 
 // Checks that a windowed application does not add an item to the browser list.
-IN_PROC_BROWSER_TEST_F(LauncherPerAppAppBrowserTestNoDefaultBrowser,
+IN_PROC_BROWSER_TEST_F(LauncherAppBrowserTestNoDefaultBrowser,
     WindowedAppDoesNotAddToBrowser) {
   // Get the number of items in the browser menu.
   size_t items = NumberOfDetectedLauncherBrowsers(false);
   size_t running_browser = chrome::GetTotalBrowserCount();
   EXPECT_EQ(0u, items);
   EXPECT_EQ(0u, running_browser);
 
   LoadAndLaunchExtension("app1", extension_misc::LAUNCH_WINDOW, NEW_WINDOW);
 
   // No new browser should get detected, even though one more is running.
   EXPECT_EQ(0u, NumberOfDetectedLauncherBrowsers(false));
   EXPECT_EQ(++running_browser, chrome::GetTotalBrowserCount());
 
   LoadAndLaunchExtension("app1", extension_misc::LAUNCH_TAB, NEW_WINDOW);
 
   // A new browser should get detected and one more should be running.
   EXPECT_EQ(NumberOfDetectedLauncherBrowsers(false), 1u);
   EXPECT_EQ(++running_browser, chrome::GetTotalBrowserCount());
 }
 
 // Checks the functionality to enumerate all browsers vs. all tabs.
-IN_PROC_BROWSER_TEST_F(LauncherPerAppAppBrowserTestNoDefaultBrowser,
+IN_PROC_BROWSER_TEST_F(LauncherAppBrowserTestNoDefaultBrowser,
     EnumerateALlBrowsersAndTabs) {
   // Create at least one browser.
   LoadAndLaunchExtension("app1", extension_misc::LAUNCH_TAB, NEW_WINDOW);
   size_t browsers = NumberOfDetectedLauncherBrowsers(false);
   size_t tabs = NumberOfDetectedLauncherBrowsers(true);
 
   // Create a second browser.
   LoadAndLaunchExtension("app1", extension_misc::LAUNCH_TAB, NEW_WINDOW);
 
   EXPECT_EQ(++browsers, NumberOfDetectedLauncherBrowsers(false));
   EXPECT_EQ(++tabs, NumberOfDetectedLauncherBrowsers(true));
 
   // Create only a tab.
   LoadAndLaunchExtension("app1",
                          extension_misc::LAUNCH_TAB,
                          NEW_FOREGROUND_TAB);
 
   EXPECT_EQ(browsers, NumberOfDetectedLauncherBrowsers(false));
   EXPECT_EQ(++tabs, NumberOfDetectedLauncherBrowsers(true));
 }
 
 // Check that the keyboard activation of a launcher item tabs properly through
 // the items at hand.
-IN_PROC_BROWSER_TEST_F(LauncherPerAppAppBrowserTest, AltNumberTabsTabbing) {
+IN_PROC_BROWSER_TEST_F(LauncherAppBrowserTest, AltNumberTabsTabbing) {
   TabStripModel* tab_strip = browser()->tab_strip_model();
-  ChromeLauncherController* controller =
-      static_cast<ChromeLauncherController*>(launcher_->delegate());
 
   ash::LauncherID shortcut_id = CreateShortcut("app");
-  controller->SetRefocusURLPatternForTest(
+  controller_->SetRefocusURLPatternForTest(
       shortcut_id, GURL("http://www.example.com/path/*"));
   std::string url = "http://www.example.com/path/bla";
 
   int shortcut_index = model_->ItemIndexByID(shortcut_id);
 
   // Create an application handled browser tab.
   ui_test_utils::NavigateToURLWithDisposition(
       browser(),
       GURL(url),
       NEW_FOREGROUND_TAB,
@@ skipping 29 matching lines @@
 
   EXPECT_EQ(content2, browser()->tab_strip_model()->GetActiveWebContents());
   ActivateLauncherItem(shortcut_index);
   EXPECT_EQ(content1, browser()->tab_strip_model()->GetActiveWebContents());
   ActivateLauncherItem(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(LauncherPlatformPerAppAppBrowserTest,
+IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest,
                        AltNumberAppsTabbing) {
   // First run app.
   const Extension* extension1 = LoadAndLaunchPlatformApp("launch");
   ui::BaseWindow* window1 = CreateShellWindow(extension1)->GetBaseWindow();
   const ash::LauncherItem& item1 = GetLastLauncherItem();
   ash::LauncherID app_id = item1.id;
   int app_index = launcher_model()->ItemIndexByID(app_id);
 
   EXPECT_EQ(ash::TYPE_PLATFORM_APP, item1.type);
   EXPECT_EQ(ash::STATUS_ACTIVE, item1.status);
@@ skipping 12 matching lines @@
   ui::BaseWindow* window1a = CreateShellWindow(extension1)->GetBaseWindow();
 
   EXPECT_TRUE(window1a->IsActive());
   EXPECT_FALSE(window1->IsActive());
   ActivateLauncherItem(app_index);
   EXPECT_TRUE(window1->IsActive());
   ActivateLauncherItem(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 = launcher_model()->item_count();
+  const Extension* extension = LoadAndLaunchPlatformApp("launch");
+  ShellWindow::CreateParams params;
+  params.window_type = ShellWindow::WINDOW_TYPE_PANEL;
+  params.focused = false;
+  ShellWindow* window = CreateShellWindowFromParams(extension, params);
+  ++item_count;
+  ASSERT_EQ(item_count, launcher_model()->item_count());
+  const ash::LauncherItem& 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);
+  --item_count;
+  EXPECT_EQ(item_count, launcher_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;
+  params.focused = false;
+  ShellWindow* panel = CreateShellWindowFromParams(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::LauncherItem& 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());
+
+  // App windows should go to attention state.
+  panel->GetNativeWindow()->SetProperty(aura::client::kDrawAttentionKey, true);
+  EXPECT_EQ(ash::STATUS_ATTENTION, item.status);
+
+  // Click the item and confirm that the panel is activated.
+  TestEvent click_event(ui::ET_MOUSE_PRESSED);
+  item_controller->Clicked(click_event);
+  EXPECT_TRUE(panel->GetBaseWindow()->IsActive());
+  EXPECT_EQ(ash::STATUS_ACTIVE, item.status);
+
+  // Active windows don't show attention.
+  panel->GetNativeWindow()->SetProperty(aura::client::kDrawAttentionKey, true);
+  EXPECT_EQ(ash::STATUS_ACTIVE, item.status);
+}
+
 // Checks that the browser Alt "tabbing" is properly done.
-IN_PROC_BROWSER_TEST_F(LauncherPerAppAppBrowserTestNoDefaultBrowser,
+IN_PROC_BROWSER_TEST_F(LauncherAppBrowserTestNoDefaultBrowser,
     AltNumberBrowserTabbing) {
   // Get the number of items in the browser menu.
   EXPECT_EQ(0u, chrome::GetTotalBrowserCount());
   // The first activation should create a browser.
   launcher_->ActivateLauncherItem(0);
   EXPECT_EQ(1u, chrome::GetTotalBrowserCount());
   // A second activation should not create a new instance.
   launcher_->ActivateLauncherItem(0);
   Browser* browser1 = chrome::FindBrowserWithWindow(ash::wm::GetActiveWindow());
   EXPECT_TRUE(browser1);
@@ skipping 35 matching lines @@
   EXPECT_NE(window1, ash::wm::GetActiveWindow());
   EXPECT_NE(window2, ash::wm::GetActiveWindow());
 
   // After activation our browser should be active again.
   launcher_->ActivateLauncherItem(0);
   EXPECT_EQ(window1, ash::wm::GetActiveWindow());
 }
 
 // Checks that after a session restore, we do not start applications on an
 // activation.
-IN_PROC_BROWSER_TEST_F(LauncherPerAppAppBrowserTest,
-    ActivateAfterSessionRestore) {
+IN_PROC_BROWSER_TEST_F(LauncherAppBrowserTest, ActivateAfterSessionRestore) {
   EXPECT_EQ(1u, chrome::GetTotalBrowserCount());
 
   // Create a known application.
-  ChromeLauncherController* controller =
-      static_cast<ChromeLauncherController*>(launcher_->delegate());
   ash::LauncherID shortcut_id = CreateShortcut("app1");
 
   // Create a new browser - without activating it - and load an "app" into it.
   Browser::CreateParams params =
       Browser::CreateParams(profile(), chrome::GetActiveDesktop());
   params.initial_show_state = ui::SHOW_STATE_INACTIVE;
   Browser* browser2 = new Browser(params);
-  controller->SetRefocusURLPatternForTest(
+  controller_->SetRefocusURLPatternForTest(
       shortcut_id, GURL("http://www.example.com/path/*"));
   std::string url = "http://www.example.com/path/bla";
   ui_test_utils::NavigateToURLWithDisposition(
       browser2,
       GURL(url),
       NEW_FOREGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 
   // Remember the number of tabs for each browser.
   TabStripModel* tab_strip = browser()->tab_strip_model();
   int tab_count1 = tab_strip->count();
   TabStripModel* tab_strip2 = browser2->tab_strip_model();
   int tab_count2 = tab_strip2->count();
 
   // Check that we have two browsers and the inactive browser remained inactive.
   EXPECT_EQ(2u, chrome::GetTotalBrowserCount());
   EXPECT_EQ(chrome::FindBrowserWithWindow(ash::wm::GetActiveWindow()),
             browser());
   // Check that the LRU browser list does only contain the original browser.
   BrowserList* ash_browser_list =
       BrowserList::GetInstance(chrome::HOST_DESKTOP_TYPE_ASH);
   BrowserList::const_reverse_iterator it =
       ash_browser_list->begin_last_active();
   EXPECT_EQ(*it, browser());
   ++it;
   EXPECT_EQ(it, ash_browser_list->end_last_active());
 
   // Now request to either activate an existing app or create a new one.
-  controller->ItemSelected(*model_->ItemByID(shortcut_id),
+  controller_->ItemSelected(*model_->ItemByID(shortcut_id),
                            ui::KeyEvent(ui::ET_KEY_RELEASED,
                                         ui::VKEY_RETURN,
                                         0,
                                         false));
 
   // Check that we have set focus on the existing application and nothing new
   // was created.
   EXPECT_EQ(2u, chrome::GetTotalBrowserCount());
   EXPECT_EQ(tab_count1, tab_strip->count());
   EXPECT_EQ(tab_count2, tab_strip2->count());
   EXPECT_EQ(chrome::FindBrowserWithWindow(ash::wm::GetActiveWindow()),
             browser2);
 }
 
 // Do various drag and drop interaction tests between the application list and
 // the launcher.
-IN_PROC_BROWSER_TEST_F(LauncherPerAppAppBrowserTest, DragAndDrop) {
+IN_PROC_BROWSER_TEST_F(LauncherAppBrowserTest, DragAndDrop) {
   // Get a number of interfaces we need.
   aura::test::EventGenerator generator(
       ash::Shell::GetPrimaryRootWindow(), gfx::Point());
   ash::test::LauncherViewTestAPI test(launcher_->GetLauncherViewForTest());
   AppListService* service = AppListService::Get();
 
   // There should be two items in our launcher by this time.
   EXPECT_EQ(2, model_->item_count());
   EXPECT_FALSE(service->IsAppListVisible());
 
@@ skipping 84 matching lines @@
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(3, model_->item_count());  // No new item got added.
   EXPECT_TRUE(grid_view->forward_events_to_drag_and_drop_host_for_test());
   generator.ReleaseLeftButton();
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_FALSE(grid_view->forward_events_to_drag_and_drop_host_for_test());
   EXPECT_EQ(3, model_->item_count());  // And it remains that way.
 }
 
 // Check that clicking on an app launcher item launches a new browser.
-IN_PROC_BROWSER_TEST_F(LauncherPerAppAppBrowserTest, ClickItem) {
+IN_PROC_BROWSER_TEST_F(LauncherAppBrowserTest, ClickItem) {
   // Get a number of interfaces we need.
   aura::test::EventGenerator generator(
       ash::Shell::GetPrimaryRootWindow(), gfx::Point());
   ash::test::LauncherViewTestAPI test(launcher_->GetLauncherViewForTest());
   AppListService* service = AppListService::Get();
   // There should be two items in our launcher by this time.
   EXPECT_EQ(2, model_->item_count());
   EXPECT_FALSE(service->IsAppListVisible());
 
   // Open the app list menu and check that the drag and drop host was set.
@@ skipping 15 matching lines @@
   TabStripModel* tab_strip = browser()->tab_strip_model();
   int tab_count = tab_strip->count();
   generator.MoveMouseTo(bounds_grid_1.CenterPoint().x(),
                         bounds_grid_1.CenterPoint().y());
   generator.ClickLeftButton();
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(tab_count + 1, tab_strip->count());
 }
 
 // Check LauncherItemController of Browser Shortcut functionality.
-IN_PROC_BROWSER_TEST_F(LauncherPerAppAppBrowserTestNoDefaultBrowser,
+IN_PROC_BROWSER_TEST_F(LauncherAppBrowserTestNoDefaultBrowser,
     BrowserShortcutLauncherItemController) {
-  ChromeLauncherControllerPerApp* controller =
-      static_cast<ChromeLauncherControllerPerApp*>(launcher_->delegate());
   LauncherItemController* item_controller =
-      controller->GetBrowserShortcutLauncherItemController();
+      controller_->GetBrowserShortcutLauncherItemController();
 
   // Get the number of browsers.
   size_t running_browser = chrome::GetTotalBrowserCount();
   EXPECT_EQ(0u, running_browser);
   EXPECT_FALSE(item_controller->IsOpen());
 
   // Activate. This creates new browser
   item_controller->Activate();
   // New Window is created.
   running_browser = chrome::GetTotalBrowserCount();
   EXPECT_EQ(1u, running_browser);
   EXPECT_TRUE(item_controller->IsOpen());
 
   // Minimize Window.
   aura::Window* window = ash::wm::GetActiveWindow();
   ash::wm::MinimizeWindow(window);
   EXPECT_TRUE(ash::wm::IsWindowMinimized(window));
 
   // Activate again. This doesn't create new browser.
   // It activates window.
   item_controller->Activate();
   running_browser = chrome::GetTotalBrowserCount();
   EXPECT_EQ(1u, running_browser);
   EXPECT_TRUE(item_controller->IsOpen());
   EXPECT_FALSE(ash::wm::IsWindowMinimized(window));
 }
 
 // Check that GetIDByWindow() returns |LauncherID| of the active tab.
-IN_PROC_BROWSER_TEST_F(LauncherPerAppAppBrowserTest,
-    MatchingLauncherIDandActiveTab)  {
-  ChromeLauncherControllerPerApp* controller =
-      static_cast<ChromeLauncherControllerPerApp*>(launcher_->delegate());
-
+IN_PROC_BROWSER_TEST_F(LauncherAppBrowserTest, MatchingLauncherIDandActiveTab) {
   EXPECT_EQ(1u, chrome::GetTotalBrowserCount());
   EXPECT_EQ(1, browser()->tab_strip_model()->count());
   EXPECT_EQ(0, browser()->tab_strip_model()->active_index());
   EXPECT_EQ(2, model_->item_count());
 
   aura::Window* window = browser()->window()->GetNativeWindow();
 
   int browser_index = ash::launcher::GetBrowserItemIndex(*model_);
   ash::LauncherID browser_id = model_->items()[browser_index].id;
-  EXPECT_EQ(browser_id, controller->GetIDByWindow(window));
+  EXPECT_EQ(browser_id, controller_->GetIDByWindow(window));
 
   ash::LauncherID app_id = CreateShortcut("app1");
   EXPECT_EQ(3, model_->item_count());
 
   // Creates a new tab for "app1" and checks that GetIDByWindow() returns
   // |LauncherID| of "app1".
   ActivateLauncherItem(model_->ItemIndexByID(app_id));
   EXPECT_EQ(2, browser()->tab_strip_model()->count());
   EXPECT_EQ(1, browser()->tab_strip_model()->active_index());
-  EXPECT_EQ(app_id, controller->GetIDByWindow(window));
+  EXPECT_EQ(app_id, controller_->GetIDByWindow(window));
 
   // Makes tab at index 0(NTP) as an active tab and checks that GetIDByWindow()
   // returns |LauncherID| of browser shortcut.
   browser()->tab_strip_model()->ActivateTabAt(0, false);
   EXPECT_EQ(0, browser()->tab_strip_model()->active_index());
-  EXPECT_EQ(browser_id, controller->GetIDByWindow(window));
+  EXPECT_EQ(browser_id, controller_->GetIDByWindow(window));
 }
+
+IN_PROC_BROWSER_TEST_F(LauncherAppBrowserTest, OverflowBubble) {
+  // Make sure to have a browser window
+  chrome::NewTab(browser());
+
+  // No overflow yet.
+  EXPECT_FALSE(launcher_->IsShowingOverflowBubble());
+
+  ash::test::LauncherViewTestAPI test(launcher_->GetLauncherViewForTest());
+
+  int items_added = 0;
+  while (!test.IsOverflowButtonVisible()) {
+    std::string fake_app_id = base::StringPrintf("fake_app_%d", items_added);
+    PinFakeApp(fake_app_id);
+
+    ++items_added;
+    ASSERT_LT(items_added, 10000);
+  }
+
+  // Now show overflow bubble.
+  test.ShowOverflowBubble();
+  EXPECT_TRUE(launcher_->IsShowingOverflowBubble());
+
+  // Unpin first pinned app and there should be no crash.
+  controller_->UnpinAppsWithID(std::string("fake_app_0"));
+
+  test.RunMessageLoopUntilAnimationsDone();
+  EXPECT_FALSE(launcher_->IsShowingOverflowBubble());
+}