Revert of mash: Remove ChromeLauncherController's |id_to_item_controller_map_|.

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 143 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 532 matching lines @@
     app_list_specifics->set_item_id(extension_misc::kChromeAppId);
     app_list_specifics->set_item_type(sync_pb::AppListSpecifics::TYPE_APP);
     app_list_specifics->set_item_pin_ordinal(chrome_position.ToInternalValue());
     syncer::SyncData sync_data = syncer::SyncData::CreateLocalData(
         extension_misc::kChromeAppId, "Test", specifics);
     sync_list.push_back(syncer::SyncChange(
         FROM_HERE, syncer::SyncChange::ACTION_UPDATE, sync_data));
     app_service_->ProcessSyncChanges(FROM_HERE, sync_list);
   }
 
-  // Gets the IDs of the currently pinned app items.
-  void GetPinnedAppIds(ChromeLauncherControllerImpl* controller,
-                       std::vector<std::string>* app_ids) {
-    app_ids->clear();
-    for (const auto& item : model_->items()) {
-      if (item.type == ash::TYPE_PINNED_APP)
-        app_ids->push_back(item.app_launch_id.app_id());
+  // Gets the currently configured app launchers from the controller.
+  void GetAppLaunchers(ChromeLauncherControllerImpl* controller,
+                       std::vector<std::string>* launchers) {
+    launchers->clear();
+    for (ash::ShelfItems::const_iterator iter(model_->items().begin());
+         iter != model_->items().end(); ++iter) {
+      ChromeLauncherControllerImpl::IDToItemControllerMap::const_iterator entry(
+          controller->id_to_item_controller_map_.find(iter->id));
+      if (iter->type == ash::TYPE_PINNED_APP &&
+          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++) {
@@ skipping 1126 matching lines @@
   const ash::ShelfID shelf_id_shortcut =
       launcher_controller_->GetShelfIDForAppID(arc_shortcut_id);
   EXPECT_NE(ash::kInvalidShelfID, shelf_id_app_1);
   EXPECT_NE(ash::kInvalidShelfID, shelf_id_app_2);
   EXPECT_NE(ash::kInvalidShelfID, shelf_id_app_3);
   EXPECT_NE(ash::kInvalidShelfID, shelf_id_shortcut);
 
   // We activated arc_app_id1 twice but expect one close for item controller
   // stops launching request.
   ash::ShelfItemDelegate* item_delegate =
-      model_->GetShelfItemDelegate(shelf_id_app_1);
+      launcher_controller_->GetShelfItemDelegate(shelf_id_app_1);
   ASSERT_NE(nullptr, item_delegate);
   item_delegate->Close();
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(ash::kInvalidShelfID,
             launcher_controller_->GetShelfIDForAppID(arc_app_id1));
   EXPECT_EQ(shelf_id_app_2,
             launcher_controller_->GetShelfIDForAppID(arc_app_id2));
   EXPECT_EQ(shelf_id_app_3,
             launcher_controller_->GetShelfIDForAppID(arc_app_id3));
@@ skipping 43 matching lines @@
   EXPECT_NE(ash::kInvalidShelfID, shelf_id);
 
   int item_index = model_->ItemIndexByID(shelf_id);
   ASSERT_GE(item_index, 0);
 
   EXPECT_EQ(model_->items()[item_index].status, ash::STATUS_CLOSED);
   EXPECT_EQ(model_->items()[item_index].type, ash::TYPE_PINNED_APP);
 
   // Play Store app is ARC app that might be represented by native Chrome
   // platform app.
-  model_->SetShelfItemDelegate(
+  launcher_controller_->SetShelfItemDelegate(
       shelf_id, base::MakeUnique<ExtensionAppWindowLauncherItemController>(
                     ash::AppLaunchId(app_id)));
   launcher_controller_->SetItemStatus(shelf_id, ash::STATUS_RUNNING);
 
   // This launch request should be ignored in case of active app.
   arc::LaunchApp(profile(), app_id, ui::EF_LEFT_MOUSE_BUTTON);
   EXPECT_FALSE(launcher_controller_->GetArcDeferredLauncher()->HasApp(app_id));
 
   // Close app but shortcut should exist.
   launcher_controller_->CloseLauncherItem(shelf_id);
@@ skipping 457 matching lines @@
 
   // Create a second test profile. The first is the one in profile() created in
   // BrowserWithTestWindowTest::SetUp().
   // No need to add the profiles to the MultiUserWindowManager here.
   // CreateMultiUserProfile() already does that.
   TestingProfile* profile2 = CreateMultiUserProfile("user2");
   const AccountId current_user =
       multi_user_util::GetAccountIdFromProfile(profile());
 
   // Create a browser window with a native window for the current user.
+  Browser::CreateParams params(profile(), true);
   std::unique_ptr<Browser> browser(
-      CreateBrowserWithTestWindowForProfile(profile()));
+      chrome::CreateBrowserWithAuraTestWindowForParams(nullptr, &params));
   BrowserWindow* browser_window = browser->window();
   aura::Window* window = browser_window->GetNativeWindow();
   manager->SetWindowOwner(window, current_user);
 
   // Check that an activation of the window on its owner's desktop does not
   // change the visibility to another user.
   launcher_controller_->ActivateWindowOrMinimizeIfActive(browser_window, false);
   EXPECT_TRUE(manager->IsWindowOnDesktopOfUser(window, current_user));
 
   // Transfer the window to another user's desktop and check that activating it
@@ skipping 255 matching lines @@
   extension_service_->AddExtension(extension2_.get());
   extension_service_->AddExtension(extension3_.get());
   extension_service_->AddExtension(extension4_.get());
 
   InitLauncherController();
 
   syncer::SyncChangeList sync_list;
   InsertAddPinChange(&sync_list, 10, extension_misc::kChromeAppId);
   SendPinChanges(sync_list, true);
 
-  std::vector<std::string> expected_pinned_apps;
-  std::vector<std::string> actual_pinned_apps;
-  GetPinnedAppIds(launcher_controller_, &actual_pinned_apps);
-  EXPECT_EQ(expected_pinned_apps, actual_pinned_apps);
+  std::vector<std::string> expected_launchers;
+  std::vector<std::string> actual_launchers;
+  GetAppLaunchers(launcher_controller_, &actual_launchers);
+  EXPECT_EQ(expected_launchers, actual_launchers);
 
   // Unavailable extensions don't create launcher items.
   sync_list.clear();
   InsertAddPinChange(&sync_list, 0, extension1_->id());
   InsertAddPinChange(&sync_list, 1, extension2_->id());
   InsertAddPinChange(&sync_list, 3, extension4_->id());
   SendPinChanges(sync_list, false);
 
-  expected_pinned_apps.push_back(extension2_->id());
-  expected_pinned_apps.push_back(extension4_->id());
-  GetPinnedAppIds(launcher_controller_, &actual_pinned_apps);
-  EXPECT_EQ(expected_pinned_apps, actual_pinned_apps);
+  expected_launchers.push_back(extension2_->id());
+  expected_launchers.push_back(extension4_->id());
+  GetAppLaunchers(launcher_controller_, &actual_launchers);
+  EXPECT_EQ(expected_launchers, actual_launchers);
 
   sync_list.clear();
   InsertAddPinChange(&sync_list, 2, extension3_->id());
   SendPinChanges(sync_list, false);
-  expected_pinned_apps.insert(expected_pinned_apps.begin() + 1,
-                              extension3_->id());
-  GetPinnedAppIds(launcher_controller_, &actual_pinned_apps);
-  EXPECT_EQ(expected_pinned_apps, actual_pinned_apps);
+  expected_launchers.insert(expected_launchers.begin() + 1, extension3_->id());
+  GetAppLaunchers(launcher_controller_, &actual_launchers);
+  EXPECT_EQ(expected_launchers, actual_launchers);
 
   sync_list.clear();
   InsertUpdatePinChange(&sync_list, 0, extension4_->id());
   InsertUpdatePinChange(&sync_list, 1, extension3_->id());
   InsertUpdatePinChange(&sync_list, 2, extension2_->id());
   SendPinChanges(sync_list, false);
-  std::reverse(expected_pinned_apps.begin(), expected_pinned_apps.end());
-  GetPinnedAppIds(launcher_controller_, &actual_pinned_apps);
-  EXPECT_EQ(expected_pinned_apps, actual_pinned_apps);
+  std::reverse(expected_launchers.begin(), expected_launchers.end());
+  GetAppLaunchers(launcher_controller_, &actual_launchers);
+  EXPECT_EQ(expected_launchers, actual_launchers);
 
   // Sending legacy sync change without pin info should not affect pin model.
   sync_list.clear();
   InsertLegacyPinChange(&sync_list, extension4_->id());
   SendPinChanges(sync_list, false);
-  GetPinnedAppIds(launcher_controller_, &actual_pinned_apps);
-  EXPECT_EQ(expected_pinned_apps, actual_pinned_apps);
+  GetAppLaunchers(launcher_controller_, &actual_launchers);
+  EXPECT_EQ(expected_launchers, actual_launchers);
 
   sync_list.clear();
   InsertRemovePinChange(&sync_list, extension4_->id());
   SendPinChanges(sync_list, false);
-  expected_pinned_apps.erase(expected_pinned_apps.begin());
-  GetPinnedAppIds(launcher_controller_, &actual_pinned_apps);
-  EXPECT_EQ(expected_pinned_apps, actual_pinned_apps);
+  expected_launchers.erase(expected_launchers.begin());
+  GetAppLaunchers(launcher_controller_, &actual_launchers);
+  EXPECT_EQ(expected_launchers, actual_launchers);
 
   sync_list.clear();
   InsertRemovePinChange(&sync_list, extension3_->id());
   InsertRemovePinChange(&sync_list, extension2_->id());
   SendPinChanges(sync_list, false);
-  expected_pinned_apps.clear();
-  GetPinnedAppIds(launcher_controller_, &actual_pinned_apps);
-  EXPECT_EQ(expected_pinned_apps, actual_pinned_apps);
+  expected_launchers.clear();
+  GetAppLaunchers(launcher_controller_, &actual_launchers);
+  EXPECT_EQ(expected_launchers, actual_launchers);
 }
 
 TEST_F(ChromeLauncherControllerImplTest, ImportLegacyPin) {
   // Note extension3_ is actually Gmail app which is default pinned.
   extension_service_->AddExtension(extension3_.get());
   InitLauncherController();
 
   // Default pins should contain Gmail. Pref is not syncing now.
   EXPECT_EQ("AppList, Chrome, App3", GetPinnedAppStatus());
 
@@ skipping 41 matching lines @@
   extension_service_->AddExtension(extension3_.get());
 
   InitLauncherController();
 
   syncer::SyncChangeList sync_list;
   InsertAddPinChange(&sync_list, 0, extension1_->id());
   InsertAddPinChange(&sync_list, 1, extension2_->id());
   InsertAddPinChange(&sync_list, 2, extension3_->id());
   SendPinChanges(sync_list, true);
 
-  std::vector<std::string> expected_pinned_apps;
-  expected_pinned_apps.push_back(extension1_->id());
-  expected_pinned_apps.push_back(extension3_->id());
-  std::vector<std::string> actual_pinned_apps;
+  std::vector<std::string> expected_launchers;
+  expected_launchers.push_back(extension1_->id());
+  expected_launchers.push_back(extension3_->id());
+  std::vector<std::string> actual_launchers;
 
-  GetPinnedAppIds(launcher_controller_, &actual_pinned_apps);
-  EXPECT_EQ(expected_pinned_apps, actual_pinned_apps);
+  GetAppLaunchers(launcher_controller_, &actual_launchers);
+  EXPECT_EQ(expected_launchers, actual_launchers);
 
   // Install |extension2| and verify it shows up between the other two.
   extension_service_->AddExtension(extension2_.get());
-  expected_pinned_apps.insert(expected_pinned_apps.begin() + 1,
-                              extension2_->id());
-  GetPinnedAppIds(launcher_controller_, &actual_pinned_apps);
-  EXPECT_EQ(expected_pinned_apps, actual_pinned_apps);
+  expected_launchers.insert(expected_launchers.begin() + 1, extension2_->id());
+  GetAppLaunchers(launcher_controller_, &actual_launchers);
+  EXPECT_EQ(expected_launchers, actual_launchers);
 }
 
 // Ensure |controller| creates the expected menu items for the given shelf item.
 void CheckAppMenu(ChromeLauncherControllerImpl* controller,
                   const ash::ShelfItem& item,
                   size_t expected_item_count,
                   base::string16 expected_item_titles[]) {
   ash::MenuItemList items = controller->GetAppMenuItemsForTesting(item);
   ASSERT_EQ(expected_item_count, items.size());
   for (size_t i = 0; i < expected_item_count; i++)
@@ skipping 439 matching lines @@
   base::string16 title2 = ASCIIToUTF16("Test2");
   NavigateAndCommitActiveTabWithTitle(browser(), GURL(gmail_url), title2);
 
   // Check that the menu is properly set.
   ash::ShelfItem item_gmail;
   item_gmail.type = ash::TYPE_PINNED_APP;
   item_gmail.id = gmail_id;
   base::string16 two_menu_items[] = {title1, title2};
   CheckAppMenu(launcher_controller_, item_gmail, 2, two_menu_items);
   ash::ShelfItemDelegate* item_delegate =
-      model_->GetShelfItemDelegate(gmail_id);
+      launcher_controller_->GetShelfItemDelegate(gmail_id);
   ASSERT_TRUE(item_delegate);
   EXPECT_EQ(1, browser()->tab_strip_model()->active_index());
   // Execute the second item in the menu, after the title and two separators,
   // this shouldn't do anything since that item is already the active tab.
   {
     ash::ShelfApplicationMenuModel menu(
         base::string16(),
         launcher_controller_->GetAppMenuItemsForTesting(item_gmail),
         item_delegate);
     menu.ActivatedAt(4);
@@ skipping 28 matching lines @@
   NavigateAndCommitActiveTabWithTitle(browser(), GURL(gmail_url), title2);
 
   // Check that the menu is properly set.
   ash::ShelfItem item_gmail;
   item_gmail.type = ash::TYPE_PINNED_APP;
   item_gmail.id = gmail_id;
   base::string16 two_menu_items[] = {title1, title2};
   CheckAppMenu(launcher_controller_, item_gmail, 2, two_menu_items);
 
   ash::ShelfItemDelegate* item_delegate =
-      model_->GetShelfItemDelegate(gmail_id);
+      launcher_controller_->GetShelfItemDelegate(gmail_id);
   ASSERT_TRUE(item_delegate);
   int tabs = browser()->tab_strip_model()->count();
   // Activate the proper tab through the menu item.
   {
     ash::MenuItemList items =
         launcher_controller_->GetAppMenuItemsForTesting(item_gmail);
     item_delegate->ExecuteCommand(items[1]->command_id, ui::EF_NONE);
     EXPECT_EQ(tabs, browser()->tab_strip_model()->count());
   }
 
@@ skipping 364 matching lines @@
   ASSERT_TRUE(window2);
 
   EXPECT_FALSE(window1->IsActive());
   EXPECT_TRUE(window2->IsActive());
 
   const std::string app_id = ArcAppTest::GetAppId(appinfo);
 
   const ash::ShelfID shelf_id =
       launcher_controller_->GetShelfIDForAppID(app_id);
   ash::ShelfItemDelegate* item_delegate =
-      model_->GetShelfItemDelegate(shelf_id);
+      launcher_controller_->GetShelfItemDelegate(shelf_id);
   ASSERT_TRUE(item_delegate);
 
   // Selecting the item will show its application menu. It does not change the
   // active window.
   SelectItem(item_delegate);
   EXPECT_FALSE(window1->IsActive());
   EXPECT_TRUE(window2->IsActive());
 
   // Command ids are just app window indices. Note, apps are registered in
   // opposite order. Last created goes in front.
@@ skipping 325 matching lines @@
 
   EnablePlayStore(true);
 
   // Pin Play Store. It should be pinned but not scheduled for deferred launch.
   launcher_controller_->PinAppWithID(arc::kPlayStoreAppId);
   EXPECT_TRUE(launcher_controller_->IsAppPinned(arc::kPlayStoreAppId));
   EXPECT_FALSE(launcher_controller_->GetArcDeferredLauncher()->HasApp(
       arc::kPlayStoreAppId));
 
   // Simulate click. This should schedule Play Store for deferred launch.
-  ash::ShelfItemDelegate* item_delegate = model_->GetShelfItemDelegate(
-      launcher_controller_->GetShelfIDForAppID(arc::kPlayStoreAppId));
+  ash::ShelfItemDelegate* item_delegate =
+      launcher_controller_->GetShelfItemDelegate(
+          launcher_controller_->GetShelfIDForAppID(arc::kPlayStoreAppId));
   EXPECT_TRUE(item_delegate);
   SelectItem(item_delegate);
   EXPECT_TRUE(launcher_controller_->IsAppPinned(arc::kPlayStoreAppId));
   EXPECT_TRUE(launcher_controller_->GetArcDeferredLauncher()->HasApp(
       arc::kPlayStoreAppId));
 }
 
 // Checks the case when several app items have the same ordinal position (which
 // is valid case).
 TEST_F(ChromeLauncherControllerImplTest, CheckPositionConflict) {
@@ skipping 218 matching lines @@
   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));
 }