ash: Rename more Launcher classes to Shelf*.

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>
 
 #include "ash/ash_switches.h"
-#include "ash/launcher/launcher_item_delegate_manager.h"
+#include "ash/shelf/shelf_item_delegate_manager.h"
 #include "ash/shelf/shelf_model.h"
 #include "ash/shelf/shelf_model_observer.h"
 #include "ash/shell.h"
-#include "ash/test/launcher_item_delegate_manager_test_api.h"
+#include "ash/test/shelf_item_delegate_manager_test_api.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_path.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/test_extension_system.h"
 #include "chrome/browser/ui/ash/chrome_launcher_prefs.h"
@@ skipping 207 matching lines @@
   virtual void Close() OVERRIDE {}
   virtual bool ItemSelected(const ui::Event& event) OVERRIDE { return false; }
   virtual string16 GetTitle() OVERRIDE { return string16(); }
   virtual ChromeLauncherAppMenuItems GetApplicationList(
       int event_flags) OVERRIDE {
     ChromeLauncherAppMenuItems items;
     items.push_back(new ChromeLauncherAppMenuItem(string16(), NULL, false));
     items.push_back(new ChromeLauncherAppMenuItem(string16(), NULL, false));
     return items.Pass();
   }
-  virtual ui::MenuModel* CreateContextMenu(
-      aura::Window* root_window) OVERRIDE { return NULL; }
-  virtual ash::LauncherMenuModel* CreateApplicationMenu(
-      int event_flags) OVERRIDE { return NULL; }
+  virtual ui::MenuModel* CreateContextMenu(aura::Window* root_window) OVERRIDE {
+    return NULL;
+  }
+  virtual ash::ShelfMenuModel* CreateApplicationMenu(int event_flags) OVERRIDE {
+    return NULL;
+  }
   virtual bool IsDraggable() OVERRIDE { return false; }
   virtual bool ShouldShowTooltip() OVERRIDE { return false; }
 
  private:
 
   DISALLOW_COPY_AND_ASSIGN(TestV2AppLauncherItemController);
 };
 
 }  // namespace
 
 class ChromeLauncherControllerTest : public BrowserWithTestWindowTest {
  protected:
   ChromeLauncherControllerTest() : test_controller_(NULL),
                                    extension_service_(NULL) {
     SetHostDesktopType(chrome::HOST_DESKTOP_TYPE_ASH);
   }
 
   virtual ~ChromeLauncherControllerTest() {
   }
 
   virtual void SetUp() OVERRIDE {
     BrowserWithTestWindowTest::SetUp();
 
     model_.reset(new ash::ShelfModel);
     model_observer_.reset(new TestShelfModelObserver);
     model_->AddObserver(model_observer_.get());
 
     if (ash::Shell::HasInstance()) {
       item_delegate_manager_ =
-          ash::Shell::GetInstance()->launcher_item_delegate_manager();
+          ash::Shell::GetInstance()->shelf_item_delegate_manager();
     } else {
       item_delegate_manager_ =
-          new ash::LauncherItemDelegateManager(model_.get());
+          new ash::ShelfItemDelegateManager(model_.get());
     }
 
     DictionaryValue manifest;
     manifest.SetString(extensions::manifest_keys::kName,
                        "launcher controller test extension");
     manifest.SetString(extensions::manifest_keys::kVersion, "1");
     manifest.SetString(extensions::manifest_keys::kDescription,
                        "for testing pinned apps");
 
     extensions::TestExtensionSystem* extension_system(
@@ skipping 128 matching lines @@
     ash::LauncherItem 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())
-      SetLauncherItemDelegateManager(item_delegate_manager_);
+      SetShelfItemDelegateManager(item_delegate_manager_);
     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 SetLauncherItemDelegateManager(
-      ash::LauncherItemDelegateManager* manager) {
-    launcher_controller_->SetLauncherItemDelegateManagerForTest(manager);
+  void SetShelfItemDelegateManager(ash::ShelfItemDelegateManager* manager) {
+    launcher_controller_->SetShelfItemDelegateManagerForTest(manager);
   }
 
   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);
   }
 
@@ skipping 128 matching lines @@
   scoped_refptr<Extension> extension8_;
   scoped_ptr<ChromeLauncherController> launcher_controller_;
   scoped_ptr<TestShelfModelObserver> model_observer_;
   scoped_ptr<ash::ShelfModel> model_;
 
   // |item_delegate_manager_| owns |test_controller_|.
   LauncherItemController* test_controller_;
 
   ExtensionService* extension_service_;
 
-  ash::LauncherItemDelegateManager* item_delegate_manager_;
+  ash::ShelfItemDelegateManager* item_delegate_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(ChromeLauncherControllerTest);
 };
 
 // The testing framework to test the legacy shelf layout.
 class LegacyShelfLayoutChromeLauncherControllerTest
     : public ChromeLauncherControllerTest {
  protected:
   LegacyShelfLayoutChromeLauncherControllerTest() {
   }
@@ skipping 1459 matching lines @@
   EXPECT_FALSE(items[0]->IsEnabled());
   for (size_t i = 0; i < expected_items; i++) {
     EXPECT_EQ(title[i], items[1 + i]->title());
     // Check that the first real item has a leading separator.
     if (i == 1)
       EXPECT_TRUE(items[i]->HasLeadingSeparator());
     else
       EXPECT_FALSE(items[i]->HasLeadingSeparator());
   }
 
-  scoped_ptr<ash::LauncherMenuModel> menu(
-      new LauncherApplicationMenuItemModel(
-          controller->GetApplicationList(item, 0)));
+  scoped_ptr<ash::ShelfMenuModel> menu(new LauncherApplicationMenuItemModel(
+      controller->GetApplicationList(item, 0)));
   // The first element in the menu is a spacing separator. On some systems
   // (e.g. Windows) such things do not exist. As such we check the existence
   // and adjust dynamically.
   int first_item = menu->GetTypeAt(0) == ui::MenuModel::TYPE_SEPARATOR ? 1 : 0;
   int expected_menu_items = first_item +
                             (expected_items ? (expected_items + 3) : 2);
   EXPECT_EQ(expected_menu_items, menu->GetItemCount());
   EXPECT_FALSE(menu->IsEnabledAt(first_item));
   if (expected_items) {
     EXPECT_EQ(ui::MenuModel::TYPE_SEPARATOR,
@@ skipping 324 matching lines @@
   ash::LauncherItem item_gmail;
   item_gmail.type = ash::TYPE_APP_SHORTCUT;
   item_gmail.id = gmail_id;
   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::LauncherMenuModel> menu(
-        new LauncherApplicationMenuItemModel(
-            launcher_controller_->GetApplicationList(item_gmail, 0)));
+    scoped_ptr<ash::ShelfMenuModel> menu(new LauncherApplicationMenuItemModel(
+        launcher_controller_->GetApplicationList(item_gmail, 0)));
     // The first element in the menu is a spacing separator. On some systems
     // (e.g. Windows) such things do not exist. As such we check the existence
     // and adjust dynamically.
     int first_item =
         (menu->GetTypeAt(0) == ui::MenuModel::TYPE_SEPARATOR) ? 1 : 0;
     menu->ActivatedAt(first_item + 3);
   }
   EXPECT_EQ(1, browser()->tab_strip_model()->active_index());
 
   // Execute the first item.
   {
-    scoped_ptr<ash::LauncherMenuModel> menu(
-        new LauncherApplicationMenuItemModel(
-            launcher_controller_->GetApplicationList(item_gmail, 0)));
+    scoped_ptr<ash::ShelfMenuModel> menu(new LauncherApplicationMenuItemModel(
+        launcher_controller_->GetApplicationList(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(ChromeLauncherControllerTest, V1AppMenuDeletionExecution) {
@@ skipping 181 matching lines @@
   model_->Move(1, 3);
   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);
 
   launcher_controller_.reset();
   if (!ash::Shell::HasInstance()) {
     delete item_delegate_manager_;
   } else {
-    // Clear already registered LauncherItemDelegate.
-    ash::test::LauncherItemDelegateManagerTestAPI test(item_delegate_manager_);
-    test.RemoveAllLauncherItemDelegateForTest();
+    // Clear already registered ShelfItemDelegate.
+    ash::test::ShelfItemDelegateManagerTestAPI test(item_delegate_manager_);
+    test.RemoveAllShelfItemDelegateForTest();
   }
   model_.reset(new ash::ShelfModel);
 
   AddAppListLauncherItem();
   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);
   if (!ash::Shell::HasInstance()) {
-    item_delegate_manager_ =
-        new ash::LauncherItemDelegateManager(model_.get());
-    SetLauncherItemDelegateManager(item_delegate_manager_);
+    item_delegate_manager_ = new ash::ShelfItemDelegateManager(model_.get());
+    SetShelfItemDelegateManager(item_delegate_manager_);
   }
   launcher_controller_->Init();
 
   // Check LauncherItems 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);
 }
 
@@ skipping 19 matching lines @@
   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_;
   } else {
-    // Clear already registered LauncherItemDelegate.
-    ash::test::LauncherItemDelegateManagerTestAPI test(item_delegate_manager_);
-    test.RemoveAllLauncherItemDelegateForTest();
+    // Clear already registered ShelfItemDelegate.
+    ash::test::ShelfItemDelegateManagerTestAPI test(item_delegate_manager_);
+    test.RemoveAllShelfItemDelegateForTest();
   }
   model_.reset(new ash::ShelfModel);
 
   AddAppListLauncherItem();
   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);
   if (!ash::Shell::HasInstance()) {
-    item_delegate_manager_ =
-        new ash::LauncherItemDelegateManager(model_.get());
-    SetLauncherItemDelegateManager(item_delegate_manager_);
+    item_delegate_manager_ = new ash::ShelfItemDelegateManager(model_.get());
+    SetShelfItemDelegateManager(item_delegate_manager_);
   }
   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_->UnpinAppWithID("1");
   ASSERT_EQ(initial_size, model_->items().size());
 }