mash: Remove ShelfDelegate; move functions to 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>
@@ skipping 255 matching lines @@
                     const ItemSelectedCallback& callback) override {
     callback.Run(ash::SHELF_ACTION_WINDOW_ACTIVATED, base::nullopt);
   }
   void ExecuteCommand(uint32_t command_id, int32_t event_flags) override {}
   void Close() override {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestV2AppLauncherItemController);
 };
 
+// A test ShelfController implementation that tracks alignment and auto-hide.
+class TestShelfController : public ash::mojom::ShelfController {
+ public:
+  TestShelfController() : binding_(this) {}
+  ~TestShelfController() override {}
+
+  ash::ShelfAlignment alignment() const { return alignment_; }
+  ash::ShelfAutoHideBehavior auto_hide() const { return auto_hide_; }
+
+  size_t alignment_change_count() const { return alignment_change_count_; }
+  size_t auto_hide_change_count() const { return auto_hide_change_count_; }
+
+  ash::mojom::ShelfControllerPtr CreateInterfacePtrAndBind() {
+    return binding_.CreateInterfacePtrAndBind();
+  }
+
+  // ash::mojom::ShelfController:
+  void AddObserver(
+      ash::mojom::ShelfObserverAssociatedPtrInfo observer) override {
+    observer_.Bind(std::move(observer));
+  }
+  void SetAlignment(ash::ShelfAlignment alignment,
+                    int64_t display_id) override {
+    alignment_change_count_++;
+    alignment_ = alignment;
+    observer_->OnAlignmentChanged(alignment_, display_id);
+  }
+  void SetAutoHideBehavior(ash::ShelfAutoHideBehavior auto_hide,
+                           int64_t display_id) override {
+    auto_hide_change_count_++;
+    auto_hide_ = auto_hide;
+    observer_->OnAutoHideBehaviorChanged(auto_hide_, display_id);
+  }
+  void PinItem(
+      const ash::ShelfItem& item,
+      ash::mojom::ShelfItemDelegateAssociatedPtrInfo delegate) override {}
+  void UnpinItem(const std::string& app_id) override {}
+  void SetItemImage(const std::string& app_id, const SkBitmap& image) override {
+  }
+
+ private:
+  ash::ShelfAlignment alignment_ = ash::SHELF_ALIGNMENT_BOTTOM_LOCKED;
+  ash::ShelfAutoHideBehavior auto_hide_ = ash::SHELF_AUTO_HIDE_ALWAYS_HIDDEN;
+
+  size_t alignment_change_count_ = 0;
+  size_t auto_hide_change_count_ = 0;
+
+  ash::mojom::ShelfObserverAssociatedPtr observer_;
+  mojo::Binding<ash::mojom::ShelfController> binding_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestShelfController);
+};
+
 // A callback that does nothing after shelf item selection handling.
 void NoopCallback(ash::ShelfAction action, base::Optional<ash::MenuItemList>) {}
 
 // Simulates selection of the shelf item.
 void SelectItem(ash::ShelfItemDelegate* delegate) {
   std::unique_ptr<ui::Event> event = base::MakeUnique<ui::MouseEvent>(
       ui::ET_MOUSE_PRESSED, gfx::Point(), gfx::Point(), ui::EventTimeForNow(),
       ui::EF_NONE, 0);
   delegate->ItemSelected(std::move(event), display::kInvalidDisplayId,
                          ash::LAUNCH_FROM_UNKNOWN, base::Bind(&NoopCallback));
 }
 
 }  // namespace
 
+// A test ChromeLauncherControllerImpl subclass that uses TestShelfController.
+class TestChromeLauncherControllerImpl : public ChromeLauncherControllerImpl {
+ public:
+  TestChromeLauncherControllerImpl(Profile* profile, ash::ShelfModel* model)
+      : ChromeLauncherControllerImpl(profile, model) {}
+
+  // ChromeLauncherControllerImpl:
+  using ChromeLauncherControllerImpl::ReleaseProfile;
+  bool ConnectToShelfController() override {
+    // Set the shelf controller pointer to a test instance; this is run in init.
+    if (!shelf_controller_.is_bound())
+      shelf_controller_ = test_shelf_controller_.CreateInterfacePtrAndBind();
+    return true;
+  }
+
+  TestShelfController* test_shelf_controller() {
+    return &test_shelf_controller_;
+  }
+
+ private:
+  TestShelfController test_shelf_controller_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestChromeLauncherControllerImpl);
+};
+
+// A shell delegate that owns a ChromeLauncherController, like production.
+// TODO(msw): Refine ChromeLauncherControllerImpl lifetime management.
+// TODO(msw): Avoid relying on TestShellDelegate's ShelfInitializer.
+class ChromeLauncherTestShellDelegate : public ash::test::TestShellDelegate {
+ public:
+  ChromeLauncherTestShellDelegate() {}
+
+  // Create a ChromeLauncherControllerImpl instance.
+  ChromeLauncherControllerImpl* CreateLauncherController(Profile* profile) {
+    launcher_controller_ = base::MakeUnique<ChromeLauncherControllerImpl>(
+        profile, ash::Shell::Get()->shelf_model());
+    return launcher_controller_.get();
+  }
+
+  // Create a TestChromeLauncherControllerImpl instance.
+  TestChromeLauncherControllerImpl* CreateTestLauncherController(
+      Profile* profile) {
+    auto controller = base::MakeUnique<TestChromeLauncherControllerImpl>(
+        profile, ash::Shell::Get()->shelf_model());
+    TestChromeLauncherControllerImpl* controller_weak = controller.get();
+    launcher_controller_ = std::move(controller);
+    launcher_controller_->Init();
+    return controller_weak;
+  }
+
+  // ash::test::TestShellDelegate:
+  void ShelfShutdown() override { launcher_controller_.reset(); }
+
+ private:
+  std::unique_ptr<ChromeLauncherControllerImpl> launcher_controller_;
+
+  DISALLOW_COPY_AND_ASSIGN(ChromeLauncherTestShellDelegate);
+};
+
 class ChromeLauncherControllerImplTest : public BrowserWithTestWindowTest {
  protected:
   ChromeLauncherControllerImplTest()
       : BrowserWithTestWindowTest(Browser::TYPE_TABBED, false) {}
 
   ~ChromeLauncherControllerImplTest() override {}
 
   void SetUp() override {
     base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
     command_line->AppendSwitch(switches::kUseFirstDisplayAsInternal);
 
     app_list::AppListSyncableServiceFactory::SetUseInTesting();
 
+    shell_delegate_ = new ChromeLauncherTestShellDelegate();
+    ash_test_helper()->set_test_shell_delegate(shell_delegate_);
+
     BrowserWithTestWindowTest::SetUp();
 
     if (!profile_manager_) {
       profile_manager_.reset(
           new TestingProfileManager(TestingBrowserProcess::GetGlobal()));
       ASSERT_TRUE(profile_manager_->SetUp());
     }
 
     model_ = ash::Shell::Get()->shelf_controller()->model();
     model_observer_.reset(new TestShelfModelObserver);
@@ skipping 165 matching lines @@
     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);
   }
 
-  // Create a launcher controller instance and register it as the ShelfDelegate.
-  // Returns a pointer to the uninitialized controller, which is owned by Shell.
+  // Create a launcher controller instance, owned by the test shell delegate.
+  // Returns a pointer to the uninitialized controller.
   ChromeLauncherControllerImpl* CreateLauncherController() {
-    // Shell owns ChromeLauncherController as its ShelfDelegate. The lifetime
-    // of this instance should match production behavior as closely as possible.
-    DCHECK(!ChromeLauncherController::instance());
-    std::unique_ptr<ChromeLauncherControllerImpl> launcher_controller =
-        base::MakeUnique<ChromeLauncherControllerImpl>(profile(), model_);
-    launcher_controller_ = launcher_controller.get();
-    ash::test::ShellTestApi().SetShelfDelegate(std::move(launcher_controller));
+    launcher_controller_ = shell_delegate_->CreateLauncherController(profile());
     return launcher_controller_;
   }
 
-  // Create and initialize the controller.
-  // Returns a pointer to the initialized controller, which is owned by Shell.
+  // Create and initialize the controller, owned by the test shell delegate.
   void InitLauncherController() { CreateLauncherController()->Init(); }
 
   // Create and initialize the controller; create a tab and show the browser.
   void InitLauncherControllerWithBrowser() {
     InitLauncherController();
     chrome::NewTab(browser());
     browser()->window()->Show();
   }
 
-  // Destroy Shell's controller instance and clear the local pointer.
+  // Destroy the launcher controller instance and clear the local pointer.
   void ResetLauncherController() {
     launcher_controller_ = nullptr;
-    ash::test::ShellTestApi().SetShelfDelegate(nullptr);
+    shell_delegate_->ShelfShutdown();
   }
 
   // Destroy and recreate the controller; clear and reinitialize the ShelfModel.
-  // Returns a pointer to the uninitialized controller, which is owned by Shell.
+  // Returns a pointer to the uninitialized controller, owned by shell delegate.
   // TODO(msw): This does not accurately represent ChromeLauncherControllerImpl
   // lifetime or usage in production, and does not accurately simulate restarts.
   ChromeLauncherControllerImpl* RecreateLauncherController() {
     // Destroy any existing controller first; only one may exist at a time.
     ResetLauncherController();
     while (model_->item_count() > 0)
       model_->RemoveItemAt(0);
     AddAppListLauncherItem();
     return CreateLauncherController();
   }
@@ skipping 402 matching lines @@
   scoped_refptr<Extension> extension5_;
   scoped_refptr<Extension> extension6_;
   scoped_refptr<Extension> extension7_;
   scoped_refptr<Extension> extension8_;
   scoped_refptr<Extension> extension_platform_app_;
   scoped_refptr<Extension> arc_support_host_;
 
   ArcAppTest arc_test_;
   bool auto_start_arc_test_ = false;
   ChromeLauncherControllerImpl* launcher_controller_ = nullptr;
+  ChromeLauncherTestShellDelegate* shell_delegate_ = nullptr;
   std::unique_ptr<TestShelfModelObserver> model_observer_;
   ash::ShelfModel* model_ = nullptr;
   std::unique_ptr<TestingProfileManager> profile_manager_;
 
   // |item_delegate_manager_| owns |test_controller_|.
   ash::ShelfItemDelegate* test_controller_ = nullptr;
 
   ExtensionService* extension_service_ = nullptr;
 
   app_list::AppListSyncableService* app_service_ = nullptr;
@@ skipping 149 matching lines @@
 
     // Initialize the UserManager singleton to a fresh FakeUserManager instance.
     user_manager_enabler_.reset(new chromeos::ScopedUserManagerEnabler(
         new chromeos::FakeChromeUserManager));
 
     // Initialize the WallpaperManager singleton.
     chromeos::WallpaperManager::Initialize();
 
     // Initialize the rest.
     ChromeLauncherControllerImplTest::SetUp();
-
-    // Get some base objects.
-    shell_delegate_ = static_cast<ash::test::TestShellDelegate*>(
-        ash::Shell::Get()->shell_delegate());
     shell_delegate_->set_multi_profiles_enabled(true);
   }
 
   void TearDown() override {
     ChromeLauncherControllerImplTest::TearDown();
     user_manager_enabler_.reset();
     for (ProfileToNameMap::iterator it = created_profiles_.begin();
          it != created_profiles_.end(); ++it)
       profile_manager_->DeleteTestingProfile(it->second);
     chromeos::WallpaperManager::Shutdown();
@@ skipping 64 matching lines @@
   // this is only usable with a single v1 application.
   V1App* CreateRunningV1App(Profile* profile,
                             const std::string& app_name,
                             const std::string& url) {
     V1App* v1_app = new V1App(profile, app_name);
     NavigateAndCommitActiveTabWithTitle(v1_app->browser(), GURL(url),
                                         base::string16());
     return v1_app;
   }
 
-  ash::test::TestShellDelegate* shell_delegate() { return shell_delegate_; }
-
   // Override BrowserWithTestWindowTest:
   TestingProfile* CreateProfile() override {
     return CreateMultiUserProfile("user1");
   }
   void DestroyProfile(TestingProfile* profile) override {
     // Delete the profile through our profile manager.
     ProfileToNameMap::iterator it = created_profiles_.find(profile);
     DCHECK(it != created_profiles_.end());
     profile_manager_->DeleteTestingProfile(it->second);
     created_profiles_.erase(it);
   }
 
  private:
   typedef std::map<Profile*, std::string> ProfileToNameMap;
   TestingProfileManager* profile_manager() { return profile_manager_.get(); }
 
   chromeos::FakeChromeUserManager* GetFakeUserManager() {
     return static_cast<chromeos::FakeChromeUserManager*>(
         user_manager::UserManager::Get());
   }
 
   std::unique_ptr<chromeos::ScopedUserManagerEnabler> user_manager_enabler_;
 
-  ash::test::TestShellDelegate* shell_delegate_;
-
   ProfileToNameMap created_profiles_;
 
   DISALLOW_COPY_AND_ASSIGN(
       MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerImplTest);
 };
 
 class ChromeLauncherControllerImplMultiProfileWithArcTest
     : public MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerImplTest,  // NOLINT(whitespace/line_length)
       public ::testing::WithParamInterface<bool> {
  protected:
@@ skipping 2902 matching lines @@
   // Pinned state should not change.
   EXPECT_EQ("AppList, Chrome, App1, App2", GetPinnedAppStatus());
   launcher_controller_->UnpinAppWithID(extension2_->id());
   EXPECT_EQ("AppList, Chrome, App1", GetPinnedAppStatus());
 
   // Resume syncing and sync information overrides local copy.
   StartAppSyncService(copy_sync_list);
   EXPECT_EQ("AppList, Chrome, App1, App2", GetPinnedAppStatus());
 }
 
-// A test ShelfController implementation that tracks alignment and auto-hide.
-class TestShelfController : public ash::mojom::ShelfController {
- public:
-  TestShelfController() : binding_(this) {}
-  ~TestShelfController() override {}
-
-  ash::ShelfAlignment alignment() const { return alignment_; }
-  ash::ShelfAutoHideBehavior auto_hide() const { return auto_hide_; }
-
-  size_t alignment_change_count() const { return alignment_change_count_; }
-  size_t auto_hide_change_count() const { return auto_hide_change_count_; }
-
-  ash::mojom::ShelfControllerPtr CreateInterfacePtrAndBind() {
-    return binding_.CreateInterfacePtrAndBind();
-  }
-
-  // ash::mojom::ShelfController:
-  void AddObserver(
-      ash::mojom::ShelfObserverAssociatedPtrInfo observer) override {
-    observer_.Bind(std::move(observer));
-  }
-  void SetAlignment(ash::ShelfAlignment alignment,
-                    int64_t display_id) override {
-    alignment_change_count_++;
-    alignment_ = alignment;
-    observer_->OnAlignmentChanged(alignment_, display_id);
-  }
-  void SetAutoHideBehavior(ash::ShelfAutoHideBehavior auto_hide,
-                           int64_t display_id) override {
-    auto_hide_change_count_++;
-    auto_hide_ = auto_hide;
-    observer_->OnAutoHideBehaviorChanged(auto_hide_, display_id);
-  }
-  void PinItem(
-      const ash::ShelfItem& item,
-      ash::mojom::ShelfItemDelegateAssociatedPtrInfo delegate) override {}
-  void UnpinItem(const std::string& app_id) override {}
-  void SetItemImage(const std::string& app_id, const SkBitmap& image) override {
-  }
-
- private:
-  ash::ShelfAlignment alignment_ = ash::SHELF_ALIGNMENT_BOTTOM_LOCKED;
-  ash::ShelfAutoHideBehavior auto_hide_ = ash::SHELF_AUTO_HIDE_ALWAYS_HIDDEN;
-
-  size_t alignment_change_count_ = 0;
-  size_t auto_hide_change_count_ = 0;
-
-  ash::mojom::ShelfObserverAssociatedPtr observer_;
-  mojo::Binding<ash::mojom::ShelfController> binding_;
-
-  DISALLOW_COPY_AND_ASSIGN(TestShelfController);
-};
-
-// A test ChromeLauncherControllerImpl sublcass that uses TestShelfController.
-class TestChromeLauncherControllerImpl : public ChromeLauncherControllerImpl {
- public:
-  TestChromeLauncherControllerImpl(Profile* profile, ash::ShelfModel* model)
-      : ChromeLauncherControllerImpl(profile, model) {}
-
-  // ChromeLauncherControllerImpl:
-  using ChromeLauncherControllerImpl::ReleaseProfile;
-  bool ConnectToShelfController() override {
-    // Set the shelf controller pointer to a test instance; this is run in init.
-    if (!shelf_controller_.is_bound())
-      shelf_controller_ = test_shelf_controller_.CreateInterfacePtrAndBind();
-    return true;
-  }
-
-  TestShelfController* test_shelf_controller() {
-    return &test_shelf_controller_;
-  }
-
- private:
-  TestShelfController test_shelf_controller_;
-
-  DISALLOW_COPY_AND_ASSIGN(TestChromeLauncherControllerImpl);
-};
-
-using ChromeLauncherControllerImplPrefTest = BrowserWithTestWindowTest;
-
 // Tests that shelf profile preferences are loaded on login.
-TEST_F(ChromeLauncherControllerImplPrefTest, PrefsLoadedOnLogin) {
+TEST_F(ChromeLauncherControllerImplTest, PrefsLoadedOnLogin) {
   PrefService* prefs = profile()->GetTestingPrefService();
   prefs->SetString(prefs::kShelfAlignmentLocal, "Left");
   prefs->SetString(prefs::kShelfAlignment, "Left");
   prefs->SetString(prefs::kShelfAutoHideBehaviorLocal, "Always");
   prefs->SetString(prefs::kShelfAutoHideBehavior, "Always");
 
-  ash::ShelfModel* model = ash::Shell::Get()->shelf_controller()->model();
-  TestChromeLauncherControllerImpl test_launcher_controller(profile(), model);
-  test_launcher_controller.Init();
+  TestChromeLauncherControllerImpl* test_launcher_controller =
+      shell_delegate_->CreateTestLauncherController(profile());
 
   // Simulate login for the test controller.
-  test_launcher_controller.ReleaseProfile();
-  test_launcher_controller.AttachProfile(profile());
+  test_launcher_controller->ReleaseProfile();
+  test_launcher_controller->AttachProfile(profile());
   base::RunLoop().RunUntilIdle();
 
   TestShelfController* shelf_controller =
-      test_launcher_controller.test_shelf_controller();
+      test_launcher_controller->test_shelf_controller();
   ASSERT_TRUE(shelf_controller);
   EXPECT_EQ(ash::SHELF_ALIGNMENT_LEFT, shelf_controller->alignment());
   EXPECT_EQ(1u, shelf_controller->alignment_change_count());
   EXPECT_EQ(ash::SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS,
             shelf_controller->auto_hide());
   EXPECT_EQ(1u, shelf_controller->auto_hide_change_count());
 }
 
 // Tests that the shelf controller's changes are not wastefully echoed back.
-TEST_F(ChromeLauncherControllerImplPrefTest, DoNotEchoShelfControllerChanges) {
-  ash::ShelfModel* model = ash::Shell::Get()->shelf_controller()->model();
-  TestChromeLauncherControllerImpl test_launcher_controller(profile(), model);
-  test_launcher_controller.Init();
+TEST_F(ChromeLauncherControllerImplTest, DoNotEchoShelfControllerChanges) {
+  TestChromeLauncherControllerImpl* test_launcher_controller =
+      shell_delegate_->CreateTestLauncherController(profile());
 
   // Simulate login for the test controller.
-  test_launcher_controller.ReleaseProfile();
-  test_launcher_controller.AttachProfile(profile());
+  test_launcher_controller->ReleaseProfile();
+  test_launcher_controller->AttachProfile(profile());
   base::RunLoop().RunUntilIdle();
 
   TestShelfController* shelf_controller =
-      test_launcher_controller.test_shelf_controller();
+      test_launcher_controller->test_shelf_controller();
   ASSERT_TRUE(shelf_controller);
   EXPECT_EQ(ash::SHELF_ALIGNMENT_BOTTOM, shelf_controller->alignment());
   EXPECT_EQ(1u, shelf_controller->alignment_change_count());
   EXPECT_EQ(ash::SHELF_AUTO_HIDE_BEHAVIOR_NEVER, shelf_controller->auto_hide());
   EXPECT_EQ(1u, shelf_controller->auto_hide_change_count());
 
   // Changing settings via the shelf controller causes the launcher controller
   // to update profile prefs. The launcher controller's prefs observation should
   // not cause those same changes to be echoed back to the shelf controller.
   int64_t display_id = display::Screen::GetScreen()->GetPrimaryDisplay().id();
   shelf_controller->SetAlignment(ash::SHELF_ALIGNMENT_LEFT, display_id);
   EXPECT_EQ(2u, shelf_controller->alignment_change_count());
   shelf_controller->SetAutoHideBehavior(ash::SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS,
                                         display_id);
   EXPECT_EQ(2u, shelf_controller->auto_hide_change_count());
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(ash::SHELF_ALIGNMENT_LEFT, shelf_controller->alignment());
   EXPECT_EQ(2u, shelf_controller->alignment_change_count());
   EXPECT_EQ(ash::SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS,
             shelf_controller->auto_hide());
   EXPECT_EQ(2u, shelf_controller->auto_hide_change_count());
 
   PrefService* prefs = profile()->GetTestingPrefService();
   EXPECT_EQ("Left", prefs->GetString(prefs::kShelfAlignmentLocal));
   EXPECT_EQ("Left", prefs->GetString(prefs::kShelfAlignment));
   EXPECT_EQ("Always", prefs->GetString(prefs::kShelfAutoHideBehaviorLocal));
   EXPECT_EQ("Always", prefs->GetString(prefs::kShelfAutoHideBehavior));
 }