mash: Fold ShelfItemDelegateManager into ShelfModel

chrome/browser/ui/ash/launcher/chrome_launcher_controller_impl_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_impl.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <map>
 #include <memory>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "ash/common/ash_switches.h"
-#include "ash/common/shelf/shelf_item_delegate_manager.h"
 #include "ash/common/shelf/shelf_model.h"
 #include "ash/common/shelf/shelf_model_observer.h"
 #include "ash/common/wm/maximize_mode/maximize_mode_controller.h"
 #include "ash/common/wm_shell.h"
 #include "ash/display/screen_orientation_controller_chromeos.h"
 #include "ash/shell.h"
 #include "ash/test/ash_test_helper.h"
-#include "ash/test/shelf_item_delegate_manager_test_api.h"
 #include "ash/test/test_session_state_delegate.h"
 #include "ash/test/test_shell_delegate.h"
 #include "ash/wm/window_util.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_path.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 110 matching lines @@
 
   void ShelfItemChanged(int index, const ash::ShelfItem& old_item) override {
     ++changed_;
     last_index_ = index;
   }
 
   void ShelfItemMoved(int start_index, int target_index) override {
     last_index_ = target_index;
   }
 
+  void OnSetShelfItemDelegate(ash::ShelfID id,
+                              ash::ShelfItemDelegate* item_delegate) override {}
+
   void clear_counts() {
     added_ = 0;
     removed_ = 0;
     changed_ = 0;
     last_index_ = 0;
   }
 
   int added() const { return added_; }
   int removed() const { return removed_; }
   int changed() const { return changed_; }
@@ skipping 156 matching lines @@
     if (!profile_manager_) {
       profile_manager_.reset(
           new TestingProfileManager(TestingBrowserProcess::GetGlobal()));
       ASSERT_TRUE(profile_manager_->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()->shelf_item_delegate_manager();
-    } else {
-      item_delegate_manager_ =
-          new ash::ShelfItemDelegateManager(model_.get());
-    }
-
     base::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(
         static_cast<extensions::TestExtensionSystem*>(
             extensions::ExtensionSystem::Get(profile())));
@@ skipping 115 matching lines @@
     InsertAddPinChange(user_a, 6, extension_misc::kChromeAppId);
 
     // Set user b preferences.
     InsertAddPinChange(user_b, 0, extension7_->id());
     InsertAddPinChange(user_b, 1, extension8_->id());
     InsertAddPinChange(user_b, 2, extension_misc::kChromeAppId);
   }
 
   void TearDown() override {
     arc_test_.TearDown();
-    launcher_controller_->SetShelfItemDelegateManagerForTest(nullptr);
     model_->RemoveObserver(model_observer_.get());
     model_observer_.reset();
     launcher_controller_.reset();
 
-    // item_delegate_manager_ must be deleted after launch_controller_,
-    // because launch_controller_ has a map of pointers to the data
-    // hold by item_delegate_manager_.
-    if (!ash::Shell::HasInstance())
-      delete item_delegate_manager_;
-
+    // |model_| must be deleted after |launch_controller_|, because
+    // |launch_controller_| has a map of pointers to the data held by |model_|.
     model_.reset();
 
     BrowserWithTestWindowTest::TearDown();
   }
 
   BrowserWindow* CreateBrowserWindow() override {
     return CreateTestBrowserWindowAura();
   }
 
   std::unique_ptr<Browser> CreateBrowserWithTestWindowForProfile(
       Profile* profile) {
     TestBrowserWindow* browser_window = CreateTestBrowserWindowAura();
     new TestBrowserWindowOwner(browser_window);
     return base::WrapUnique(
         CreateBrowser(profile, Browser::TYPE_TABBED, false, browser_window));
   }
 
   void AddAppListLauncherItem() {
     ash::ShelfItem app_list;
     app_list.type = ash::TYPE_APP_LIST;
     model_->Add(app_list);
   }
 
   void InitLauncherController() {
     AddAppListLauncherItem();
     launcher_controller_.reset(
         new ChromeLauncherControllerImpl(profile(), model_.get()));
-    if (!ash::Shell::HasInstance())
-      SetShelfItemDelegateManager(item_delegate_manager_);
     launcher_controller_->Init();
   }
 
   void InitLauncherControllerWithBrowser() {
     InitLauncherController();
     chrome::NewTab(browser());
     browser()->window()->Show();
   }
 
   void RecreateChromeLauncher() {
@@ skipping 27 matching lines @@
     std::vector<std::unique_ptr<AppIconLoader>> loaders;
     loaders.push_back(std::move(loader1));
     loaders.push_back(std::move(loader2));
     launcher_controller_->SetAppIconLoadersForTest(loaders);
   }
 
   void SetLauncherControllerHelper(LauncherControllerHelper* helper) {
     launcher_controller_->SetLauncherControllerHelperForTest(helper);
   }
 
-  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 base::DictionaryValue();
     entry->SetString(ash::launcher::kPinnedAppsPrefAppIDPath, extension_id);
     pref_value->Insert(index, entry);
   }
 
   void InsertRemoveAllPinsChange(syncer::SyncChangeList* list) {
     for (const auto& sync_peer : app_service_->sync_items()) {
@@ skipping 350 matching lines @@
   std::unique_ptr<ash::ShelfModel> model_;
   std::unique_ptr<TestingProfileManager> profile_manager_;
 
   // |item_delegate_manager_| owns |test_controller_|.
   LauncherItemController* test_controller_;
 
   ExtensionService* extension_service_;
 
   app_list::AppListSyncableService* app_service_;
 
-  ash::ShelfItemDelegateManager* item_delegate_manager_;
-
  private:
   TestBrowserWindow* CreateTestBrowserWindowAura() {
     std::unique_ptr<aura::Window> window(new aura::Window(nullptr));
     window->set_id(0);
     window->SetType(ui::wm::WINDOW_TYPE_NORMAL);
     window->Init(ui::LAYER_TEXTURED);
     aura::client::ParentWindowWithContext(window.get(), GetContext(),
                                           gfx::Rect(200, 200));
 
     return new TestBrowserWindowAura(std::move(window));
@@ skipping 2275 matching lines @@
   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, model_->items()[2].type);
   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, model_->items()[3].type);
 
   // Move browser shortcut item from index 1 to index 3.
   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);
 
-  SetShelfItemDelegateManager(nullptr);
   launcher_controller_.reset();
-  if (!ash::Shell::HasInstance()) {
-    delete item_delegate_manager_;
-  } else {
-    // Clear already registered ShelfItemDelegate.
-    ash::test::ShelfItemDelegateManagerTestAPI test(item_delegate_manager_);
-    test.RemoveAllShelfItemDelegateForTest();
-  }
   model_.reset(new ash::ShelfModel);
 
   AddAppListLauncherItem();
   launcher_controller_.reset(
       ChromeLauncherControllerImpl::CreateInstance(profile(), model_.get()));
   helper = new TestLauncherControllerHelper(profile());
   helper->SetAppID(tab_strip_model->GetWebContentsAt(0), "1");
   helper->SetAppID(tab_strip_model->GetWebContentsAt(1), "2");
   SetLauncherControllerHelper(helper);
-  if (!ash::Shell::HasInstance()) {
-    item_delegate_manager_ = new ash::ShelfItemDelegateManager(model_.get());
-    SetShelfItemDelegateManager(item_delegate_manager_);
-  }
   launcher_controller_->Init();
 
   // Check ShelfItems are restored after resetting ChromeLauncherControllerImpl.
   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.
@@ skipping 16 matching lines @@
 
   launcher_controller_->PinAppWithID("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());
 
-  SetShelfItemDelegateManager(nullptr);
   launcher_controller_.reset();
-  if (!ash::Shell::HasInstance()) {
-    delete item_delegate_manager_;
-  } else {
-    // Clear already registered ShelfItemDelegate.
-    ash::test::ShelfItemDelegateManagerTestAPI test(item_delegate_manager_);
-    test.RemoveAllShelfItemDelegateForTest();
-  }
   model_.reset(new ash::ShelfModel);
 
   AddAppListLauncherItem();
   launcher_controller_.reset(
       ChromeLauncherControllerImpl::CreateInstance(profile(), model_.get()));
   helper = new TestLauncherControllerHelper(profile());
   helper->SetAppID(tab_strip_model->GetWebContentsAt(0), "1");
   SetLauncherControllerHelper(helper);
   // app_icon_loader is owned by ChromeLauncherControllerImpl.
   app_icon_loader = new TestAppIconLoaderImpl;
   app_icon_loader->AddSupportedApp("1");
   SetAppIconLoader(std::unique_ptr<AppIconLoader>(app_icon_loader));
-  if (!ash::Shell::HasInstance()) {
-    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());
@@ skipping 371 matching lines @@
   EXPECT_FALSE(controller->rotation_locked());
   EXPECT_EQ(display::Display::ROTATE_0,
             display::Screen::GetScreen()->GetPrimaryDisplay().rotation());
 
   NotifyOnTaskOrientationLockRequested(task_id_current_,
                                        OrientationLock::CURRENT);
   EXPECT_TRUE(controller->rotation_locked());
   EXPECT_EQ(display::Display::ROTATE_0,
             display::Screen::GetScreen()->GetPrimaryDisplay().rotation());
 }