ash: Remove ShelfModel id conversion functions.

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 <map>
@@ skipping 828 matching lines @@
   // pinned V2 app will start with a '*' + small letter.
   std::string GetPinnedAppStatus() {
     std::string result;
     for (int i = 0; i < model_->item_count(); i++) {
       if (!result.empty())
         result.append(", ");
       switch (model_->items()[i].type) {
         case ash::TYPE_APP: {
           if (launcher_controller_->IsPlatformApp(model_->items()[i].id))
             result += "*";
-          const std::string& app =
-              launcher_controller_->GetAppIDForShelfID(model_->items()[i].id);
+          const std::string& app = model_->items()[i].id.app_id;
           EXPECT_FALSE(launcher_controller_->IsAppPinned(app));
           if (app == extension1_->id()) {
             result += "app1";
           } else if (app == extension2_->id()) {
             result += "app2";
           } else if (app == extension3_->id()) {
             result += "app3";
           } else if (app == extension4_->id()) {
             result += "app4";
           } else if (app == extension5_->id()) {
             result += "app5";
           } else if (app == extension6_->id()) {
             result += "app6";
           } else if (app == extension7_->id()) {
             result += "app7";
           } else if (app == extension8_->id()) {
             result += "app8";
           } else if (app == extension_platform_app_->id()) {
             result += "platform_app";
           } else {
             result += "unknown";
           }
           break;
         }
         case ash::TYPE_PINNED_APP: {
           if (launcher_controller_->IsPlatformApp(model_->items()[i].id))
             result += "*";
-          const std::string& app =
-              launcher_controller_->GetAppIDForShelfID(model_->items()[i].id);
+          const std::string& app = model_->items()[i].id.app_id;
           EXPECT_TRUE(launcher_controller_->IsAppPinned(app));
           if (app == extension1_->id()) {
             result += "App1";
           } else if (app == extension2_->id()) {
             result += "App2";
           } else if (app == extension3_->id()) {
             result += "App3";
           } else if (app == extension4_->id()) {
             result += "App4";
           } else if (app == extension5_->id()) {
@@ skipping 804 matching lines @@
                                       UnloadedExtensionReason::UPDATE);
   EXPECT_EQ("AppList, Chrome, App3", GetPinnedAppStatus());
 }
 
 // Test the V1 app interaction flow: run it, activate it, close it.
 TEST_F(ChromeLauncherControllerTest, V1AppRunActivateClose) {
   InitLauncherController();
   // The model should only contain the browser shortcut and app list items.
   EXPECT_EQ(2, model_->item_count());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
-  EXPECT_TRUE(
-      launcher_controller_->GetShelfIDForAppID(extension1_->id()).IsNull());
+  EXPECT_EQ(nullptr,
+            launcher_controller_->GetItem(ash::ShelfID(extension1_->id())));
 
   // Reporting that the app is running should create a new shelf item.
   launcher_controller_->SetV1AppStatus(extension1_->id(), ash::STATUS_RUNNING);
   EXPECT_EQ(3, model_->item_count());
   EXPECT_EQ(ash::TYPE_APP, model_->items()[2].type);
   EXPECT_EQ(ash::STATUS_RUNNING, model_->items()[2].status);
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
-  EXPECT_FALSE(
-      launcher_controller_->GetShelfIDForAppID(extension1_->id()).IsNull());
+  EXPECT_NE(nullptr,
+            launcher_controller_->GetItem(ash::ShelfID(extension1_->id())));
 
   // Reporting an active status should just update the existing item.
   launcher_controller_->SetV1AppStatus(extension1_->id(), ash::STATUS_ACTIVE);
   EXPECT_EQ(3, model_->item_count());
   EXPECT_EQ(ash::STATUS_ACTIVE, model_->items()[2].status);
 
   // Reporting that the app is closed should remove its shelf item.
   launcher_controller_->SetV1AppStatus(extension1_->id(), ash::STATUS_CLOSED);
   EXPECT_EQ(2, model_->item_count());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
-  EXPECT_TRUE(
-      launcher_controller_->GetShelfIDForAppID(extension1_->id()).IsNull());
+  EXPECT_EQ(nullptr,
+            launcher_controller_->GetItem(ash::ShelfID(extension1_->id())));
 
   // Reporting that the app is closed again should have no effect.
   launcher_controller_->SetV1AppStatus(extension1_->id(), ash::STATUS_CLOSED);
   EXPECT_EQ(2, model_->item_count());
 }
 
 // Test the V1 app interaction flow: pin it, run it, close it, unpin it.
 TEST_F(ChromeLauncherControllerTest, V1AppPinRunCloseUnpin) {
   InitLauncherController();
   // The model should only contain the browser shortcut and app list items.
   EXPECT_EQ(2, model_->item_count());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
-  EXPECT_TRUE(
-      launcher_controller_->GetShelfIDForAppID(extension1_->id()).IsNull());
+  EXPECT_EQ(nullptr,
+            launcher_controller_->GetItem(ash::ShelfID(extension1_->id())));
 
   // Pinning the app should create a new shelf item.
   launcher_controller_->PinAppWithID(extension1_->id());
   EXPECT_EQ(3, model_->item_count());
   EXPECT_EQ(ash::TYPE_PINNED_APP, model_->items()[2].type);
   EXPECT_EQ(ash::STATUS_CLOSED, model_->items()[2].status);
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension1_->id()));
-  EXPECT_FALSE(
-      launcher_controller_->GetShelfIDForAppID(extension1_->id()).IsNull());
+  EXPECT_NE(nullptr,
+            launcher_controller_->GetItem(ash::ShelfID(extension1_->id())));
 
   // Reporting that the app is running should just update the existing item.
   launcher_controller_->SetV1AppStatus(extension1_->id(), ash::STATUS_RUNNING);
   EXPECT_EQ(3, model_->item_count());
   EXPECT_EQ(ash::TYPE_PINNED_APP, model_->items()[2].type);
   EXPECT_EQ(ash::STATUS_RUNNING, model_->items()[2].status);
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension1_->id()));
-  EXPECT_FALSE(
-      launcher_controller_->GetShelfIDForAppID(extension1_->id()).IsNull());
+  EXPECT_NE(nullptr,
+            launcher_controller_->GetItem(ash::ShelfID(extension1_->id())));
 
   // Reporting that the app is closed should just update the existing item.
   launcher_controller_->SetV1AppStatus(extension1_->id(), ash::STATUS_CLOSED);
   EXPECT_EQ(3, model_->item_count());
   EXPECT_EQ(ash::TYPE_PINNED_APP, model_->items()[2].type);
   EXPECT_EQ(ash::STATUS_CLOSED, model_->items()[2].status);
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension1_->id()));
-  EXPECT_FALSE(
-      launcher_controller_->GetShelfIDForAppID(extension1_->id()).IsNull());
+  EXPECT_NE(nullptr,
+            launcher_controller_->GetItem(ash::ShelfID(extension1_->id())));
 
   // Unpinning the app should remove its shelf item.
   launcher_controller_->UnpinAppWithID(extension1_->id());
   EXPECT_EQ(2, model_->item_count());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
-  EXPECT_TRUE(
-      launcher_controller_->GetShelfIDForAppID(extension1_->id()).IsNull());
+  EXPECT_EQ(nullptr,
+            launcher_controller_->GetItem(ash::ShelfID(extension1_->id())));
 }
 
 // Test the V1 app interaction flow: run it, pin it, close it, unpin it.
 TEST_F(ChromeLauncherControllerTest, V1AppRunPinCloseUnpin) {
   InitLauncherController();
   // The model should only contain the browser shortcut and app list items.
   EXPECT_EQ(2, model_->item_count());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
-  EXPECT_TRUE(
-      launcher_controller_->GetShelfIDForAppID(extension1_->id()).IsNull());
+  EXPECT_EQ(nullptr,
+            launcher_controller_->GetItem(ash::ShelfID(extension1_->id())));
 
   // Reporting that the app is running should create a new shelf item.
   launcher_controller_->SetV1AppStatus(extension1_->id(), ash::STATUS_RUNNING);
   EXPECT_EQ(3, model_->item_count());
   EXPECT_EQ(ash::TYPE_APP, model_->items()[2].type);
   EXPECT_EQ(ash::STATUS_RUNNING, model_->items()[2].status);
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
-  EXPECT_FALSE(
-      launcher_controller_->GetShelfIDForAppID(extension1_->id()).IsNull());
+  EXPECT_NE(nullptr,
+            launcher_controller_->GetItem(ash::ShelfID(extension1_->id())));
 
   // Pinning the app should just update the existing item.
   launcher_controller_->PinAppWithID(extension1_->id());
   EXPECT_EQ(3, model_->item_count());
   EXPECT_EQ(ash::TYPE_PINNED_APP, model_->items()[2].type);
   EXPECT_EQ(ash::STATUS_RUNNING, model_->items()[2].status);
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension1_->id()));
-  EXPECT_FALSE(
-      launcher_controller_->GetShelfIDForAppID(extension1_->id()).IsNull());
+  EXPECT_NE(nullptr,
+            launcher_controller_->GetItem(ash::ShelfID(extension1_->id())));
 
   // Reporting that the app is closed should just update the existing item.
   launcher_controller_->SetV1AppStatus(extension1_->id(), ash::STATUS_CLOSED);
   EXPECT_EQ(3, model_->item_count());
   EXPECT_EQ(ash::TYPE_PINNED_APP, model_->items()[2].type);
   EXPECT_EQ(ash::STATUS_CLOSED, model_->items()[2].status);
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension1_->id()));
-  EXPECT_FALSE(
-      launcher_controller_->GetShelfIDForAppID(extension1_->id()).IsNull());
+  EXPECT_NE(nullptr,
+            launcher_controller_->GetItem(ash::ShelfID(extension1_->id())));
 
   // Unpinning the app should remove its shelf item.
   launcher_controller_->UnpinAppWithID(extension1_->id());
   EXPECT_EQ(2, model_->item_count());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
-  EXPECT_TRUE(
-      launcher_controller_->GetShelfIDForAppID(extension1_->id()).IsNull());
+  EXPECT_EQ(nullptr,
+            launcher_controller_->GetItem(ash::ShelfID(extension1_->id())));
 }
 
 // Test the V1 app interaction flow: pin it, run it, unpin it, close it.
 TEST_F(ChromeLauncherControllerTest, V1AppPinRunUnpinClose) {
   InitLauncherController();
   // The model should only contain the browser shortcut and app list items.
   EXPECT_EQ(2, model_->item_count());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
-  EXPECT_TRUE(
-      launcher_controller_->GetShelfIDForAppID(extension1_->id()).IsNull());
+  EXPECT_EQ(nullptr,
+            launcher_controller_->GetItem(ash::ShelfID(extension1_->id())));
 
   // Pinning the app should create a new shelf item.
   launcher_controller_->PinAppWithID(extension1_->id());
   EXPECT_EQ(3, model_->item_count());
   EXPECT_EQ(ash::TYPE_PINNED_APP, model_->items()[2].type);
   EXPECT_EQ(ash::STATUS_CLOSED, model_->items()[2].status);
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension1_->id()));
-  EXPECT_FALSE(
-      launcher_controller_->GetShelfIDForAppID(extension1_->id()).IsNull());
+  EXPECT_NE(nullptr,
+            launcher_controller_->GetItem(ash::ShelfID(extension1_->id())));
 
   // Reporting that the app is running should just update the existing item.
   launcher_controller_->SetV1AppStatus(extension1_->id(), ash::STATUS_RUNNING);
   EXPECT_EQ(3, model_->item_count());
   EXPECT_EQ(ash::TYPE_PINNED_APP, model_->items()[2].type);
   EXPECT_EQ(ash::STATUS_RUNNING, model_->items()[2].status);
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension1_->id()));
-  EXPECT_FALSE(
-      launcher_controller_->GetShelfIDForAppID(extension1_->id()).IsNull());
+  EXPECT_NE(nullptr,
+            launcher_controller_->GetItem(ash::ShelfID(extension1_->id())));
 
   // Unpinning the app should just update the existing item.
   launcher_controller_->UnpinAppWithID(extension1_->id());
   EXPECT_EQ(3, model_->item_count());
   EXPECT_EQ(ash::TYPE_APP, model_->items()[2].type);
   EXPECT_EQ(ash::STATUS_RUNNING, model_->items()[2].status);
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
-  EXPECT_FALSE(
-      launcher_controller_->GetShelfIDForAppID(extension1_->id()).IsNull());
+  EXPECT_NE(nullptr,
+            launcher_controller_->GetItem(ash::ShelfID(extension1_->id())));
 
   // Reporting that the app is closed should remove its shelf item.
   launcher_controller_->SetV1AppStatus(extension1_->id(), ash::STATUS_CLOSED);
   EXPECT_EQ(2, model_->item_count());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension1_->id()));
-  EXPECT_TRUE(
-      launcher_controller_->GetShelfIDForAppID(extension1_->id()).IsNull());
+  EXPECT_EQ(nullptr,
+            launcher_controller_->GetItem(ash::ShelfID(extension1_->id())));
 }
 
 // Ensure unpinned V1 app ordering is properly restored after user changes.
 TEST_F(ChromeLauncherControllerTest, CheckRunningV1AppOrder) {
   InitLauncherController();
   // The model should only contain the browser shortcut and app list items.
   EXPECT_EQ(2, model_->item_count());
 
   // Add a few running applications.
   launcher_controller_->SetV1AppStatus(extension1_->id(), ash::STATUS_RUNNING);
@@ skipping 49 matching lines @@
   const std::string arc_app_id1 = ArcAppTest::GetAppId(app1);
   const std::string arc_app_id2 = ArcAppTest::GetAppId(app2);
   const std::string arc_app_id3 = ArcAppTest::GetAppId(app3);
   const std::string arc_shortcut_id = ArcAppTest::GetAppId(shortcut);
 
   SendListOfArcApps();
   SendListOfArcShortcuts();
 
   arc_test_.StopArcInstance();
 
-  EXPECT_TRUE(launcher_controller_->GetShelfIDForAppID(arc_app_id1).IsNull());
-  EXPECT_TRUE(launcher_controller_->GetShelfIDForAppID(arc_app_id2).IsNull());
-  EXPECT_TRUE(launcher_controller_->GetShelfIDForAppID(arc_app_id3).IsNull());
-  EXPECT_TRUE(
-      launcher_controller_->GetShelfIDForAppID(arc_shortcut_id).IsNull());
+  const ash::ShelfID shelf_id_app_1(arc_app_id1);
+  const ash::ShelfID shelf_id_app_2(arc_app_id2);
+  const ash::ShelfID shelf_id_app_3(arc_app_id3);
+  const ash::ShelfID shelf_id_shortcut(arc_shortcut_id);
+  EXPECT_FALSE(launcher_controller_->GetItem(shelf_id_app_1));
+  EXPECT_FALSE(launcher_controller_->GetItem(shelf_id_app_2));
+  EXPECT_FALSE(launcher_controller_->GetItem(shelf_id_app_3));
+  EXPECT_FALSE(launcher_controller_->GetItem(shelf_id_shortcut));
 
   arc::LaunchApp(profile(), arc_app_id1, ui::EF_LEFT_MOUSE_BUTTON);
   arc::LaunchApp(profile(), arc_app_id1, ui::EF_LEFT_MOUSE_BUTTON);
   arc::LaunchApp(profile(), arc_app_id2, ui::EF_LEFT_MOUSE_BUTTON);
   arc::LaunchApp(profile(), arc_app_id3, ui::EF_LEFT_MOUSE_BUTTON);
   arc::LaunchApp(profile(), arc_shortcut_id, ui::EF_LEFT_MOUSE_BUTTON);
 
-  const ash::ShelfID shelf_id_app_1 =
-      launcher_controller_->GetShelfIDForAppID(arc_app_id1);
-  const ash::ShelfID shelf_id_app_2 =
-      launcher_controller_->GetShelfIDForAppID(arc_app_id2);
-  const ash::ShelfID shelf_id_app_3 =
-      launcher_controller_->GetShelfIDForAppID(arc_app_id3);
-  const ash::ShelfID shelf_id_shortcut =
-      launcher_controller_->GetShelfIDForAppID(arc_shortcut_id);
-  EXPECT_FALSE(shelf_id_app_1.IsNull());
-  EXPECT_FALSE(shelf_id_app_2.IsNull());
-  EXPECT_FALSE(shelf_id_app_3.IsNull());
-  EXPECT_FALSE(shelf_id_shortcut.IsNull());
+  EXPECT_TRUE(launcher_controller_->GetItem(shelf_id_app_1));
+  EXPECT_TRUE(launcher_controller_->GetItem(shelf_id_app_2));
+  EXPECT_TRUE(launcher_controller_->GetItem(shelf_id_app_3));
+  EXPECT_TRUE(launcher_controller_->GetItem(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);
   ASSERT_NE(nullptr, item_delegate);
   item_delegate->Close();
   base::RunLoop().RunUntilIdle();
 
-  EXPECT_TRUE(launcher_controller_->GetShelfIDForAppID(arc_app_id1).IsNull());
-  EXPECT_EQ(shelf_id_app_2,
-            launcher_controller_->GetShelfIDForAppID(arc_app_id2));
-  EXPECT_EQ(shelf_id_app_3,
-            launcher_controller_->GetShelfIDForAppID(arc_app_id3));
+  EXPECT_FALSE(launcher_controller_->GetItem(shelf_id_app_1));
+  EXPECT_TRUE(launcher_controller_->GetItem(shelf_id_app_2));
+  EXPECT_TRUE(launcher_controller_->GetItem(shelf_id_app_3));
+  EXPECT_TRUE(launcher_controller_->GetItem(shelf_id_shortcut));
 
   arc_test_.RestartArcInstance();
   SendListOfArcApps();
 
   base::RunLoop().RunUntilIdle();
 
   // Now deferred contollers should go away together with shelf items and ARC
   // app instance should receive request for launching apps and shortcuts.
-  EXPECT_TRUE(launcher_controller_->GetShelfIDForAppID(arc_app_id1).IsNull());
-  EXPECT_TRUE(launcher_controller_->GetShelfIDForAppID(arc_app_id2).IsNull());
-  EXPECT_TRUE(launcher_controller_->GetShelfIDForAppID(arc_app_id3).IsNull());
+  EXPECT_FALSE(launcher_controller_->GetItem(shelf_id_app_1));
+  EXPECT_FALSE(launcher_controller_->GetItem(shelf_id_app_2));
+  EXPECT_FALSE(launcher_controller_->GetItem(shelf_id_app_3));
+  EXPECT_FALSE(launcher_controller_->GetItem(shelf_id_shortcut));
 
   ASSERT_EQ(2U, arc_test_.app_instance()->launch_requests().size());
   ASSERT_EQ(1U, arc_test_.app_instance()->launch_intents().size());
 
   const arc::FakeAppInstance::Request* request1 =
       arc_test_.app_instance()->launch_requests()[0].get();
   const arc::FakeAppInstance::Request* request2 =
       arc_test_.app_instance()->launch_requests()[1].get();
 
   EXPECT_TRUE((request1->IsForApp(app2) && request2->IsForApp(app3)) ||
               (request1->IsForApp(app3) && request2->IsForApp(app2)));
   EXPECT_EQ(arc_test_.app_instance()->launch_intents()[0].c_str(),
             shortcut.intent_uri);
 }
 
 // Ensure the deferred controller does not override the active app controller
 // (crbug.com/701152).
 TEST_P(ChromeLauncherControllerWithArcTest, ArcDeferredLaunchForActiveApp) {
   InitLauncherController();
   SendListOfArcApps();
   arc_test_.StopArcInstance();
 
   const arc::mojom::AppInfo& app = arc_test_.fake_apps()[0];
   const std::string app_id = ArcAppTest::GetAppId(app);
 
   launcher_controller_->PinAppWithID(app_id);
   EXPECT_TRUE(launcher_controller_->IsAppPinned(app_id));
-  const ash::ShelfID shelf_id =
-      launcher_controller_->GetShelfIDForAppID(app_id);
-  EXPECT_FALSE(shelf_id.IsNull());
-
-  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);
+  const ash::ShelfID shelf_id(app_id);
+  const ash::ShelfItem* item = launcher_controller_->GetItem(shelf_id);
+  ASSERT_NE(nullptr, item);
+  EXPECT_EQ(ash::STATUS_CLOSED, item->status);
+  EXPECT_EQ(ash::TYPE_PINNED_APP, item->type);
 
   // Play Store app is ARC app that might be represented by native Chrome
   // platform app.
   model_->SetShelfItemDelegate(
-      shelf_id, base::MakeUnique<ExtensionAppWindowLauncherItemController>(
-                    ash::ShelfID(app_id)));
+      shelf_id,
+      base::MakeUnique<ExtensionAppWindowLauncherItemController>(shelf_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.
+  // Closing the app should leave a pinned but closed shelf item shortcut.
   launcher_controller_->CloseLauncherItem(shelf_id);
-  EXPECT_EQ(shelf_id, launcher_controller_->GetShelfIDForAppID(app_id));
-
-  // This should switch shelf item into closed state.
-  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);
+  item = launcher_controller_->GetItem(shelf_id);
+  ASSERT_NE(nullptr, item);
+  EXPECT_EQ(ash::STATUS_CLOSED, item->status);
+  EXPECT_EQ(ash::TYPE_PINNED_APP, item->type);
 
   // Now launch request should not be ignored.
   arc::LaunchApp(profile(), app_id, ui::EF_LEFT_MOUSE_BUTTON);
   EXPECT_TRUE(launcher_controller_->GetArcDeferredLauncher()->HasApp(app_id));
 }
 
 TEST_P(ChromeLauncherControllerMultiProfileWithArcTest, ArcMultiUser) {
   SendListOfArcApps();
 
   InitLauncherController();
@@ skipping 18 matching lines @@
       ArcAppTest::GetAppId(arc_test_.fake_apps()[0]);
   const std::string arc_app_id2 =
       ArcAppTest::GetAppId(arc_test_.fake_apps()[1]);
   const std::string arc_app_id3 =
       ArcAppTest::GetAppId(arc_test_.fake_apps()[2]);
 
   std::string window_app_id1("org.chromium.arc.1");
   views::Widget* arc_window1 = CreateArcWindow(window_app_id1);
   arc_test_.app_instance()->SendTaskCreated(1, arc_test_.fake_apps()[0],
                                             std::string());
-  EXPECT_FALSE(launcher_controller_->GetShelfIDForAppID(arc_app_id1).IsNull());
+  EXPECT_TRUE(launcher_controller_->GetItem(ash::ShelfID(arc_app_id1)));
 
   std::string window_app_id2("org.chromium.arc.2");
   views::Widget* arc_window2 = CreateArcWindow(window_app_id2);
   arc_test_.app_instance()->SendTaskCreated(2, arc_test_.fake_apps()[1],
                                             std::string());
-  EXPECT_FALSE(launcher_controller_->GetShelfIDForAppID(arc_app_id2).IsNull());
+  EXPECT_TRUE(launcher_controller_->GetItem(ash::ShelfID(arc_app_id2)));
 
   launcher_controller_->SetProfileForTest(profile2);
   SwitchActiveUser(account_id2);
 
-  EXPECT_TRUE(launcher_controller_->GetShelfIDForAppID(arc_app_id1).IsNull());
-  EXPECT_TRUE(launcher_controller_->GetShelfIDForAppID(arc_app_id2).IsNull());
+  EXPECT_FALSE(launcher_controller_->GetItem(ash::ShelfID(arc_app_id1)));
+  EXPECT_FALSE(launcher_controller_->GetItem(ash::ShelfID(arc_app_id2)));
 
   std::string window_app_id3("org.chromium.arc.3");
   views::Widget* arc_window3 = CreateArcWindow(window_app_id3);
   arc_test_.app_instance()->SendTaskCreated(3, arc_test_.fake_apps()[2],
                                             std::string());
-  EXPECT_TRUE(launcher_controller_->GetShelfIDForAppID(arc_app_id3).IsNull());
+  EXPECT_FALSE(launcher_controller_->GetItem(ash::ShelfID(arc_app_id3)));
 
   arc_window2->CloseNow();
   arc_test_.app_instance()->SendTaskDestroyed(2);
 
   launcher_controller_->SetProfileForTest(profile());
   SwitchActiveUser(account_id);
 
-  EXPECT_FALSE(launcher_controller_->GetShelfIDForAppID(arc_app_id1).IsNull());
-  EXPECT_TRUE(launcher_controller_->GetShelfIDForAppID(arc_app_id2).IsNull());
-  EXPECT_FALSE(launcher_controller_->GetShelfIDForAppID(arc_app_id3).IsNull());
+  EXPECT_TRUE(launcher_controller_->GetItem(ash::ShelfID(arc_app_id1)));
+  EXPECT_FALSE(launcher_controller_->GetItem(ash::ShelfID(arc_app_id2)));
+  EXPECT_TRUE(launcher_controller_->GetItem(ash::ShelfID(arc_app_id3)));
 
   // Close active window to let test passes.
   arc_window1->CloseNow();
   arc_window3->CloseNow();
 }
 
 TEST_P(ChromeLauncherControllerWithArcTest, ArcRunningApp) {
   InitLauncherController();
 
   const std::string arc_app_id = ArcAppTest::GetAppId(arc_test_.fake_apps()[0]);
   SendListOfArcApps();
-  EXPECT_TRUE(launcher_controller_->GetShelfIDForAppID(arc_app_id).IsNull());
+  EXPECT_FALSE(launcher_controller_->GetItem(ash::ShelfID(arc_app_id)));
 
   // Normal flow, create/destroy tasks.
   std::string window_app_id1("org.chromium.arc.1");
   std::string window_app_id2("org.chromium.arc.2");
   std::string window_app_id3("org.chromium.arc.3");
   CreateArcWindow(window_app_id1);
   arc_test_.app_instance()->SendTaskCreated(1, arc_test_.fake_apps()[0],
                                             std::string());
-  EXPECT_FALSE(launcher_controller_->GetShelfIDForAppID(arc_app_id).IsNull());
+  EXPECT_TRUE(launcher_controller_->GetItem(ash::ShelfID(arc_app_id)));
   CreateArcWindow(window_app_id2);
   arc_test_.app_instance()->SendTaskCreated(2, arc_test_.fake_apps()[0],
                                             std::string());
-  EXPECT_FALSE(launcher_controller_->GetShelfIDForAppID(arc_app_id).IsNull());
+  EXPECT_TRUE(launcher_controller_->GetItem(ash::ShelfID(arc_app_id)));
   arc_test_.app_instance()->SendTaskDestroyed(1);
-  EXPECT_FALSE(launcher_controller_->GetShelfIDForAppID(arc_app_id).IsNull());
+  EXPECT_TRUE(launcher_controller_->GetItem(ash::ShelfID(arc_app_id)));
   arc_test_.app_instance()->SendTaskDestroyed(2);
-  EXPECT_TRUE(launcher_controller_->GetShelfIDForAppID(arc_app_id).IsNull());
+  EXPECT_FALSE(launcher_controller_->GetItem(ash::ShelfID(arc_app_id)));
 
   // Stopping bridge removes apps.
   CreateArcWindow(window_app_id3);
   arc_test_.app_instance()->SendTaskCreated(3, arc_test_.fake_apps()[0],
                                             std::string());
-  EXPECT_FALSE(launcher_controller_->GetShelfIDForAppID(arc_app_id).IsNull());
+  EXPECT_TRUE(launcher_controller_->GetItem(ash::ShelfID(arc_app_id)));
   arc_test_.StopArcInstance();
   base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(launcher_controller_->GetShelfIDForAppID(arc_app_id).IsNull());
+  EXPECT_FALSE(launcher_controller_->GetItem(ash::ShelfID(arc_app_id)));
 }
 
 // Test race creation/deletion of ARC app.
 // TODO(khmel): Remove after moving everything to wayland protocol.
 TEST_P(ChromeLauncherControllerWithArcTest, ArcRaceCreateClose) {
   InitLauncherController();
 
   const std::string arc_app_id1 =
       ArcAppTest::GetAppId(arc_test_.fake_apps()[0]);
   const std::string arc_app_id2 =
       ArcAppTest::GetAppId(arc_test_.fake_apps()[1]);
   SendListOfArcApps();
 
   // ARC window created before and closed after mojom notification.
   std::string window_app_id1("org.chromium.arc.1");
   views::Widget* arc_window = CreateArcWindow(window_app_id1);
-  EXPECT_TRUE(launcher_controller_->GetShelfIDForAppID(arc_app_id1).IsNull());
+  EXPECT_FALSE(launcher_controller_->GetItem(ash::ShelfID(arc_app_id1)));
   ASSERT_TRUE(arc_window);
   arc_test_.app_instance()->SendTaskCreated(1, arc_test_.fake_apps()[0],
                                             std::string());
-  EXPECT_FALSE(launcher_controller_->GetShelfIDForAppID(arc_app_id1).IsNull());
+  EXPECT_TRUE(launcher_controller_->GetItem(ash::ShelfID(arc_app_id1)));
   arc_test_.app_instance()->SendTaskDestroyed(1);
-  EXPECT_TRUE(launcher_controller_->GetShelfIDForAppID(arc_app_id1).IsNull());
+  EXPECT_FALSE(launcher_controller_->GetItem(ash::ShelfID(arc_app_id1)));
   arc_window->Close();
   base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(launcher_controller_->GetShelfIDForAppID(arc_app_id1).IsNull());
+  EXPECT_FALSE(launcher_controller_->GetItem(ash::ShelfID(arc_app_id1)));
 
   // ARC window created after and closed before mojom notification.
   std::string window_app_id2("org.chromium.arc.2");
   arc_test_.app_instance()->SendTaskCreated(2, arc_test_.fake_apps()[1],
                                             std::string());
-  EXPECT_FALSE(launcher_controller_->GetShelfIDForAppID(arc_app_id2).IsNull());
+  EXPECT_TRUE(launcher_controller_->GetItem(ash::ShelfID(arc_app_id2)));
   arc_window = CreateArcWindow(window_app_id2);
   ASSERT_TRUE(arc_window);
-  EXPECT_FALSE(launcher_controller_->GetShelfIDForAppID(arc_app_id2).IsNull());
+  EXPECT_TRUE(launcher_controller_->GetItem(ash::ShelfID(arc_app_id2)));
   arc_window->Close();
   base::RunLoop().RunUntilIdle();
   // Closing window does not close shelf item. It is closed on task destroy.
-  EXPECT_FALSE(launcher_controller_->GetShelfIDForAppID(arc_app_id2).IsNull());
+  EXPECT_TRUE(launcher_controller_->GetItem(ash::ShelfID(arc_app_id2)));
   arc_test_.app_instance()->SendTaskDestroyed(2);
-  EXPECT_TRUE(launcher_controller_->GetShelfIDForAppID(arc_app_id2).IsNull());
+  EXPECT_FALSE(launcher_controller_->GetItem(ash::ShelfID(arc_app_id2)));
 }
 
 TEST_P(ChromeLauncherControllerWithArcTest, ArcWindowRecreation) {
   InitLauncherController();
 
   const std::string arc_app_id = ArcAppTest::GetAppId(arc_test_.fake_apps()[0]);
   SendListOfArcApps();
 
   std::string window_app_id("org.chromium.arc.1");
   views::Widget* arc_window = CreateArcWindow(window_app_id);
   ASSERT_TRUE(arc_window);
   arc_test_.app_instance()->SendTaskCreated(1, arc_test_.fake_apps()[0],
                                             std::string());
-  const ash::ShelfID shelf_id =
-      launcher_controller_->GetShelfIDForAppID(arc_app_id);
-  EXPECT_FALSE(shelf_id.IsNull());
+  EXPECT_TRUE(launcher_controller_->GetItem(ash::ShelfID(arc_app_id)));
 
   for (int i = 0; i < 3; ++i) {
     arc_window->Close();
     base::RunLoop().RunUntilIdle();
-    EXPECT_EQ(shelf_id, launcher_controller_->GetShelfIDForAppID(arc_app_id));
+    EXPECT_TRUE(launcher_controller_->GetItem(ash::ShelfID(arc_app_id)));
 
     arc_window = CreateArcWindow(window_app_id);
     ASSERT_TRUE(arc_window);
     base::RunLoop().RunUntilIdle();
-    EXPECT_EQ(shelf_id, launcher_controller_->GetShelfIDForAppID(arc_app_id));
+    EXPECT_TRUE(launcher_controller_->GetItem(ash::ShelfID(arc_app_id)));
   }
 }
 
 // Validate that ARC app is pinned correctly and pin is removed automatically
 // once app is uninstalled.
 TEST_P(ChromeLauncherControllerWithArcTest, ArcAppPin) {
   InitLauncherController();
 
   const std::string arc_app_id = ArcAppTest::GetAppId(arc_test_.fake_apps()[0]);
 
@@ skipping 674 matching lines @@
 // Check that browsers get reflected correctly in the launcher menu.
 TEST_F(ChromeLauncherControllerTest, BrowserMenuGeneration) {
   EXPECT_EQ(1U, chrome::GetTotalBrowserCount());
   chrome::NewTab(browser());
 
   InitLauncherController();
 
   // Check that the browser list is empty at this time.
   ash::ShelfItem item_browser;
   item_browser.type = ash::TYPE_BROWSER_SHORTCUT;
-  item_browser.id =
-      launcher_controller_->GetShelfIDForAppID(extension_misc::kChromeAppId);
+  item_browser.id = ash::ShelfID(extension_misc::kChromeAppId);
   CheckAppMenu(launcher_controller_, item_browser, 0, nullptr);
 
   // Now make the created browser() visible by showing its browser window.
   browser()->window()->Show();
   base::string16 title1 = ASCIIToUTF16("Test1");
   NavigateAndCommitActiveTabWithTitle(browser(), GURL("http://test1"), title1);
   base::string16 one_menu_item[] = {title1};
 
   CheckAppMenu(launcher_controller_, item_browser, 1, one_menu_item);
 
@@ skipping 16 matching lines @@
 }
 
 // Check the multi profile case where only user related browsers should show up.
 TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest,
        BrowserMenuGenerationTwoUsers) {
   // Create a browser item in the LauncherController.
   InitLauncherController();
 
   ash::ShelfItem item_browser;
   item_browser.type = ash::TYPE_BROWSER_SHORTCUT;
-  item_browser.id =
-      launcher_controller_->GetShelfIDForAppID(extension_misc::kChromeAppId);
+  item_browser.id = ash::ShelfID(extension_misc::kChromeAppId);
 
   // Check that the menu is empty.
   chrome::NewTab(browser());
   CheckAppMenu(launcher_controller_, item_browser, 0, nullptr);
 
   // Show the created |browser()| by showing its window.
   browser()->window()->Show();
   base::string16 title1 = ASCIIToUTF16("Test1");
   NavigateAndCommitActiveTabWithTitle(browser(), GURL("http://test1"), title1);
   base::string16 one_menu_item1[] = {title1};
@@ skipping 30 matching lines @@
 TEST_F(ChromeLauncherControllerTest, V1AppMenuGeneration) {
   EXPECT_EQ(1U, chrome::GetTotalBrowserCount());
   EXPECT_EQ(0, browser()->tab_strip_model()->count());
 
   InitLauncherControllerWithBrowser();
 
   // The model should only contain the browser shortcut and app list items.
   EXPECT_EQ(2, model_->item_count());
   EXPECT_FALSE(launcher_controller_->IsAppPinned(extension3_->id()));
 
-  // Installing |extension3_| adds it to the launcher.
+  // Installing |extension3_| pins it to the launcher.
   const ash::ShelfID gmail_id(extension3_->id());
   extension_service_->AddExtension(extension3_.get());
-  EXPECT_EQ(3, model_->item_count());
-  int gmail_index = model_->ItemIndexByID(gmail_id);
-  EXPECT_EQ(ash::TYPE_PINNED_APP, model_->items()[gmail_index].type);
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension3_->id()));
   launcher_controller_->SetRefocusURLPatternForTest(gmail_id, GURL(kGmailUrl));
 
   // Check the menu content.
   ash::ShelfItem item_browser;
   item_browser.type = ash::TYPE_BROWSER_SHORTCUT;
-  item_browser.id =
-      launcher_controller_->GetShelfIDForAppID(extension_misc::kChromeAppId);
+  item_browser.id = ash::ShelfID(extension_misc::kChromeAppId);
 
   ash::ShelfItem item_gmail;
   item_gmail.type = ash::TYPE_PINNED_APP;
   item_gmail.id = gmail_id;
   CheckAppMenu(launcher_controller_, item_gmail, 0, nullptr);
 
   // Set the gmail URL to a new tab.
   base::string16 title1 = ASCIIToUTF16("Test1");
   NavigateAndCommitActiveTabWithTitle(browser(), GURL(kGmailUrl), title1);
 
@@ skipping 26 matching lines @@
   CheckAppMenu(launcher_controller_, item_browser, 1, browser_menu_item2);
 }
 
 // Check the multi profile case where only user related apps should show up.
 TEST_F(MultiProfileMultiBrowserShelfLayoutChromeLauncherControllerTest,
        V1AppMenuGenerationTwoUsers) {
   // Create a browser item in the LauncherController.
   InitLauncherController();
   chrome::NewTab(browser());
 
-  // Installing |extension3_| adds it to the launcher.
+  // Installing |extension3_| pins it to the launcher.
   const ash::ShelfID gmail_id(extension3_->id());
   extension_service_->AddExtension(extension3_.get());
-  EXPECT_EQ(3, model_->item_count());
-  int gmail_index = model_->ItemIndexByID(gmail_id);
-  EXPECT_EQ(ash::TYPE_PINNED_APP, model_->items()[gmail_index].type);
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension3_->id()));
   launcher_controller_->SetRefocusURLPatternForTest(gmail_id, GURL(kGmailUrl));
 
   // Check the menu content.
   ash::ShelfItem item_browser;
   item_browser.type = ash::TYPE_BROWSER_SHORTCUT;
-  item_browser.id =
-      launcher_controller_->GetShelfIDForAppID(extension_misc::kChromeAppId);
+  item_browser.id = ash::ShelfID(extension_misc::kChromeAppId);
 
   ash::ShelfItem item_gmail;
   item_gmail.type = ash::TYPE_PINNED_APP;
   item_gmail.id = gmail_id;
   CheckAppMenu(launcher_controller_, item_gmail, 0, nullptr);
 
   // Set the gmail URL to a new tab.
   base::string16 title1 = ASCIIToUTF16("Test1");
   NavigateAndCommitActiveTabWithTitle(browser(), GURL(kGmailUrl), title1);
 
@@ skipping 339 matching lines @@
   // Make an app panel; the ShelfItem is added by ash::ShelfWindowWatcher.
   std::unique_ptr<V2App> app_panel1 = base::MakeUnique<V2App>(
       profile(), extension1_.get(), extensions::AppWindow::WINDOW_TYPE_PANEL);
   EXPECT_TRUE(app_panel1->window()->GetNativeWindow()->IsVisible());
   int panel_index = model_observer_->last_index();
   EXPECT_EQ(1, model_observer_->added());
   EXPECT_EQ(1, app_icon_loader->fetch_count());
   model_observer_->clear_counts();
 
   // App panels should have a separate identifier than the app id
-  EXPECT_TRUE(launcher_controller_->GetShelfIDForAppID(app_id).IsNull());
+  EXPECT_FALSE(launcher_controller_->GetItem(ash::ShelfID(app_id)));
 
   // Setting the app image should not change the panel, which has a window icon.
   gfx::ImageSkia image;
   launcher_controller_->OnAppImageUpdated(app_id, image);
   EXPECT_EQ(0, model_observer_->changed());
   model_observer_->clear_counts();
 
   // Make a second app panel and verify that it gets the same index as the first
   // panel, being added to the left of the existing panel.
   std::unique_ptr<V2App> app_panel2 = base::MakeUnique<V2App>(
@@ skipping 15 matching lines @@
   // Create a Gmail browser tab.
   chrome::NewTab(browser());
   base::string16 title = ASCIIToUTF16("Test");
   NavigateAndCommitActiveTabWithTitle(browser(), GURL(kGmailUrl), title);
   content::WebContents* content =
       browser()->tab_strip_model()->GetActiveWebContents();
 
   // Check that the launcher controller does not recognize the running app.
   EXPECT_FALSE(launcher_controller_->ContentCanBeHandledByGmailApp(content));
 
-  // Installing |extension3_| adds it to the launcher.
+  // Installing |extension3_| pins it to the launcher.
   const ash::ShelfID gmail_id(extension3_->id());
   extension_service_->AddExtension(extension3_.get());
-  EXPECT_EQ(3, model_->item_count());
-  int gmail_index = model_->ItemIndexByID(gmail_id);
-  EXPECT_EQ(ash::TYPE_PINNED_APP, model_->items()[gmail_index].type);
   EXPECT_TRUE(launcher_controller_->IsAppPinned(extension3_->id()));
 
   // Check that it is now handled.
   EXPECT_TRUE(launcher_controller_->ContentCanBeHandledByGmailApp(content));
 
   // Check also that the app has detected that properly.
   ash::ShelfItem item_gmail;
   item_gmail.type = ash::TYPE_PINNED_APP;
   item_gmail.id = gmail_id;
   EXPECT_EQ(1U,
             launcher_controller_->GetAppMenuItemsForTesting(item_gmail).size());
 }
 
 // Tests that the Gmail extension does not match the offline verison.
 TEST_F(ChromeLauncherControllerTest, GmailOfflineMatching) {
   InitLauncherControllerWithBrowser();
 
   // Create a Gmail browser tab.
   chrome::NewTab(browser());
   base::string16 title = ASCIIToUTF16("Test");
   NavigateAndCommitActiveTabWithTitle(browser(), GURL(kOfflineGmailUrl), title);
   content::WebContents* content =
       browser()->tab_strip_model()->GetActiveWebContents();
 
-  // Installing |extension3_| adds it to the launcher.
+  // Installing |extension3_| pins it to the launcher.
   const ash::ShelfID gmail_id(extension3_->id());
   extension_service_->AddExtension(extension3_.get());
-  EXPECT_EQ(3, model_->item_count());
-  int gmail_index = model_->ItemIndexByID(gmail_id);
-  EXPECT_EQ(ash::TYPE_PINNED_APP, model_->items()[gmail_index].type);
   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();
 
@@ skipping 54 matching lines @@
   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);
+  const int app_index = model_->ItemIndexByID(ash::ShelfID("1"));
   EXPECT_EQ(1, app_icon_loader->fetch_count());
   EXPECT_EQ(ash::TYPE_PINNED_APP, 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());
 
   RecreateLauncherController();
   helper = new TestLauncherControllerHelper(profile());
   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));
   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_PINNED_APP, model_->items()[app_index].type);
 
   launcher_controller_->UnpinAppWithID("1");
   ASSERT_EQ(initial_size, model_->items().size());
 }
 
 TEST_F(ChromeLauncherControllerTest, MultipleAppIconLoaders) {
   InitLauncherControllerWithBrowser();
 
-  const std::string app_id1 = extension1_->id();
-  const std::string app_id2 = extension2_->id();
-  const std::string app_id3 = extension3_->id();
+  const ash::ShelfID shelf_id1(extension1_->id());
+  const ash::ShelfID shelf_id2(extension2_->id());
+  const ash::ShelfID shelf_id3(extension3_->id());
   // app_icon_loader1 and app_icon_loader2 are owned by
   // ChromeLauncherController.
   TestAppIconLoaderImpl* app_icon_loader1 = new TestAppIconLoaderImpl();
   TestAppIconLoaderImpl* app_icon_loader2 = new TestAppIconLoaderImpl();
-  app_icon_loader1->AddSupportedApp(app_id1);
-  app_icon_loader2->AddSupportedApp(app_id2);
+  app_icon_loader1->AddSupportedApp(shelf_id1.app_id);
+  app_icon_loader2->AddSupportedApp(shelf_id2.app_id);
   SetAppIconLoaders(std::unique_ptr<AppIconLoader>(app_icon_loader1),
                     std::unique_ptr<AppIconLoader>(app_icon_loader2));
 
-  const ash::ShelfID shelfId3 = launcher_controller_->CreateAppLauncherItem(
-      base::MakeUnique<ExtensionAppWindowLauncherItemController>(
-          ash::ShelfID(app_id3)),
+  launcher_controller_->CreateAppLauncherItem(
+      base::MakeUnique<ExtensionAppWindowLauncherItemController>(shelf_id3),
       ash::STATUS_RUNNING);
   EXPECT_EQ(0, app_icon_loader1->fetch_count());
   EXPECT_EQ(0, app_icon_loader1->clear_count());
   EXPECT_EQ(0, app_icon_loader2->fetch_count());
   EXPECT_EQ(0, app_icon_loader2->clear_count());
 
-  const ash::ShelfID shelfId2 = launcher_controller_->CreateAppLauncherItem(
-      base::MakeUnique<ExtensionAppWindowLauncherItemController>(
-          ash::ShelfID(app_id2)),
+  launcher_controller_->CreateAppLauncherItem(
+      base::MakeUnique<ExtensionAppWindowLauncherItemController>(shelf_id2),
       ash::STATUS_RUNNING);
   EXPECT_EQ(0, app_icon_loader1->fetch_count());
   EXPECT_EQ(0, app_icon_loader1->clear_count());
   EXPECT_EQ(1, app_icon_loader2->fetch_count());
   EXPECT_EQ(0, app_icon_loader2->clear_count());
 
-  const ash::ShelfID shelfId1 = launcher_controller_->CreateAppLauncherItem(
-      base::MakeUnique<ExtensionAppWindowLauncherItemController>(
-          ash::ShelfID(app_id1)),
+  launcher_controller_->CreateAppLauncherItem(
+      base::MakeUnique<ExtensionAppWindowLauncherItemController>(shelf_id1),
       ash::STATUS_RUNNING);
   EXPECT_EQ(1, app_icon_loader1->fetch_count());
   EXPECT_EQ(0, app_icon_loader1->clear_count());
   EXPECT_EQ(1, app_icon_loader2->fetch_count());
   EXPECT_EQ(0, app_icon_loader2->clear_count());
 
-  launcher_controller_->CloseLauncherItem(shelfId1);
+  launcher_controller_->CloseLauncherItem(shelf_id1);
   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(0, app_icon_loader2->clear_count());
 
-  launcher_controller_->CloseLauncherItem(shelfId2);
+  launcher_controller_->CloseLauncherItem(shelf_id2);
   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());
 
-  launcher_controller_->CloseLauncherItem(shelfId3);
+  launcher_controller_->CloseLauncherItem(shelf_id3);
   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());
 }
 
 TEST_P(ChromeLauncherControllerWithArcTest, ArcAppPinPolicy) {
   InitLauncherControllerWithBrowser();
   arc::mojom::AppInfo appinfo = CreateAppInfo(
       "Some App", "SomeActivity", "com.example.app", OrientationLock::NONE);
@@ skipping 88 matching lines @@
   EXPECT_TRUE(window1->IsActive());
 
   NotifyOnTaskCreated(appinfo, 2 /* task_id */);
   views::Widget* window2 = CreateArcWindow("org.chromium.arc.2");
   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);
+      model_->GetShelfItemDelegate(ash::ShelfID(app_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 278 matching lines @@
   // Prevent safe decoding which requires IPC.
   ArcAppIcon::DisableSafeDecodingForTesting();
 
   ArcAppListPrefs* const prefs = arc_test_.arc_app_list_prefs();
   EnablePlayStore(false);
   EXPECT_FALSE(arc::IsArcPlayStoreEnabledForProfile(profile()));
   ASSERT_TRUE(prefs->GetAppIds().size());
 
   const std::string app_id =
       ArcAppTest::GetAppId(arc_test_.fake_default_apps()[0]);
-  EXPECT_TRUE(launcher_controller_->GetShelfIDForAppID(app_id).IsNull());
+  EXPECT_FALSE(launcher_controller_->GetItem(ash::ShelfID(app_id)));
   EXPECT_TRUE(arc::LaunchApp(profile(), app_id, ui::EF_LEFT_MOUSE_BUTTON));
   EXPECT_TRUE(arc::IsArcPlayStoreEnabledForProfile(profile()));
-  EXPECT_FALSE(launcher_controller_->GetShelfIDForAppID(app_id).IsNull());
+  EXPECT_TRUE(launcher_controller_->GetItem(ash::ShelfID(app_id)));
 
   // Stop ARC again. Shelf item should go away.
   EnablePlayStore(false);
-  EXPECT_TRUE(launcher_controller_->GetShelfIDForAppID(app_id).IsNull());
+  EXPECT_FALSE(launcher_controller_->GetItem(ash::ShelfID(app_id)));
 
   EXPECT_TRUE(arc::LaunchApp(profile(), app_id, ui::EF_LEFT_MOUSE_BUTTON));
   EXPECT_TRUE(arc::IsArcPlayStoreEnabledForProfile(profile()));
-
-  EXPECT_FALSE(launcher_controller_->GetShelfIDForAppID(app_id).IsNull());
+  EXPECT_TRUE(launcher_controller_->GetItem(ash::ShelfID(app_id)));
   EXPECT_TRUE(launcher_controller_->GetArcDeferredLauncher()->HasApp(app_id));
 
   std::string window_app_id("org.chromium.arc.1");
   CreateArcWindow(window_app_id);
   arc_test_.app_instance()->SendTaskCreated(1, arc_test_.fake_default_apps()[0],
                                             std::string());
-
-  EXPECT_FALSE(launcher_controller_->GetShelfIDForAppID(app_id).IsNull());
+  EXPECT_TRUE(launcher_controller_->GetItem(ash::ShelfID(app_id)));
   EXPECT_FALSE(launcher_controller_->GetArcDeferredLauncher()->HasApp(app_id));
 }
 
 TEST_P(ChromeLauncherControllerArcDefaultAppsTest, PlayStoreDeferredLaunch) {
   // Add ARC host app to enable Play Store default app.
   extension_service_->AddExtension(arc_support_host_.get());
   arc_test_.SetUp(profile());
   ArcAppListPrefs* const prefs = arc_test_.arc_app_list_prefs();
   EXPECT_TRUE(prefs->IsRegistered(arc::kPlayStoreAppId));
 
   InitLauncherController();
 
   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 =
+      model_->GetShelfItemDelegate(ash::ShelfID(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(ChromeLauncherControllerTest, CheckPositionConflict) {
@@ skipping 136 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));
 }