Remove PerBrowser launcher, reland step 1 of 2

chrome/browser/ui/ash/launcher/chrome_launcher_controller_per_app_unittest.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_per_app.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 17 matching lines @@
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/host_desktop.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/browser_with_test_window_test.h"
 #include "chrome/test/base/testing_pref_service_syncable.h"
 #include "chrome/test/base/testing_profile.h"
+#include "content/public/browser/web_contents.h"
 #include "content/public/test/test_browser_thread.h"
 #include "extensions/common/manifest_constants.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/models/menu_model.h"
 
 using extensions::Extension;
 using extensions::Manifest;
 
 namespace {
 const char* offline_gmail_url = "https://mail.google.com/mail/mu/u";
@@ skipping 80 matching lines @@
   }
 
   int fetch_count() const { return fetch_count_; }
 
  private:
   int fetch_count_;
 
   DISALLOW_COPY_AND_ASSIGN(TestAppIconLoaderImpl);
 };
 
+// Test implementation of AppTabHelper.
+class TestAppTabHelperImpl : public ChromeLauncherController::AppTabHelper {
+ public:
+  TestAppTabHelperImpl() {}
+  virtual ~TestAppTabHelperImpl() {}
+
+  // Sets the id for the specified tab. The id is removed if Remove() is
+  // invoked.
+  void SetAppID(content::WebContents* tab, const std::string& id) {
+    tab_id_map_[tab] = id;
+  }
+
+  // Returns true if there is an id registered for |tab|.
+  bool HasAppID(content::WebContents* tab) const {
+    return tab_id_map_.find(tab) != tab_id_map_.end();
+  }
+
+  // AppTabHelper implementation:
+  virtual std::string GetAppID(content::WebContents* tab) OVERRIDE {
+    return tab_id_map_.find(tab) != tab_id_map_.end() ? tab_id_map_[tab] :
+        std::string();
+  }
+
+  virtual bool IsValidID(const std::string& id) OVERRIDE {
+    for (TabToStringMap::const_iterator i = tab_id_map_.begin();
+         i != tab_id_map_.end(); ++i) {
+      if (i->second == id)
+        return true;
+    }
+    return false;
+  }
+
+ private:
+  typedef std::map<content::WebContents*, std::string> TabToStringMap;
+
+  TabToStringMap tab_id_map_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestAppTabHelperImpl);
+};
+
 }  // namespace
 
-class ChromeLauncherControllerPerAppTest : public BrowserWithTestWindowTest {
+class ChromeLauncherControllerTest : public BrowserWithTestWindowTest {
  protected:
-  ChromeLauncherControllerPerAppTest()
-      : extension_service_(NULL) {
+  ChromeLauncherControllerTest() : extension_service_(NULL) {
     SetHostDesktopType(chrome::HOST_DESKTOP_TYPE_ASH);
   }
 
-  virtual ~ChromeLauncherControllerPerAppTest() {
+  virtual ~ChromeLauncherControllerTest() {
   }
 
   virtual void SetUp() OVERRIDE {
     BrowserWithTestWindowTest::SetUp();
 
     model_.reset(new ash::LauncherModel);
     model_observer_.reset(new TestLauncherModelObserver);
     model_->AddObserver(model_observer_.get());
 
     DictionaryValue manifest;
@@ skipping 51 matching lines @@
     model_->RemoveObserver(model_observer_.get());
     model_observer_.reset();
     launcher_controller_.reset();
     model_.reset();
 
     BrowserWithTestWindowTest::TearDown();
   }
 
   void InitLauncherController() {
     launcher_controller_.reset(
-        new ChromeLauncherControllerPerApp(profile(), model_.get()));
+        new ChromeLauncherController(profile(), model_.get()));
     launcher_controller_->Init();
   }
 
   void InitLauncherControllerWithBrowser() {
     chrome::NewTab(browser());
     BrowserList::SetLastActive(browser());
     InitLauncherController();
   }
 
   void SetAppIconLoader(extensions::AppIconLoader* loader) {
     launcher_controller_->SetAppIconLoaderForTest(loader);
   }
 
+  void SetAppTabHelper(ChromeLauncherController::AppTabHelper* helper) {
+    launcher_controller_->SetAppTabHelperForTest(helper);
+  }
+
   void InsertPrefValue(base::ListValue* pref_value,
                        int index,
                        const std::string& extension_id) {
     base::DictionaryValue* entry = new DictionaryValue();
     entry->SetString(ash::kPinnedAppsPrefAppIDPath, extension_id);
     pref_value->Insert(index, entry);
   }
 
   // Gets the currently configured app launchers from the controller.
-  void GetAppLaunchers(ChromeLauncherControllerPerApp* controller,
+  void GetAppLaunchers(ChromeLauncherController* controller,
                        std::vector<std::string>* launchers) {
     launchers->clear();
     for (ash::LauncherItems::const_iterator iter(model_->items().begin());
          iter != model_->items().end(); ++iter) {
-      ChromeLauncherControllerPerApp::IDToItemControllerMap::const_iterator
+      ChromeLauncherController::IDToItemControllerMap::const_iterator
           entry(controller->id_to_item_controller_map_.find(iter->id));
       if (iter->type == ash::TYPE_APP_SHORTCUT &&
           entry != controller->id_to_item_controller_map_.end()) {
         launchers->push_back(entry->second->app_id());
       }
     }
   }
 
   std::string GetPinnedAppStatus() {
     std::string result;
@@ skipping 32 matching lines @@
       }
     }
     return result;
   }
 
   // Needed for extension service & friends to work.
   scoped_refptr<Extension> extension1_;
   scoped_refptr<Extension> extension2_;
   scoped_refptr<Extension> extension3_;
   scoped_refptr<Extension> extension4_;
-  scoped_ptr<ChromeLauncherControllerPerApp> launcher_controller_;
+  scoped_ptr<ChromeLauncherController> launcher_controller_;
   scoped_ptr<TestLauncherModelObserver> model_observer_;
   scoped_ptr<ash::LauncherModel> model_;
 
   ExtensionService* extension_service_;
 
-  DISALLOW_COPY_AND_ASSIGN(ChromeLauncherControllerPerAppTest);
+  DISALLOW_COPY_AND_ASSIGN(ChromeLauncherControllerTest);
 };
 
 // The testing framework to test the alternate shelf layout.
-class AlternateLayoutChromeLauncherControllerPerAppTest
-    : public ChromeLauncherControllerPerAppTest {
+class AlternateLayoutChromeLauncherControllerTest
+    : public ChromeLauncherControllerTest {
  protected:
-  AlternateLayoutChromeLauncherControllerPerAppTest() {
+  AlternateLayoutChromeLauncherControllerTest() {
   }
 
-  virtual ~AlternateLayoutChromeLauncherControllerPerAppTest() {
+  virtual ~AlternateLayoutChromeLauncherControllerTest() {
   }
 
   // Overwrite the Setup function to add the Alternate Shelf layout option.
   virtual void SetUp() OVERRIDE {
     CommandLine::ForCurrentProcess()->AppendSwitch(
         ash::switches::kAshUseAlternateShelfLayout);
-    ChromeLauncherControllerPerAppTest::SetUp();
+    ChromeLauncherControllerTest::SetUp();
   }
 
   // Set the index at which the chrome icon should be.
   void SetShelfChromeIconIndex(int index) {
     profile()->GetTestingPrefService()->SetInteger(prefs::kShelfChromeIconIndex,
                                                    index + 1);
   }
 
  private:
 
-  DISALLOW_COPY_AND_ASSIGN(AlternateLayoutChromeLauncherControllerPerAppTest);
+  DISALLOW_COPY_AND_ASSIGN(AlternateLayoutChromeLauncherControllerTest);
 };
 
 
-TEST_F(ChromeLauncherControllerPerAppTest, DefaultApps) {
+TEST_F(ChromeLauncherControllerTest, DefaultApps) {
   InitLauncherController();
   // Model should only contain the browser shortcut and app list items.
   EXPECT_EQ(2, model_->item_count());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension2_->id()));
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension3_->id()));
 
   // Installing |extension3_| should add it to the launcher - behind the
   // chrome icon.
   extension_service_->AddExtension(extension3_.get());
   EXPECT_EQ("Chrome, App3, AppList, ", GetPinnedAppStatus());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension2_->id()));
 }
 
 // Check that the restauration of launcher items is happening in the same order
 // as the user has pinned them (on another system) when they are synced reverse
 // order.
-TEST_F(ChromeLauncherControllerPerAppTest, RestoreDefaultAppsReverseOrder) {
+TEST_F(ChromeLauncherControllerTest, RestoreDefaultAppsReverseOrder) {
   InitLauncherController();
 
   base::ListValue policy_value;
   InsertPrefValue(&policy_value, 0, extension1_->id());
   InsertPrefValue(&policy_value, 1, extension2_->id());
   InsertPrefValue(&policy_value, 2, extension3_->id());
   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
                                                   policy_value.DeepCopy());
   EXPECT_EQ(0, profile()->GetPrefs()->GetInteger(prefs::kShelfChromeIconIndex));
   // Model should only contain the browser shortcut and app list items.
@@ skipping 18 matching lines @@
 
   // Installing |extension1_| should add it to the launcher - behind the
   // chrome icon, but in first location.
   extension_service_->AddExtension(extension1_.get());
   EXPECT_EQ("Chrome, App1, App2, App3, AppList, ", GetPinnedAppStatus());
 }
 
 // Check that the restauration of launcher items is happening in the same order
 // as the user has pinned them (on another system) when they are synced random
 // order.
-TEST_F(ChromeLauncherControllerPerAppTest, RestoreDefaultAppsRandomOrder) {
+TEST_F(ChromeLauncherControllerTest, RestoreDefaultAppsRandomOrder) {
   InitLauncherController();
 
   base::ListValue policy_value;
   InsertPrefValue(&policy_value, 0, extension1_->id());
   InsertPrefValue(&policy_value, 1, extension2_->id());
   InsertPrefValue(&policy_value, 2, extension3_->id());
   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
                                                   policy_value.DeepCopy());
   EXPECT_EQ(0, profile()->GetPrefs()->GetInteger(prefs::kShelfChromeIconIndex));
   // Model should only contain the browser shortcut and app list items.
@@ skipping 17 matching lines @@
 
   // Installing |extension3_| should add it to the launcher - behind the
   // chrome icon, but in first location.
   extension_service_->AddExtension(extension3_.get());
   EXPECT_EQ("Chrome, App1, App2, App3, AppList, ", GetPinnedAppStatus());
 }
 
 // Check that the restauration of launcher items is happening in the same order
 // as the user has pinned / moved them (on another system) when they are synced
 // random order - including the chrome icon.
-TEST_F(ChromeLauncherControllerPerAppTest,
-    RestoreDefaultAppsRandomOrderChromeMoved) {
+TEST_F(ChromeLauncherControllerTest, RestoreDefaultAppsRandomOrderChromeMoved) {
   InitLauncherController();
 
   base::ListValue policy_value;
   InsertPrefValue(&policy_value, 0, extension1_->id());
   InsertPrefValue(&policy_value, 1, extension2_->id());
   InsertPrefValue(&policy_value, 2, extension3_->id());
   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
                                                   policy_value.DeepCopy());
   profile()->GetTestingPrefService()->SetInteger(prefs::kShelfChromeIconIndex,
                                                  1);
@@ skipping 17 matching lines @@
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension3_->id()));
   EXPECT_EQ("App1, Chrome, App2, AppList, ", GetPinnedAppStatus());
 
   // Installing |extension3_| should add it to the launcher - behind the
   // chrome icon, but in first location.
   extension_service_->AddExtension(extension3_.get());
   EXPECT_EQ("App1, Chrome, App2, App3, AppList, ", GetPinnedAppStatus());
 }
 
 // Check that syncing to a different state does the correct thing.
-TEST_F(ChromeLauncherControllerPerAppTest, RestoreDefaultAppsResyncOrder) {
+TEST_F(ChromeLauncherControllerTest, RestoreDefaultAppsResyncOrder) {
   InitLauncherController();
   base::ListValue policy_value;
   InsertPrefValue(&policy_value, 0, extension1_->id());
   InsertPrefValue(&policy_value, 1, extension2_->id());
   InsertPrefValue(&policy_value, 2, extension3_->id());
   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
                                                   policy_value.DeepCopy());
   EXPECT_EQ(0, profile()->GetPrefs()->GetInteger(prefs::kShelfChromeIconIndex));
   extension_service_->AddExtension(extension2_.get());
   extension_service_->AddExtension(extension1_.get());
@@ skipping 14 matching lines @@
   InsertPrefValue(&policy_value2, 0, extension2_->id());
   InsertPrefValue(&policy_value2, 1, extension3_->id());
   InsertPrefValue(&policy_value2, 2, extension1_->id());
   profile()->GetTestingPrefService()->SetInteger(prefs::kShelfChromeIconIndex,
                                                  1);
   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
                                                   policy_value2.DeepCopy());
   EXPECT_EQ("App2, Chrome, App3, App1, AppList, ", GetPinnedAppStatus());
 }
 
-TEST_F(AlternateLayoutChromeLauncherControllerPerAppTest, DefaultApps) {
+TEST_F(AlternateLayoutChromeLauncherControllerTest, DefaultApps) {
   InitLauncherController();
   // Model should only contain the browser shortcut and app list items.
   EXPECT_EQ(2, model_->item_count());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension2_->id()));
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension3_->id()));
 
   // Installing |extension3_| should add it to the launcher - behind the
   // chrome icon.
   extension_service_->AddExtension(extension3_.get());
   EXPECT_EQ("AppList, Chrome, App3, ", GetPinnedAppStatus());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension2_->id()));
 }
 
 // Check that the restauration of launcher items is happening in the same order
 // as the user has pinned them (on another system) when they are synced reverse
 // order.
-TEST_F(AlternateLayoutChromeLauncherControllerPerAppTest,
+TEST_F(AlternateLayoutChromeLauncherControllerTest,
     RestoreDefaultAppsReverseOrder) {
   InitLauncherController();
 
   base::ListValue policy_value;
   InsertPrefValue(&policy_value, 0, extension1_->id());
   InsertPrefValue(&policy_value, 1, extension2_->id());
   InsertPrefValue(&policy_value, 2, extension3_->id());
   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
                                                   policy_value.DeepCopy());
   SetShelfChromeIconIndex(0);
@@ skipping 19 matching lines @@
 
   // Installing |extension1_| should add it to the launcher - behind the
   // chrome icon, but in first location.
   extension_service_->AddExtension(extension1_.get());
   EXPECT_EQ("AppList, Chrome, App1, App2, App3, ", GetPinnedAppStatus());
 }
 
 // Check that the restauration of launcher items is happening in the same order
 // as the user has pinned them (on another system) when they are synced random
 // order.
-TEST_F(AlternateLayoutChromeLauncherControllerPerAppTest,
+TEST_F(AlternateLayoutChromeLauncherControllerTest,
     RestoreDefaultAppsRandomOrder) {
   InitLauncherController();
 
   base::ListValue policy_value;
   InsertPrefValue(&policy_value, 0, extension1_->id());
   InsertPrefValue(&policy_value, 1, extension2_->id());
   InsertPrefValue(&policy_value, 2, extension3_->id());
   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
                                                   policy_value.DeepCopy());
   SetShelfChromeIconIndex(0);
@@ skipping 18 matching lines @@
 
   // Installing |extension3_| should add it to the launcher - behind the
   // chrome icon, but in first location.
   extension_service_->AddExtension(extension3_.get());
   EXPECT_EQ("AppList, Chrome, App1, App2, App3, ", GetPinnedAppStatus());
 }
 
 // Check that the restauration of launcher items is happening in the same order
 // as the user has pinned / moved them (on another system) when they are synced
 // random order - including the chrome icon - using the alternate shelf layout.
-TEST_F(AlternateLayoutChromeLauncherControllerPerAppTest,
+TEST_F(AlternateLayoutChromeLauncherControllerTest,
     RestoreDefaultAppsRandomOrderChromeMoved) {
   InitLauncherController();
 
   base::ListValue policy_value;
   InsertPrefValue(&policy_value, 0, extension1_->id());
   InsertPrefValue(&policy_value, 1, extension2_->id());
   InsertPrefValue(&policy_value, 2, extension3_->id());
   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
                                                   policy_value.DeepCopy());
   SetShelfChromeIconIndex(1);
@@ skipping 18 matching lines @@
   EXPECT_EQ("AppList, App1, Chrome, App2, ", GetPinnedAppStatus());
 
   // Installing |extension3_| should add it to the launcher - behind the
   // chrome icon, but in first location.
   extension_service_->AddExtension(extension3_.get());
   EXPECT_EQ("AppList, App1, Chrome, App2, App3, ", GetPinnedAppStatus());
 }
 
 // Check that syncing to a different state does the correct thing with the
 // alternate shelf layout.
-TEST_F(AlternateLayoutChromeLauncherControllerPerAppTest,
+TEST_F(AlternateLayoutChromeLauncherControllerTest,
     RestoreDefaultAppsResyncOrder) {
   InitLauncherController();
   base::ListValue policy_value;
   InsertPrefValue(&policy_value, 0, extension1_->id());
   InsertPrefValue(&policy_value, 1, extension2_->id());
   InsertPrefValue(&policy_value, 2, extension3_->id());
   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
                                                   policy_value.DeepCopy());
   // The alternate shelf layout has always one static item at the beginning.
   SetShelfChromeIconIndex(0);
@@ skipping 41 matching lines @@
                                       extension_misc::UNLOAD_REASON_UNINSTALL);
   EXPECT_EQ("AppList, Chrome, App3, ", GetPinnedAppStatus());
 
   // Check that an update of an extension does not crash the system.
   extension_service_->UnloadExtension(extension3_->id(),
                                       extension_misc::UNLOAD_REASON_UPDATE);
   EXPECT_EQ("AppList, Chrome, App3, ", GetPinnedAppStatus());
 }
 
 // Check that simple locking of an application will 'create' a launcher item.
-TEST_F(ChromeLauncherControllerPerAppTest, CheckLockApps) {
+TEST_F(ChromeLauncherControllerTest, CheckLockApps) {
   InitLauncherController();
   // Model should only contain the browser shortcut and app list items.
   EXPECT_EQ(2, model_->item_count());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_FALSE(
       launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension2_->id()));
   EXPECT_FALSE(
       launcher_controller_->IsWindowedAppInLauncher(extension2_->id()));
 
@@ skipping 12 matching lines @@
   EXPECT_EQ(2, model_->item_count());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_FALSE(
       launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension2_->id()));
   EXPECT_FALSE(
       launcher_controller_->IsWindowedAppInLauncher(extension2_->id()));
 }
 
 // Check that multiple locks of an application will be properly handled.
-TEST_F(ChromeLauncherControllerPerAppTest, CheckMukltiLockApps) {
+TEST_F(ChromeLauncherControllerTest, CheckMukltiLockApps) {
   InitLauncherController();
   // Model should only contain the browser shortcut and app list items.
   EXPECT_EQ(2, model_->item_count());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_FALSE(
       launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
 
   for (int i = 0; i < 2; i++) {
     launcher_controller_->LockV1AppWithID(extension1_->id());
 
@@ skipping 16 matching lines @@
   EXPECT_EQ(2, model_->item_count());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_FALSE(
       launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension2_->id()));
   EXPECT_FALSE(
       launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
 }
 
 // Check that already pinned items are not effected by locks.
-TEST_F(ChromeLauncherControllerPerAppTest, CheckAlreadyPinnedLockApps) {
+TEST_F(ChromeLauncherControllerTest, CheckAlreadyPinnedLockApps) {
   InitLauncherController();
   // Model should only contain the browser shortcut and app list items.
   EXPECT_EQ(2, model_->item_count());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_FALSE(
       launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
 
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
   launcher_controller_->PinAppWithID(extension1_->id());
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension1_->id()));
@@ skipping 19 matching lines @@
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_FALSE(
       launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
 
   launcher_controller_->UnpinAppsWithID(extension1_->id());
 
   EXPECT_EQ(2, model_->item_count());
 }
 
 // Check that already pinned items which get locked stay after unpinning.
-TEST_F(ChromeLauncherControllerPerAppTest, CheckPinnedAppsStayAfterUnlock) {
+TEST_F(ChromeLauncherControllerTest, CheckPinnedAppsStayAfterUnlock) {
   InitLauncherController();
   // Model should only contain the browser shortcut and app list items.
   EXPECT_EQ(2, model_->item_count());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_FALSE(
       launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
 
   launcher_controller_->PinAppWithID(extension1_->id());
 
   EXPECT_EQ(3, model_->item_count());
@@ skipping 16 matching lines @@
   EXPECT_EQ(ash::TYPE_WINDOWED_APP, model_->items()[1].type);
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_TRUE(launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
 
   launcher_controller_->UnlockV1AppWithID(extension1_->id());
 
   EXPECT_EQ(2, model_->item_count());
 }
 
 // Check that lock -> pin -> unlock -> unpin does properly transition.
-TEST_F(ChromeLauncherControllerPerAppTest, CheckLockPinUnlockUnpin) {
+TEST_F(ChromeLauncherControllerTest, CheckLockPinUnlockUnpin) {
   InitLauncherController();
   // Model should only contain the browser shortcut and app list items.
   EXPECT_EQ(2, model_->item_count());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_FALSE(
       launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
 
   launcher_controller_->LockV1AppWithID(extension1_->id());
 
   EXPECT_EQ(3, model_->item_count());
@@ skipping 15 matching lines @@
   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, model_->items()[1].type);
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_FALSE(
       launcher_controller_->IsWindowedAppInLauncher(extension1_->id()));
 
   launcher_controller_->UnpinAppsWithID(extension1_->id());
 
   EXPECT_EQ(2, model_->item_count());
 }
 
-TEST_F(ChromeLauncherControllerPerAppTest, Policy) {
+TEST_F(ChromeLauncherControllerTest, Policy) {
   extension_service_->AddExtension(extension1_.get());
   extension_service_->AddExtension(extension3_.get());
 
   base::ListValue policy_value;
   InsertPrefValue(&policy_value, 0, extension1_->id());
   InsertPrefValue(&policy_value, 1, extension2_->id());
   profile()->GetTestingPrefService()->SetManagedPref(prefs::kPinnedLauncherApps,
                                                      policy_value.DeepCopy());
 
   // Only |extension1_| should get pinned. |extension2_| is specified but not
@@ skipping 19 matching lines @@
   policy_value.Remove(0, NULL);
   profile()->GetTestingPrefService()->SetManagedPref(prefs::kPinnedLauncherApps,
                                                      policy_value.DeepCopy());
   EXPECT_EQ(3, model_->item_count());
   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, model_->items()[1].type);
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension2_->id()));
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension3_->id()));
 }
 
-TEST_F(ChromeLauncherControllerPerAppTest, UnpinWithUninstall) {
+TEST_F(ChromeLauncherControllerTest, UnpinWithUninstall) {
   extension_service_->AddExtension(extension3_.get());
   extension_service_->AddExtension(extension4_.get());
 
   InitLauncherController();
 
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension3_->id()));
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension4_->id()));
 
   extension_service_->UnloadExtension(extension3_->id(),
                                       extension_misc::UNLOAD_REASON_UNINSTALL);
 
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension3_->id()));
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension4_->id()));
 }
 
-TEST_F(ChromeLauncherControllerPerAppTest, PrefUpdates) {
+TEST_F(ChromeLauncherControllerTest, PrefUpdates) {
   extension_service_->AddExtension(extension2_.get());
   extension_service_->AddExtension(extension3_.get());
   extension_service_->AddExtension(extension4_.get());
 
   InitLauncherController();
 
   std::vector<std::string> expected_launchers;
   std::vector<std::string> actual_launchers;
   base::ListValue pref_value;
   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
@@ skipping 35 matching lines @@
 
   // Clearing works.
   pref_value.Clear();
   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
                                                  pref_value.DeepCopy());
   expected_launchers.clear();
   GetAppLaunchers(launcher_controller_.get(), &actual_launchers);
   EXPECT_EQ(expected_launchers, actual_launchers);
 }
 
-TEST_F(ChromeLauncherControllerPerAppTest, PendingInsertionOrder) {
+TEST_F(ChromeLauncherControllerTest, PendingInsertionOrder) {
   extension_service_->AddExtension(extension1_.get());
   extension_service_->AddExtension(extension3_.get());
 
   InitLauncherController();
 
   base::ListValue pref_value;
   InsertPrefValue(&pref_value, 0, extension1_->id());
   InsertPrefValue(&pref_value, 1, extension2_->id());
   InsertPrefValue(&pref_value, 2, extension3_->id());
   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
@@ skipping 12 matching lines @@
   expected_launchers.insert(expected_launchers.begin() + 1, extension2_->id());
   GetAppLaunchers(launcher_controller_.get(), &actual_launchers);
   EXPECT_EQ(expected_launchers, actual_launchers);
 }
 
 // Checks the created menus and menu lists for correctness. It uses the given
 // |controller| to create the objects for the given |item| and checks the
 // found item count against the |expected_items|. The |title| list contains the
 // menu titles in the order of their appearance in the menu (not including the
 // application name).
-bool CheckMenuCreation(ChromeLauncherControllerPerApp* controller,
+bool CheckMenuCreation(ChromeLauncherController* controller,
                        const ash::LauncherItem& item,
                        size_t expected_items,
                        string16 title[],
                        bool is_browser) {
   ChromeLauncherAppMenuItems items = controller->GetApplicationList(item, 0);
   // A new behavior has been added: Only show menus if there is at least one
   // item available.
   if (expected_items < 1 && is_browser) {
     EXPECT_EQ(0u, items.size());
     return items.size() == 0;
@@ skipping 21 matching lines @@
   EXPECT_EQ(expected_menu_items, menu->GetItemCount());
   EXPECT_FALSE(menu->IsEnabledAt(first_item));
   if (expected_items) {
     EXPECT_EQ(ui::MenuModel::TYPE_SEPARATOR,
               menu->GetTypeAt(first_item + 1));
   }
   return items.size() == expected_items + 1;
 }
 
 // Check that browsers get reflected correctly in the launcher menu.
-TEST_F(ChromeLauncherControllerPerAppTest, BrowserMenuGeneration) {
+TEST_F(ChromeLauncherControllerTest, BrowserMenuGeneration) {
   EXPECT_EQ(1U, chrome::GetTotalBrowserCount());
   chrome::NewTab(browser());
 
   InitLauncherController();
 
   // Check that the browser list is empty at this time.
   ash::LauncherItem item_browser;
   item_browser.type = ash::TYPE_BROWSER_SHORTCUT;
   item_browser.id =
       launcher_controller_->GetLauncherIDForAppID(extension_misc::kChromeAppId);
@@ skipping 27 matching lines @@
       launcher_controller_.get(), item_browser, 2, two_menu_items, true));
 
   // Apparently we have to close all tabs we have.
   chrome::CloseTab(browser2.get());
 }
 
 // Check that V1 apps are correctly reflected in the launcher menu using the
 // refocus logic.
 // Note that the extension matching logic is tested by the extension system
 // and does not need a separate test here.
-TEST_F(ChromeLauncherControllerPerAppTest, V1AppMenuGeneration) {
+TEST_F(ChromeLauncherControllerTest, V1AppMenuGeneration) {
   EXPECT_EQ(1U, chrome::GetTotalBrowserCount());
   EXPECT_EQ(0, browser()->tab_strip_model()->count());
 
   InitLauncherControllerWithBrowser();
 
   // Model should only contain the browser shortcut and app list items.
   EXPECT_EQ(2, model_->item_count());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension3_->id()));
 
   // Installing |extension3_| adds it to the launcher.
@@ skipping 52 matching lines @@
   launcher_controller_->Close(item_gmail.id);
 
   EXPECT_TRUE(CheckMenuCreation(
       launcher_controller_.get(), item_gmail, 0, NULL, false));
   string16 browser_menu_item2[] = {title2};
   EXPECT_TRUE(CheckMenuCreation(
       launcher_controller_.get(), item_browser, 1, browser_menu_item2, false));
 }
 
 // Checks that the generated menu list properly activates items.
-TEST_F(ChromeLauncherControllerPerAppTest, V1AppMenuExecution) {
+TEST_F(ChromeLauncherControllerTest, V1AppMenuExecution) {
   InitLauncherControllerWithBrowser();
 
   // Add |extension3_| to the launcher and add two items.
   GURL gmail = GURL("https://mail.google.com/mail/u");
   ash::LauncherID gmail_id = model_->next_id();
   extension_service_->AddExtension(extension3_.get());
   launcher_controller_->SetRefocusURLPatternForTest(gmail_id, GURL(gmail_url));
   string16 title1 = ASCIIToUTF16("Test1");
   NavigateAndCommitActiveTabWithTitle(browser(), GURL(gmail_url), title1);
   chrome::NewTab(browser());
@@ skipping 28 matching lines @@
         launcher_controller_->CreateApplicationMenu(item_gmail, 0));
     int first_item =
         (menu->GetTypeAt(0) == ui::MenuModel::TYPE_SEPARATOR) ? 1 : 0;
     menu->ActivatedAt(first_item + 2);
   }
   // Now the active tab should be the second item.
   EXPECT_EQ(0, browser()->tab_strip_model()->active_index());
 }
 
 // Checks that the generated menu list properly deletes items.
-TEST_F(ChromeLauncherControllerPerAppTest, V1AppMenuDeletionExecution) {
+TEST_F(ChromeLauncherControllerTest, V1AppMenuDeletionExecution) {
   InitLauncherControllerWithBrowser();
 
   // Add |extension3_| to the launcher and add two items.
   GURL gmail = GURL("https://mail.google.com/mail/u");
   ash::LauncherID gmail_id = model_->next_id();
   extension_service_->AddExtension(extension3_.get());
   launcher_controller_->SetRefocusURLPatternForTest(gmail_id, GURL(gmail_url));
   string16 title1 = ASCIIToUTF16("Test1");
   NavigateAndCommitActiveTabWithTitle(browser(), GURL(gmail_url), title1);
   chrome::NewTab(browser());
@@ skipping 20 matching lines @@
   // Delete one tab through the menu item.
   {
     ChromeLauncherAppMenuItems items =
         launcher_controller_->GetApplicationList(item_gmail, 0);
     items[1]->Execute(ui::EF_SHIFT_DOWN);
     EXPECT_EQ(--tabs, browser()->tab_strip_model()->count());
   }
 }
 
 // Tests that panels create launcher items correctly
-TEST_F(ChromeLauncherControllerPerAppTest, AppPanels) {
+TEST_F(ChromeLauncherControllerTest, AppPanels) {
   InitLauncherControllerWithBrowser();
+  // Browser shortcut LauncherItem is added.
   EXPECT_EQ(1, model_observer_->added());
 
   TestAppIconLoaderImpl* app_icon_loader = new TestAppIconLoaderImpl();
   SetAppIconLoader(app_icon_loader);
 
   // Test adding an app panel
   std::string app_id = extension1_->id();
   ShellWindowLauncherItemController app_panel_controller(
       LauncherItemController::TYPE_APP_PANEL, "id", app_id,
       launcher_controller_.get());
@@ skipping 23 matching lines @@
   EXPECT_EQ(1, model_observer_->added());
   model_observer_->clear_counts();
 
   launcher_controller_->CloseLauncherItem(launcher_id2);
   launcher_controller_->CloseLauncherItem(launcher_id1);
   EXPECT_EQ(2, model_observer_->removed());
 }
 
 // Tests that the Gmail extension matches more then the app itself claims with
 // the manifest file.
-TEST_F(ChromeLauncherControllerPerAppTest, GmailMatching) {
+TEST_F(ChromeLauncherControllerTest, GmailMatching) {
   InitLauncherControllerWithBrowser();
 
   // Create a Gmail browser tab.
   chrome::NewTab(browser());
   string16 title = ASCIIToUTF16("Test");
   NavigateAndCommitActiveTabWithTitle(browser(), GURL(gmail_url), title);
   content::WebContents* content =
       browser()->tab_strip_model()->GetActiveWebContents();
 
   // Check that the launcher controller does not recognize the running app.
@@ skipping 11 matching lines @@
   EXPECT_TRUE(launcher_controller_->ContentCanBeHandledByGmailApp(content));
 
   // Check also that the app has detected that properly.
   ash::LauncherItem item_gmail;
   item_gmail.type = ash::TYPE_APP_SHORTCUT;
   item_gmail.id = gmail_id;
   EXPECT_EQ(2U, launcher_controller_->GetApplicationList(item_gmail, 0).size());
 }
 
 // Tests that the Gmail extension does not match the offline verison.
-TEST_F(ChromeLauncherControllerPerAppTest, GmailOfflineMatching) {
+TEST_F(ChromeLauncherControllerTest, GmailOfflineMatching) {
   InitLauncherControllerWithBrowser();
 
   // Create a Gmail browser tab.
   chrome::NewTab(browser());
   string16 title = ASCIIToUTF16("Test");
   NavigateAndCommitActiveTabWithTitle(browser(),
                                       GURL(offline_gmail_url),
                                       title);
   content::WebContents* content =
       browser()->tab_strip_model()->GetActiveWebContents();
 
   // Installing |extension3_| adds it to the launcher.
   ash::LauncherID gmail_id = model_->next_id();
   extension_service_->AddExtension(extension3_.get());
   EXPECT_EQ(3, model_->item_count());
   int gmail_index = model_->ItemIndexByID(gmail_id);
   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, model_->items()[gmail_index].type);
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension3_->id()));
 
   // The content should not be able to be handled by the app.
   EXPECT_FALSE(launcher_controller_->ContentCanBeHandledByGmailApp(content));
 }
+
+// Verify that the launcher item positions are persisted and restored.
+TEST_F(ChromeLauncherControllerTest, PersistLauncherItemPositions) {
+  InitLauncherController();
+
+  TestAppTabHelperImpl* app_tab_helper = new TestAppTabHelperImpl;
+  SetAppTabHelper(app_tab_helper);
+
+  EXPECT_EQ(ash::TYPE_BROWSER_SHORTCUT, model_->items()[0].type);
+  EXPECT_EQ(ash::TYPE_APP_LIST, model_->items()[1].type);
+
+  TabStripModel* tab_strip_model = browser()->tab_strip_model();
+  EXPECT_EQ(0, tab_strip_model->count());
+  chrome::NewTab(browser());
+  chrome::NewTab(browser());
+  EXPECT_EQ(2, tab_strip_model->count());
+  app_tab_helper->SetAppID(tab_strip_model->GetWebContentsAt(0), "1");
+  app_tab_helper->SetAppID(tab_strip_model->GetWebContentsAt(1), "2");
+
+  EXPECT_FALSE(launcher_controller_->IsAppPinned("1"));
+  launcher_controller_->PinAppWithID("1");
+  EXPECT_TRUE(launcher_controller_->IsAppPinned("1"));
+  launcher_controller_->PinAppWithID("2");
+
+  EXPECT_EQ(ash::TYPE_BROWSER_SHORTCUT, model_->items()[0].type);
+  EXPECT_EQ(ash::TYPE_APP_SHORTCUT, model_->items()[1].type);
+  EXPECT_EQ(ash::TYPE_APP_SHORTCUT, model_->items()[2].type);
+  EXPECT_EQ(ash::TYPE_APP_LIST, model_->items()[3].type);
+
+  // Move browser shortcut item from index 0 to index 2.
+  model_->Move(0, 2);
+  EXPECT_EQ(ash::TYPE_APP_SHORTCUT, model_->items()[0].type);
+  EXPECT_EQ(ash::TYPE_APP_SHORTCUT, model_->items()[1].type);
+  EXPECT_EQ(ash::TYPE_BROWSER_SHORTCUT, model_->items()[2].type);
+  EXPECT_EQ(ash::TYPE_APP_LIST, model_->items()[3].type);
+
+  launcher_controller_.reset();
+  model_.reset(new ash::LauncherModel);
+  launcher_controller_.reset(
+      ChromeLauncherController::CreateInstance(profile(), model_.get()));
+  app_tab_helper = new TestAppTabHelperImpl;
+  app_tab_helper->SetAppID(tab_strip_model->GetWebContentsAt(0), "1");
+  app_tab_helper->SetAppID(tab_strip_model->GetWebContentsAt(1), "2");
+  SetAppTabHelper(app_tab_helper);
+
+  launcher_controller_->Init();
+
+  // Check LauncherItems are restored after resetting ChromeLauncherController.
+  EXPECT_EQ(ash::TYPE_APP_SHORTCUT, model_->items()[0].type);
+  EXPECT_EQ(ash::TYPE_APP_SHORTCUT, model_->items()[1].type);
+  EXPECT_EQ(ash::TYPE_BROWSER_SHORTCUT, model_->items()[2].type);
+  EXPECT_EQ(ash::TYPE_APP_LIST, model_->items()[3].type);
+}
+
+// Verifies pinned apps are persisted and restored.
+TEST_F(ChromeLauncherControllerTest, PersistPinned) {
+  InitLauncherControllerWithBrowser();
+  size_t initial_size = model_->items().size();
+
+  TabStripModel* tab_strip_model = browser()->tab_strip_model();
+  EXPECT_EQ(1, tab_strip_model->count());
+
+  TestAppTabHelperImpl* app_tab_helper = new TestAppTabHelperImpl;
+  app_tab_helper->SetAppID(tab_strip_model->GetWebContentsAt(0), "1");
+  SetAppTabHelper(app_tab_helper);
+
+  TestAppIconLoaderImpl* app_icon_loader = new TestAppIconLoaderImpl;
+  SetAppIconLoader(app_icon_loader);
+  EXPECT_EQ(0, app_icon_loader->fetch_count());
+
+  launcher_controller_->PinAppWithID("1");
+  ash::LauncherID id = launcher_controller_->GetLauncherIDForAppID("1");
+  int app_index = model_->ItemIndexByID(id);
+  EXPECT_EQ(1, app_icon_loader->fetch_count());
+  EXPECT_EQ(ash::TYPE_APP_SHORTCUT, model_->items()[app_index].type);
+  EXPECT_TRUE(launcher_controller_->IsAppPinned("1"));
+  EXPECT_FALSE(launcher_controller_->IsAppPinned("0"));
+  EXPECT_EQ(initial_size + 1, model_->items().size());
+
+  launcher_controller_.reset();
+  model_.reset(new ash::LauncherModel);
+  launcher_controller_.reset(
+      ChromeLauncherController::CreateInstance(profile(), model_.get()));
+  app_tab_helper = new TestAppTabHelperImpl;
+  app_tab_helper->SetAppID(tab_strip_model->GetWebContentsAt(0), "1");
+  SetAppTabHelper(app_tab_helper);
+  app_icon_loader = new TestAppIconLoaderImpl;
+  SetAppIconLoader(app_icon_loader);
+  launcher_controller_->Init();
+
+  EXPECT_EQ(1, app_icon_loader->fetch_count());
+  ASSERT_EQ(initial_size + 1, model_->items().size());
+  EXPECT_TRUE(launcher_controller_->IsAppPinned("1"));
+  EXPECT_FALSE(launcher_controller_->IsAppPinned("0"));
+  EXPECT_EQ(ash::TYPE_APP_SHORTCUT, model_->items()[app_index].type);
+
+  launcher_controller_->UnpinAppsWithID("1");
+  ASSERT_EQ(initial_size, model_->items().size());
+}