Pin apps from prefs on the mash 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 <stddef.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 15 matching lines @@
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "build/build_config.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"
 #include "chrome/browser/ui/ash/launcher/extension_app_window_launcher_item_controller.h"
 #include "chrome/browser/ui/ash/launcher/launcher_application_menu_item_model.h"
+#include "chrome/browser/ui/ash/launcher/launcher_controller_helper.h"
 #include "chrome/browser/ui/ash/launcher/launcher_item_controller.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/browser_with_test_window_test.h"
@@ skipping 137 matching lines @@
   int clear_count() const { return clear_count_; }
 
  private:
   int fetch_count_ = 0;
   int clear_count_ = 0;
   std::set<std::string> supported_apps_;
 
   DISALLOW_COPY_AND_ASSIGN(TestAppIconLoaderImpl);
 };
 
-// Test implementation of AppTabHelper.
-class TestAppTabHelperImpl : public ChromeLauncherController::AppTabHelper {
+// Test implementation of LauncherControllerHelper.
+class TestLauncherControllerHelper : public LauncherControllerHelper {
  public:
-  TestAppTabHelperImpl() {}
-  ~TestAppTabHelperImpl() override {}
+  TestLauncherControllerHelper() : LauncherControllerHelper(nullptr) {}
+  ~TestLauncherControllerHelper() override {}
 
-  // Sets the id for the specified tab. The id is removed if Remove() is
-  // invoked.
+  // Sets the id for the specified tab.
   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:
+  // LauncherControllerHelper:
   std::string GetAppID(content::WebContents* tab) override {
     return tab_id_map_.find(tab) != tab_id_map_.end() ? tab_id_map_[tab] :
         std::string();
   }
 
   bool IsValidIDForCurrentUser(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;
   }
 
   void SetCurrentUser(Profile* profile) override {
     // We can ignore this for now.
   }
 
  private:
   typedef std::map<content::WebContents*, std::string> TabToStringMap;
 
   TabToStringMap tab_id_map_;
 
-  DISALLOW_COPY_AND_ASSIGN(TestAppTabHelperImpl);
+  DISALLOW_COPY_AND_ASSIGN(TestLauncherControllerHelper);
 };
 
 // Test implementation of a V2 app launcher item controller.
 class TestV2AppLauncherItemController : public LauncherItemController {
  public:
   TestV2AppLauncherItemController(const std::string& app_id,
                                   ChromeLauncherController* controller)
       : LauncherItemController(LauncherItemController::TYPE_APP,
                                app_id,
                                controller) {
@@ skipping 249 matching lines @@
   }
 
   void SetAppIconLoaders(std::unique_ptr<AppIconLoader> loader1,
                          std::unique_ptr<AppIconLoader> loader2) {
     std::vector<std::unique_ptr<AppIconLoader>> loaders;
     loaders.push_back(std::move(loader1));
     loaders.push_back(std::move(loader2));
     launcher_controller_->SetAppIconLoadersForTest(loaders);
   }
 
-  void SetAppTabHelper(ChromeLauncherController::AppTabHelper* helper) {
-    launcher_controller_->SetAppTabHelperForTest(helper);
+  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();
@@ skipping 417 matching lines @@
         CreateBrowserWithTestWindowForProfile(profile));
     chrome::NewTab(browser.get());
 
     browser->window()->Show();
     NavigateAndCommitActiveTabWithTitle(browser.get(), GURL(url),
                                         ASCIIToUTF16(title));
     return browser;
   }
 
   // Creates a running V1 application.
-  // Note that with the use of the app_tab_helper as done below, this is only
-  // usable with a single v1 application.
+  // Note that with the use of the launcher_controller_helper as done below,
+  // 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);
-    // Create a new app tab helper and assign it to the launcher so that this
-    // app gets properly detected.
-    // TODO(skuhne): Create a more intelligent app tab helper which is able to
-    // detect all running apps properly.
-    TestAppTabHelperImpl* app_tab_helper = new TestAppTabHelperImpl;
-    app_tab_helper->SetAppID(
-        v1_app->browser()->tab_strip_model()->GetWebContentsAt(0),
-        app_name);
-    SetAppTabHelper(app_tab_helper);
+    // Create a new launcher controller helper and assign it to the launcher so
+    // that this app gets properly detected.
+    // TODO(skuhne): Create a more intelligent launcher contrller helper that is
+    // able to detect all running apps properly.
+    TestLauncherControllerHelper* helper = new TestLauncherControllerHelper;
+    helper->SetAppID(v1_app->browser()->tab_strip_model()->GetWebContentsAt(0),
+                     app_name);
+    SetLauncherControllerHelper(helper);
 
     NavigateAndCommitActiveTabWithTitle(
         v1_app->browser(), GURL(url), ASCIIToUTF16(""));
     return v1_app;
   }
 
   ash::test::TestSessionStateDelegate* session_delegate() {
     return static_cast<ash::test::TestSessionStateDelegate*>(
         ash::Shell::GetInstance()->session_state_delegate());
   }
@@ skipping 615 matching lines @@
   }
   SwitchActiveUser(account_id2);
   EXPECT_EQ(2, model_->item_count());
 }
 
 // Check edge cases with multi profile V1 apps in the shelf.
 TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest,
        V1AppUpdateOnUserSwitchEdgecases2) {
   // Create a browser item in the LauncherController.
   InitLauncherController();
-  TestAppTabHelperImpl* app_tab_helper = new TestAppTabHelperImpl;
-  SetAppTabHelper(app_tab_helper);
+  SetLauncherControllerHelper(new TestLauncherControllerHelper);
 
   // First test: Create an app when the user is not active.
   std::string user2 = "user2";
   TestingProfile* profile2 = CreateMultiUserProfile(user2);
   const AccountId account_id(
       multi_user_util::GetAccountIdFromProfile(profile()));
   const AccountId account_id2(
       multi_user_util::GetAccountIdFromProfile(profile2));
   SwitchActiveUser(account_id2);
   {
@@ skipping 1141 matching lines @@
   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);
+  TestLauncherControllerHelper* helper = new TestLauncherControllerHelper;
+  SetLauncherControllerHelper(helper);
 
   EXPECT_EQ(ash::TYPE_APP_LIST, model_->items()[0].type);
   EXPECT_EQ(ash::TYPE_BROWSER_SHORTCUT, 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");
+  helper->SetAppID(tab_strip_model->GetWebContentsAt(0), "1");
+  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_APP_LIST, model_->items()[0].type);
   EXPECT_EQ(ash::TYPE_BROWSER_SHORTCUT, model_->items()[1].type);
   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, model_->items()[2].type);
   EXPECT_EQ(ash::TYPE_APP_SHORTCUT, model_->items()[3].type);
@@ skipping 12 matching lines @@
   } else {
     // 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);
+  helper = new TestLauncherControllerHelper;
+  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 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);
+  TestLauncherControllerHelper* helper = new TestLauncherControllerHelper;
+  helper->SetAppID(tab_strip_model->GetWebContentsAt(0), "1");
+  SetLauncherControllerHelper(helper);
 
   // app_icon_loader is owned by ChromeLauncherController.
   TestAppIconLoaderImpl* app_icon_loader = new TestAppIconLoaderImpl;
   app_icon_loader->AddSupportedApp("1");
   SetAppIconLoader(std::unique_ptr<AppIconLoader>(app_icon_loader));
   EXPECT_EQ(0, app_icon_loader->fetch_count());
 
   launcher_controller_->PinAppWithID("1");
   ash::ShelfID id = launcher_controller_->GetShelfIDForAppID("1");
   int app_index = model_->ItemIndexByID(id);
@@ skipping 10 matching lines @@
   } else {
     // 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);
+  helper = new TestLauncherControllerHelper;
+  helper->SetAppID(tab_strip_model->GetWebContentsAt(0), "1");
+  SetLauncherControllerHelper(helper);
   // app_icon_loader is owned by ChromeLauncherController.
   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();
 
@@ skipping 68 matching lines @@
   EXPECT_EQ(1, app_icon_loader1->clear_count());
   EXPECT_EQ(1, app_icon_loader2->fetch_count());
   EXPECT_EQ(1, app_icon_loader2->clear_count());
 
   launcher_controller_->CloseLauncherItem(shelfId3);
   EXPECT_EQ(1, app_icon_loader1->fetch_count());
   EXPECT_EQ(1, app_icon_loader1->clear_count());
   EXPECT_EQ(1, app_icon_loader2->fetch_count());
   EXPECT_EQ(1, app_icon_loader2->clear_count());
 }