Fixing activation states from the new launcher. Also adding a whole bunch of unit tests for the new…

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 "ash/ash_switches.h"
 #include "ash/launcher/launcher.h"
 #include "ash/launcher/launcher_model.h"
 #include "ash/shell.h"
 #include "ash/test/shell_test_api.h"
 #include "ash/wm/window_util.h"
 #include "base/command_line.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/automation/automation_util.h"
 #include "chrome/browser/extensions/extension_apitest.h"
 #include "chrome/browser/extensions/extension_browsertest.h"
@@ skipping 16 matching lines @@
 #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 "testing/gtest/include/gtest/gtest.h"
 #include "ui/aura/window.h"
 
 using extensions::Extension;
 using content::WebContents;
 
-class LauncherPlatformAppBrowserTest
+// TODO(skuhne): Change name back to LauncherPlatformAppBrowserTest when the
+// old launcher gets ripped out.
+class LauncherPlatformPerAppAppBrowserTest
     : public extensions::PlatformAppBrowserTest {
  protected:
-  LauncherPlatformAppBrowserTest()
+  LauncherPlatformPerAppAppBrowserTest()
       : launcher_(NULL),
         controller_(NULL) {
   }
 
-  virtual ~LauncherPlatformAppBrowserTest() {}
+  virtual ~LauncherPlatformPerAppAppBrowserTest() {}
+  // TODO(skuhne): Remove when the old launcher gets removed.
+  virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
+    PlatformAppBrowserTest::SetUpCommandLine(command_line);
+    command_line->AppendSwitch(ash::switches::kAshEnablePerAppLauncher);
+  }
 
   ash::LauncherModel* launcher_model() {
     return ash::test::ShellTestApi(ash::Shell::GetInstance()).launcher_model();
   }
 
   virtual void RunTestOnMainThreadLoop() {
     launcher_ = ash::Launcher::ForPrimaryDisplay();
     controller_ = static_cast<ChromeLauncherController*>(launcher_->delegate());
     return extensions::PlatformAppBrowserTest::RunTestOnMainThreadLoop();
   }
 
   ash::LauncherID CreateAppShortcutLauncherItem(const std::string& name) {
     return controller_->CreateAppShortcutLauncherItem(
         name, controller_->model()->item_count());
   }
 
   ash::Launcher* launcher_;
   ChromeLauncherController* controller_;
 };
 
-class LauncherAppBrowserTest : public ExtensionBrowserTest {
+// TODO(skuhne): Change name back to LauncherAppBrowserTest when the
+// old launcher gets ripped out.
+class LauncherPerAppAppBrowserTest : public ExtensionBrowserTest {
  protected:
-  LauncherAppBrowserTest()
+  LauncherPerAppAppBrowserTest()
       : launcher_(NULL),
         model_(NULL) {
   }
 
-  virtual ~LauncherAppBrowserTest() {}
+  virtual ~LauncherPerAppAppBrowserTest() {}
+
+  // TODO(skuhne): Remove when the old launcher gets removed.
+  virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
+    ExtensionBrowserTest::SetUpCommandLine(command_line);
+    command_line->AppendSwitch(ash::switches::kAshEnablePerAppLauncher);
+  }
 
   virtual void RunTestOnMainThreadLoop() {
     launcher_ = ash::Launcher::ForPrimaryDisplay();
     model_ =
         ash::test::ShellTestApi(ash::Shell::GetInstance()).launcher_model();
     return ExtensionBrowserTest::RunTestOnMainThreadLoop();
   }
 
   const Extension* LoadAndLaunchExtension(
       const char* name,
@@ skipping 33 matching lines @@
     ash::LauncherItem item = *model_->ItemByID(shortcut_id);
     EXPECT_EQ(ash::TYPE_APP_SHORTCUT, item.type);
     return item.id;
   }
 
   ash::Launcher* launcher_;
   ash::LauncherModel* model_;
 };
 
 // Test that we can launch a platform app and get a running item.
-IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest, LaunchUnpinned) {
+IN_PROC_BROWSER_TEST_F(LauncherPlatformPerAppAppBrowserTest, 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());
   ash::LauncherItem item =
       launcher_model()->items()[launcher_model()->item_count() - 2];
   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(LauncherPlatformAppBrowserTest, LaunchPinned) {
+IN_PROC_BROWSER_TEST_F(LauncherPlatformPerAppAppBrowserTest, 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(LauncherPlatformAppBrowserTest, PinRunning) {
+IN_PROC_BROWSER_TEST_F(LauncherPlatformPerAppAppBrowserTest, 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());
   ash::LauncherItem item =
       launcher_model()->items()[launcher_model()->item_count() - 2];
   ash::LauncherID id = item.id;
   EXPECT_EQ(ash::TYPE_PLATFORM_APP, item.type);
@@ skipping 18 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(LauncherPlatformAppBrowserTest, UnpinRunning) {
+IN_PROC_BROWSER_TEST_F(LauncherPlatformPerAppAppBrowserTest, 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(LauncherPlatformAppBrowserTest, MultipleWindows) {
+IN_PROC_BROWSER_TEST_F(LauncherPlatformPerAppAppBrowserTest, 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());
   ash::LauncherItem item =
       launcher_model()->items()[launcher_model()->item_count() - 2];
   ash::LauncherID item_id = item.id;
@@ skipping 14 matching lines @@
   item = *launcher_model()->ItemByID(item_id);
   EXPECT_EQ(ash::STATUS_ACTIVE, item.status);
 
   // Close first window.
   CloseShellWindow(window1);
   // Confirm item is removed.
   --item_count;
   ASSERT_EQ(item_count, launcher_model()->item_count());
 }
 
-IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest, MultipleApps) {
+IN_PROC_BROWSER_TEST_F(LauncherPlatformPerAppAppBrowserTest, 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());
   ash::LauncherItem item1 =
       launcher_model()->items()[launcher_model()->item_count() - 2];
   ash::LauncherID item_id1 = item1.id;
@@ skipping 25 matching lines @@
 
   // 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(LauncherPlatformAppBrowserTest, WindowActivation) {
+IN_PROC_BROWSER_TEST_F(LauncherPlatformPerAppAppBrowserTest, 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());
   ash::LauncherItem item1 =
       launcher_model()->items()[launcher_model()->item_count() - 2];
   ash::LauncherID item_id1 = item1.id;
@@ skipping 65 matching lines @@
   // First app should be active again.
   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());
 }
 
-IN_PROC_BROWSER_TEST_F(LauncherPlatformAppBrowserTest, BrowserActivation) {
+IN_PROC_BROWSER_TEST_F(LauncherPlatformPerAppAppBrowserTest,
+    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());
   ash::LauncherItem item1 =
       launcher_model()->items()[launcher_model()->item_count() - 2];
   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 we can launch an app with a shortcut.
-IN_PROC_BROWSER_TEST_F(LauncherAppBrowserTest, LaunchPinned) {
+IN_PROC_BROWSER_TEST_F(LauncherPerAppAppBrowserTest, 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);
   launcher_->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(LauncherAppBrowserTest, LaunchUnpinned) {
+IN_PROC_BROWSER_TEST_F(LauncherPerAppAppBrowserTest, 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(LauncherAppBrowserTest, LaunchInBackground) {
+IN_PROC_BROWSER_TEST_F(LauncherPerAppAppBrowserTest, 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(LauncherAppBrowserTest, LaunchMaximized) {
+IN_PROC_BROWSER_TEST_F(LauncherPerAppAppBrowserTest, 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());
   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");
   launcher_->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);
 
   launcher_->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(LauncherAppBrowserTest, ActivateApp) {
+IN_PROC_BROWSER_TEST_F(LauncherPerAppAppBrowserTest, 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(LauncherAppBrowserTest, LaunchApp) {
+IN_PROC_BROWSER_TEST_F(LauncherPerAppAppBrowserTest, 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(LauncherAppBrowserTest, MultipleApps) {
+IN_PROC_BROWSER_TEST_F(LauncherPerAppAppBrowserTest, 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.
   launcher_->ActivateLauncherItem(model_->ItemIndexByID(shortcut1));
@@ skipping 16 matching lines @@
   EXPECT_EQ(ash::STATUS_ACTIVE, (*model_->ItemByID(shortcut1)).status);
   EXPECT_EQ(ash::STATUS_RUNNING, (*model_->ItemByID(shortcut2)).status);
 
   // Open second tab for second app. This should activate it.
   ui_test_utils::NavigateToURLWithDisposition(
       browser(),
       GURL("http://www.example.com/path3/foo.html"),
       NEW_FOREGROUND_TAB,
       0);
   EXPECT_EQ(++tab_count, tab_strip->count());
-  WebContents* tab3 = tab_strip->GetActiveWebContents();
   EXPECT_EQ(ash::STATUS_RUNNING, (*model_->ItemByID(shortcut1)).status);
   EXPECT_EQ(ash::STATUS_ACTIVE, (*model_->ItemByID(shortcut2)).status);
 
   // Reactivate first app.
   launcher_->ActivateLauncherItem(model_->ItemIndexByID(shortcut1));
   EXPECT_EQ(tab_count, tab_strip->count());
   EXPECT_EQ(tab_strip->GetActiveWebContents(), tab1);
   EXPECT_EQ(ash::STATUS_ACTIVE, (*model_->ItemByID(shortcut1)).status);
   EXPECT_EQ(ash::STATUS_RUNNING, (*model_->ItemByID(shortcut2)).status);
 
   // And second again. This time the second tab should become active.
   launcher_->ActivateLauncherItem(model_->ItemIndexByID(shortcut2));
   EXPECT_EQ(tab_count, tab_strip->count());
-  EXPECT_EQ(tab_strip->GetActiveWebContents(), tab3);
+  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(LauncherAppBrowserTest, Navigation) {
+IN_PROC_BROWSER_TEST_F(LauncherPerAppAppBrowserTest, Navigation) {
   ash::LauncherID shortcut_id = CreateShortcut("app1");
   EXPECT_EQ(ash::STATUS_CLOSED, (*model_->ItemByID(shortcut_id)).status);
   launcher_->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(LauncherAppBrowserTest, MultipleOwnedTabs) {
+IN_PROC_BROWSER_TEST_F(LauncherPerAppAppBrowserTest, MultipleOwnedTabs) {
   TabStripModel* tab_strip = browser()->tab_strip_model();
   int tab_count = tab_strip->count();
   ash::LauncherID shortcut_id = CreateShortcut("app1");
   launcher_->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(
       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);
-  WebContents* second_tab = tab_strip->GetActiveWebContents();
 
   // 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 second tab active again.
+  // Activating app makes first tab active again.
   launcher_->ActivateLauncherItem(model_->ItemIndexByID(shortcut_id));
   EXPECT_EQ(ash::STATUS_ACTIVE, model_->ItemByID(shortcut_id)->status);
-  EXPECT_EQ(tab_strip->GetActiveWebContents(), second_tab);
+  EXPECT_EQ(tab_strip->GetActiveWebContents(), first_tab);
 }
 
-IN_PROC_BROWSER_TEST_F(LauncherAppBrowserTest, RefocusFilter) {
+IN_PROC_BROWSER_TEST_F(LauncherPerAppAppBrowserTest, RefocusFilter) {
   ChromeLauncherController* controller =
       static_cast<ChromeLauncherController*>(launcher_->delegate());
   TabStripModel* tab_strip = browser()->tab_strip_model();
   int tab_count = tab_strip->count();
   ash::LauncherID shortcut_id = CreateShortcut("app1");
   launcher_->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();
 
@@ skipping 19 matching lines @@
   // 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.
   launcher_->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(LauncherAppBrowserTest, RefocusFilterLaunch) {
+IN_PROC_BROWSER_TEST_F(LauncherPerAppAppBrowserTest, RefocusFilterLaunch) {
   ChromeLauncherController* controller =
       static_cast<ChromeLauncherController*>(launcher_->delegate());
   TabStripModel* tab_strip = browser()->tab_strip_model();
   int tab_count = tab_strip->count();
   ash::LauncherID shortcut_id = CreateShortcut("app1");
   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());
   WebContents* first_tab = tab_strip->GetActiveWebContents();
   // Confirm app is active.
   EXPECT_EQ(ash::STATUS_ACTIVE, model_->ItemByID(shortcut_id)->status);
 
   // Activating app should launch new tab, because second tab isn't
   // in its refocus url path.
   launcher_->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());
+  TabStripModel* tab_strip = browser()->tab_strip_model();
+  // Get the browser item index
+  int browser_index = -1;
+  for (size_t index = 0; index < model_->items().size() && browser_index == -1;
+       index++) {
+    if (model_->items()[index].type == ash::TYPE_BROWSER_SHORTCUT)
+      browser_index = index;
+  }
+  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(
+      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,
+      ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
+
+  EXPECT_EQ(ash::STATUS_ACTIVE, model_->ItemByID(shortcut_id)->status);
+  EXPECT_EQ(ash::STATUS_ACTIVE, model_->items()[browser_index].status);
+
+  tab_strip->ActivateTabAt(0, false);
+  EXPECT_EQ(ash::STATUS_RUNNING, model_->ItemByID(shortcut_id)->status);
+  EXPECT_EQ(ash::STATUS_ACTIVE, model_->items()[browser_index].status);
+
+  tab_strip->CloseWebContentsAt(1, TabStripModel::CLOSE_NONE);
+  EXPECT_EQ(ash::STATUS_CLOSED, model_->ItemByID(shortcut_id)->status);
+  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);
+
+  // We cannot destroy the browser here - but we can do something which would
+  // usually destroy the browser: Closing all tabs - which will be detected
+  // by the monitoring functions as closed browser.
+  tab_strip->CloseAllTabs();
+  EXPECT_EQ(ash::STATUS_CLOSED, model_->ItemByID(shortcut_id)->status);
+  EXPECT_EQ(ash::STATUS_CLOSED, model_->items()[browser_index].status);
+}
+