Renames LauncherID, LauncherItem and LauncherItems...

chrome/browser/ui/ash/launcher/chrome_launcher_controller_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/ui/ash/launcher/chrome_launcher_controller.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 84 matching lines @@
 
   virtual ~TestShelfModelObserver() {
   }
 
   // Overridden from ash::ShelfModelObserver:
   virtual void ShelfItemAdded(int index) OVERRIDE {
     ++added_;
     last_index_ = index;
   }
 
-  virtual void ShelfItemRemoved(int index, ash::LauncherID id) OVERRIDE {
+  virtual void ShelfItemRemoved(int index, ash::ShelfID id) OVERRIDE {
     ++removed_;
     last_index_ = index;
   }
 
   virtual void ShelfItemChanged(int index,
-                                const ash::LauncherItem& old_item) OVERRIDE {
+                                const ash::ShelfItem& old_item) OVERRIDE {
     ++changed_;
     last_index_ = index;
   }
 
   virtual void ShelfItemMoved(int start_index, int target_index) OVERRIDE {
     last_index_ = target_index;
   }
 
   virtual void ShelfStatusChanged() OVERRIDE {
   }
@@ skipping 232 matching lines @@
     extension8_ = Extension::Create(base::FilePath(), Manifest::UNPACKED,
                                     manifest,
                                     Extension::NO_FLAGS,
                                     "ffffffffffffffffffffffffffffffff",
                                     &error);
   }
 
   // Creates a running V2 app (not pinned) of type |app_id|.
   virtual void CreateRunningV2App(const std::string& app_id) {
     DCHECK(!test_controller_);
-    ash::LauncherID id =
+    ash::ShelfID id =
         launcher_controller_->CreateAppShortcutLauncherItemWithType(
             app_id,
             model_->item_count(),
             ash::TYPE_PLATFORM_APP);
     DCHECK(id);
     // Change the created launcher controller into a V2 app controller.
     test_controller_ = new TestV2AppLauncherItemController(app_id,
         launcher_controller_.get());
     launcher_controller_->SetItemController(id, test_controller_);
   }
@@ skipping 41 matching lines @@
       delete item_delegate_manager_;
     model_->RemoveObserver(model_observer_.get());
     model_observer_.reset();
     launcher_controller_.reset();
     model_.reset();
 
     BrowserWithTestWindowTest::TearDown();
   }
 
   void AddAppListLauncherItem() {
-    ash::LauncherItem app_list;
+    ash::ShelfItem app_list;
     app_list.type = ash::TYPE_APP_LIST;
     model_->Add(app_list);
   }
 
   void InitLauncherController() {
     AddAppListLauncherItem();
     launcher_controller_.reset(
         new ChromeLauncherController(profile(), model_.get()));
     if (!ash::Shell::HasInstance())
       SetShelfItemDelegateManager(item_delegate_manager_);
@@ skipping 23 matching lines @@
                        const std::string& extension_id) {
     base::DictionaryValue* entry = new base::DictionaryValue();
     entry->SetString(ash::kPinnedAppsPrefAppIDPath, extension_id);
     pref_value->Insert(index, entry);
   }
 
   // Gets the currently configured app launchers from the controller.
   void GetAppLaunchers(ChromeLauncherController* controller,
                        std::vector<std::string>* launchers) {
     launchers->clear();
-    for (ash::LauncherItems::const_iterator iter(model_->items().begin());
+    for (ash::ShelfItems::const_iterator iter(model_->items().begin());
          iter != model_->items().end(); ++iter) {
       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());
       }
     }
   }
 
   // Get the setup of the currently shown launcher items in one string.
   // Each pinned element will start with a big letter, each running but not
   // pinned V1 app will start with a small letter and each running but not
   // pinned V2 app will start with a '*' + small letter.
   std::string GetPinnedAppStatus() {
     std::string result;
     for (int i = 0; i < model_->item_count(); i++) {
       if (!result.empty())
         result.append(", ");
       switch (model_->items()[i].type) {
         case ash::TYPE_PLATFORM_APP:
             result+= "*";
             // FALLTHROUGH
         case ash::TYPE_WINDOWED_APP: {
-            const std::string& app =
-                launcher_controller_->GetAppIDForLauncherID(
-                    model_->items()[i].id);
+          const std::string& app =
+              launcher_controller_->GetAppIDForShelfID(model_->items()[i].id);
             if (app == extension1_->id()) {
               result += "app1";
               EXPECT_FALSE(
                   launcher_controller_->IsAppPinned(extension1_->id()));
             } else if (app == extension2_->id()) {
               result += "app2";
               EXPECT_FALSE(
                   launcher_controller_->IsAppPinned(extension2_->id()));
             } else if (app == extension3_->id()) {
               result += "app3";
@@ skipping 18 matching lines @@
             } else if (app == extension8_->id()) {
               result += "app8";
               EXPECT_FALSE(
                   launcher_controller_->IsAppPinned(extension8_->id()));
             } else {
               result += "unknown";
             }
             break;
           }
         case ash::TYPE_APP_SHORTCUT: {
-            const std::string& app =
-                launcher_controller_->GetAppIDForLauncherID(
-                    model_->items()[i].id);
+          const std::string& app =
+              launcher_controller_->GetAppIDForShelfID(model_->items()[i].id);
             if (app == extension1_->id()) {
               result += "App1";
               EXPECT_TRUE(launcher_controller_->IsAppPinned(extension1_->id()));
             } else if (app == extension2_->id()) {
               result += "App2";
               EXPECT_TRUE(launcher_controller_->IsAppPinned(extension2_->id()));
             } else if (app == extension3_->id()) {
               result += "App3";
               EXPECT_TRUE(launcher_controller_->IsAppPinned(extension3_->id()));
             } else if (app == extension4_->id()) {
@@ skipping 458 matching lines @@
   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.
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension2_->id()));
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension3_->id()));
   EXPECT_EQ("Chrome, AppList", GetPinnedAppStatus());
 
-  // Installing |extension3_| should add it to the launcher - behind the
+  // Installing |extension3_| should add it to the shelf - behind the
   // chrome icon.
-  ash::LauncherItem item;
+  ash::ShelfItem item;
   extension_service_->AddExtension(extension3_.get());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension2_->id()));
   EXPECT_EQ("Chrome, App3, AppList", GetPinnedAppStatus());
 
   // Installing |extension2_| should add it to the launcher - behind the
   // chrome icon, but in first location.
   extension_service_->AddExtension(extension2_.get());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_EQ("Chrome, App2, App3, AppList", GetPinnedAppStatus());
@@ skipping 57 matching lines @@
   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
                                                   policy_value.DeepCopy());
   profile()->GetTestingPrefService()->SetInteger(prefs::kShelfChromeIconIndex,
                                                  1);
   // Model should only contain the browser shortcut and app list items.
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension2_->id()));
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension3_->id()));
   EXPECT_EQ("Chrome, AppList", GetPinnedAppStatus());
 
-  // Installing |extension2_| should add it to the launcher - behind the
+  // Installing |extension2_| should add it to the shelf - behind the
   // chrome icon.
-  ash::LauncherItem item;
+  ash::ShelfItem item;
   extension_service_->AddExtension(extension2_.get());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension3_->id()));
   EXPECT_EQ("Chrome, App2, AppList", GetPinnedAppStatus());
 
   // Installing |extension1_| should add it to the launcher - behind the
   // chrome icon, but in first location.
   extension_service_->AddExtension(extension1_.get());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension3_->id()));
   EXPECT_EQ("App1, Chrome, App2, AppList", GetPinnedAppStatus());
@@ skipping 58 matching lines @@
 }
 
 // Check that changing from the alternate shelf layout to the old shelflayout
 // and back does keep the app launcher at location #0.
 TEST_F(ChromeLauncherControllerTest,
        SwitchingFromAlternateShelfLayoutToLegacyAndBack) {
   InitLauncherController();
 
   // We simulate this problem by intentionally placing the app list item in
   // the middle of several apps which caused a crash (see crbug.com/329597).
-  const char kAppLauncherIdPlaceholder[] = "AppLauncherIDPlaceholder--------";
+  const char kAppShelfIdPlaceholder[] = "AppShelfIDPlaceholder--------";
 
   base::ListValue policy_value;
   InsertPrefValue(&policy_value, 0, extension1_->id());
-  InsertPrefValue(&policy_value, 1, kAppLauncherIdPlaceholder);
+  InsertPrefValue(&policy_value, 1, kAppShelfIdPlaceholder);
   InsertPrefValue(&policy_value, 2, extension2_->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.
   extension_service_->AddExtension(extension1_.get());
   extension_service_->AddExtension(extension2_.get());
   EXPECT_EQ("AppList, Chrome, App1, App2", 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 reverse
 // order.
 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());
   SetShelfChromeIconIndex(0);
   // Model should only contain the browser shortcut and app list items.
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension2_->id()));
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension3_->id()));
   EXPECT_EQ("AppList, Chrome", GetPinnedAppStatus());
 
-  // Installing |extension3_| should add it to the launcher - behind the
+  // Installing |extension3_| should add it to the shelf - behind the
   // chrome icon.
-  ash::LauncherItem item;
+  ash::ShelfItem item;
   extension_service_->AddExtension(extension3_.get());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension2_->id()));
   EXPECT_EQ("AppList, Chrome, App3", GetPinnedAppStatus());
 
   // Installing |extension2_| should add it to the launcher - behind the
   // chrome icon, but in first location.
   extension_service_->AddExtension(extension2_.get());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_EQ("AppList, Chrome, App2, App3", GetPinnedAppStatus());
@@ skipping 54 matching lines @@
   InsertPrefValue(&policy_value, 2, extension3_->id());
   profile()->GetTestingPrefService()->SetUserPref(prefs::kPinnedLauncherApps,
                                                   policy_value.DeepCopy());
   SetShelfChromeIconIndex(1);
   // Model should only contain the browser shortcut and app list items.
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension2_->id()));
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension3_->id()));
   EXPECT_EQ("AppList, Chrome", GetPinnedAppStatus());
 
-  // Installing |extension2_| should add it to the launcher - behind the
+  // Installing |extension2_| should add it to the shelf - behind the
   // chrome icon.
-  ash::LauncherItem item;
+  ash::ShelfItem item;
   extension_service_->AddExtension(extension2_.get());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension3_->id()));
   EXPECT_EQ("AppList, Chrome, App2", GetPinnedAppStatus());
 
   // Installing |extension1_| should add it to the launcher - behind the
   // chrome icon, but in first location.
   extension_service_->AddExtension(extension1_.get());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension3_->id()));
   EXPECT_EQ("AppList, App1, Chrome, App2", GetPinnedAppStatus());
@@ skipping 828 matching lines @@
   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(ChromeLauncherController* controller,
-                       const ash::LauncherItem& item,
+                       const ash::ShelfItem& item,
                        size_t expected_items,
                        base::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 27 matching lines @@
 }
 
 // Check that browsers get reflected correctly in the launcher menu.
 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;
+  ash::ShelfItem item_browser;
   item_browser.type = ash::TYPE_BROWSER_SHORTCUT;
   item_browser.id =
-      launcher_controller_->GetLauncherIDForAppID(extension_misc::kChromeAppId);
+      launcher_controller_->GetShelfIDForAppID(extension_misc::kChromeAppId);
   EXPECT_TRUE(CheckMenuCreation(
       launcher_controller_.get(), item_browser, 0, NULL, true));
 
   // Now make the created browser() visible by adding it to the active browser
   // list.
   BrowserList::SetLastActive(browser());
   base::string16 title1 = ASCIIToUTF16("Test1");
   NavigateAndCommitActiveTabWithTitle(browser(), GURL("http://test1"), title1);
   base::string16 one_menu_item[] = { title1 };
 
@@ skipping 21 matching lines @@
 }
 
 #if defined(OS_CHROMEOS)
 // Check the multi profile case where only user related browsers should show
 // up.
 TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest,
        BrowserMenuGenerationTwoUsers) {
   // Create a browser item in the LauncherController.
   InitLauncherController();
 
-  ash::LauncherItem item_browser;
+  ash::ShelfItem item_browser;
   item_browser.type = ash::TYPE_BROWSER_SHORTCUT;
   item_browser.id =
-      launcher_controller_->GetLauncherIDForAppID(extension_misc::kChromeAppId);
+      launcher_controller_->GetShelfIDForAppID(extension_misc::kChromeAppId);
 
   // Check that the menu is empty.
   chrome::NewTab(browser());
   EXPECT_TRUE(CheckMenuCreation(
       launcher_controller_.get(), item_browser, 0, NULL, true));
 
   // Show the created |browser()| by adding it to the active browser list.
   BrowserList::SetLastActive(browser());
   base::string16 title1 = ASCIIToUTF16("Test1");
   NavigateAndCommitActiveTabWithTitle(browser(), GURL("http://test1"), title1);
@@ skipping 36 matching lines @@
   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.
-  ash::LauncherID gmail_id = model_->next_id();
+  ash::ShelfID 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()));
   launcher_controller_->SetRefocusURLPatternForTest(gmail_id, GURL(gmail_url));
 
   // Check the menu content.
-  ash::LauncherItem item_browser;
+  ash::ShelfItem item_browser;
   item_browser.type = ash::TYPE_BROWSER_SHORTCUT;
   item_browser.id =
-      launcher_controller_->GetLauncherIDForAppID(extension_misc::kChromeAppId);
+      launcher_controller_->GetShelfIDForAppID(extension_misc::kChromeAppId);
 
-  ash::LauncherItem item_gmail;
+  ash::ShelfItem item_gmail;
   item_gmail.type = ash::TYPE_APP_SHORTCUT;
   item_gmail.id = gmail_id;
   EXPECT_TRUE(CheckMenuCreation(
       launcher_controller_.get(), item_gmail, 0, NULL, false));
 
   // Set the gmail URL to a new tab.
   base::string16 title1 = ASCIIToUTF16("Test1");
   NavigateAndCommitActiveTabWithTitle(browser(), GURL(gmail_url), title1);
 
   base::string16 one_menu_item[] = { title1 };
@@ skipping 35 matching lines @@
 
 #if defined(OS_CHROMEOS)
 // Check the multi profile case where only user related apps should show up.
 TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest,
        V1AppMenuGenerationTwoUsers) {
   // Create a browser item in the LauncherController.
   InitLauncherController();
   chrome::NewTab(browser());
 
   // Installing |extension3_| adds it to the launcher.
-  ash::LauncherID gmail_id = model_->next_id();
+  ash::ShelfID 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()));
   launcher_controller_->SetRefocusURLPatternForTest(gmail_id, GURL(gmail_url));
 
   // Check the menu content.
-  ash::LauncherItem item_browser;
+  ash::ShelfItem item_browser;
   item_browser.type = ash::TYPE_BROWSER_SHORTCUT;
   item_browser.id =
-      launcher_controller_->GetLauncherIDForAppID(extension_misc::kChromeAppId);
+      launcher_controller_->GetShelfIDForAppID(extension_misc::kChromeAppId);
 
-  ash::LauncherItem item_gmail;
+  ash::ShelfItem item_gmail;
   item_gmail.type = ash::TYPE_APP_SHORTCUT;
   item_gmail.id = gmail_id;
   EXPECT_TRUE(CheckMenuCreation(
       launcher_controller_.get(), item_gmail, 0, NULL, false));
 
   // Set the gmail URL to a new tab.
   base::string16 title1 = ASCIIToUTF16("Test1");
   NavigateAndCommitActiveTabWithTitle(browser(), GURL(gmail_url), title1);
 
   base::string16 one_menu_item[] = { title1 };
@@ skipping 85 matching lines @@
   EXPECT_EQ(2, model_->item_count());
 }
 #endif  // defined(OS_CHROMEOS)
 
 // Checks that the generated menu list properly activates items.
 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();
+  ash::ShelfID gmail_id = model_->next_id();
   extension_service_->AddExtension(extension3_.get());
   launcher_controller_->SetRefocusURLPatternForTest(gmail_id, GURL(gmail_url));
   base::string16 title1 = ASCIIToUTF16("Test1");
   NavigateAndCommitActiveTabWithTitle(browser(), GURL(gmail_url), title1);
   chrome::NewTab(browser());
   base::string16 title2 = ASCIIToUTF16("Test2");
   NavigateAndCommitActiveTabWithTitle(browser(), GURL(gmail_url), title2);
 
   // Check that the menu is properly set.
-  ash::LauncherItem item_gmail;
+  ash::ShelfItem item_gmail;
   item_gmail.type = ash::TYPE_APP_SHORTCUT;
   item_gmail.id = gmail_id;
   base::string16 two_menu_items[] = {title1, title2};
   EXPECT_TRUE(CheckMenuCreation(
       launcher_controller_.get(), item_gmail, 2, two_menu_items, false));
   EXPECT_EQ(1, browser()->tab_strip_model()->active_index());
   // Execute the second item in the list (which shouldn't do anything since that
   // item is per definition already the active tab).
   {
     scoped_ptr<ash::ShelfMenuModel> menu(new LauncherApplicationMenuItemModel(
@@ skipping 18 matching lines @@
   // 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(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();
+  ash::ShelfID gmail_id = model_->next_id();
   extension_service_->AddExtension(extension3_.get());
   launcher_controller_->SetRefocusURLPatternForTest(gmail_id, GURL(gmail_url));
   base::string16 title1 = ASCIIToUTF16("Test1");
   NavigateAndCommitActiveTabWithTitle(browser(), GURL(gmail_url), title1);
   chrome::NewTab(browser());
   base::string16 title2 = ASCIIToUTF16("Test2");
   NavigateAndCommitActiveTabWithTitle(browser(), GURL(gmail_url), title2);
 
   // Check that the menu is properly set.
-  ash::LauncherItem item_gmail;
+  ash::ShelfItem item_gmail;
   item_gmail.type = ash::TYPE_APP_SHORTCUT;
   item_gmail.id = gmail_id;
   base::string16 two_menu_items[] = {title1, title2};
   EXPECT_TRUE(CheckMenuCreation(
       launcher_controller_.get(), item_gmail, 2, two_menu_items, false));
 
   int tabs = browser()->tab_strip_model()->count();
   // Activate the proper tab through the menu item.
   {
     ChromeLauncherAppMenuItems items =
         launcher_controller_->GetApplicationList(item_gmail, 0);
     items[1]->Execute(0);
     EXPECT_EQ(tabs, browser()->tab_strip_model()->count());
   }
 
   // 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(ChromeLauncherControllerTest, AppPanels) {
   InitLauncherControllerWithBrowser();
-  // App list and Browser shortcut LauncherItems are added.
+  // App list and Browser shortcut ShelfItems are added.
   EXPECT_EQ(2, 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 =
       new ShellWindowLauncherItemController(
           LauncherItemController::TYPE_APP_PANEL,
           "id",
           app_id,
           launcher_controller_.get());
-  ash::LauncherID launcher_id1 = launcher_controller_->CreateAppLauncherItem(
+  ash::ShelfID shelf_id1 = launcher_controller_->CreateAppLauncherItem(
       app_panel_controller, app_id, ash::STATUS_RUNNING);
   int panel_index = model_observer_->last_index();
   EXPECT_EQ(3, model_observer_->added());
   EXPECT_EQ(0, model_observer_->changed());
   EXPECT_EQ(1, app_icon_loader->fetch_count());
   model_observer_->clear_counts();
 
   // App panels should have a separate identifier than the app id
-  EXPECT_EQ(0, launcher_controller_->GetLauncherIDForAppID(app_id));
+  EXPECT_EQ(0, launcher_controller_->GetShelfIDForAppID(app_id));
 
   // Setting the app image image should not change the panel if it set its icon
   app_panel_controller->set_image_set_by_controller(true);
   gfx::ImageSkia image;
   launcher_controller_->SetAppImage(app_id, image);
   EXPECT_EQ(0, model_observer_->changed());
   model_observer_->clear_counts();
 
   // Add a second app panel and verify that it get the same index as the first
   // one had, being added to the left of the existing panel.
   ShellWindowLauncherItemController* app_panel_controller2 =
       new ShellWindowLauncherItemController(
           LauncherItemController::TYPE_APP_PANEL,
           "id",
           app_id,
           launcher_controller_.get());
 
-  ash::LauncherID launcher_id2 = launcher_controller_->CreateAppLauncherItem(
+  ash::ShelfID shelf_id2 = launcher_controller_->CreateAppLauncherItem(
       app_panel_controller2, app_id, ash::STATUS_RUNNING);
   EXPECT_EQ(panel_index, model_observer_->last_index());
   EXPECT_EQ(1, model_observer_->added());
   model_observer_->clear_counts();
 
-  launcher_controller_->CloseLauncherItem(launcher_id2);
-  launcher_controller_->CloseLauncherItem(launcher_id1);
+  launcher_controller_->CloseLauncherItem(shelf_id2);
+  launcher_controller_->CloseLauncherItem(shelf_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(ChromeLauncherControllerTest, GmailMatching) {
   InitLauncherControllerWithBrowser();
 
   // Create a Gmail browser tab.
   chrome::NewTab(browser());
   base::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.
   EXPECT_FALSE(launcher_controller_->ContentCanBeHandledByGmailApp(content));
 
   // Installing |extension3_| adds it to the launcher.
-  ash::LauncherID gmail_id = model_->next_id();
+  ash::ShelfID 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()));
 
   // Check that it is now handled.
   EXPECT_TRUE(launcher_controller_->ContentCanBeHandledByGmailApp(content));
 
   // Check also that the app has detected that properly.
-  ash::LauncherItem item_gmail;
+  ash::ShelfItem 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(ChromeLauncherControllerTest, GmailOfflineMatching) {
   InitLauncherControllerWithBrowser();
 
   // Create a Gmail browser tab.
   chrome::NewTab(browser());
   base::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();
+  ash::ShelfID 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));
 }
 
@@ skipping 48 matching lines @@
   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);
   if (!ash::Shell::HasInstance()) {
     item_delegate_manager_ = new ash::ShelfItemDelegateManager(model_.get());
     SetShelfItemDelegateManager(item_delegate_manager_);
   }
   launcher_controller_->Init();
 
-  // Check LauncherItems are restored after resetting ChromeLauncherController.
+  // Check ShelfItems are restored after resetting ChromeLauncherController.
   EXPECT_EQ(ash::TYPE_APP_LIST, 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_BROWSER_SHORTCUT, 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");
+  ash::ShelfID id = launcher_controller_->GetShelfIDForAppID("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();
   if (!ash::Shell::HasInstance()) {
     delete item_delegate_manager_;
@@ skipping 20 matching lines @@
 
   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_->UnpinAppWithID("1");
   ASSERT_EQ(initial_size, model_->items().size());
 }