mash: Replace int ShelfIDs with AppLaunchID strings.

chrome/browser/ui/ash/launcher/chrome_launcher_controller.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 "ash/multi_profile_uma.h"
 #include "ash/public/cpp/shelf_item.h"
 #include "ash/public/interfaces/constants.mojom.h"
 #include "ash/resources/grit/ash_resources.h"
@@ skipping 282 matching lines @@
       ash::launcher::ChromeLauncherPrefsObserver::CreateIfNecessary(profile());
 }
 
 ash::ShelfID ChromeLauncherController::CreateAppLauncherItem(
     std::unique_ptr<ash::ShelfItemDelegate> item_delegate,
     ash::ShelfItemStatus status) {
   return InsertAppLauncherItem(std::move(item_delegate), status,
                                model_->item_count(), ash::TYPE_APP);
 }
 
-const ash::ShelfItem* ChromeLauncherController::GetItem(ash::ShelfID id) const {
+const ash::ShelfItem* ChromeLauncherController::GetItem(
+    const ash::ShelfID& id) const {
   const int index = model_->ItemIndexByID(id);
   if (index >= 0 && index < model_->item_count())
     return &model_->items()[index];
   return nullptr;
 }
 
-void ChromeLauncherController::SetItemType(ash::ShelfID id,
+void ChromeLauncherController::SetItemType(const ash::ShelfID& id,
                                            ash::ShelfItemType type) {
   const ash::ShelfItem* item = GetItem(id);
   if (item && item->type != type) {
     ash::ShelfItem new_item = *item;
     new_item.type = type;
     model_->Set(model_->ItemIndexByID(id), new_item);
   }
 }
 
-void ChromeLauncherController::SetItemStatus(ash::ShelfID id,
+void ChromeLauncherController::SetItemStatus(const ash::ShelfID& id,
                                              ash::ShelfItemStatus status) {
   const ash::ShelfItem* item = GetItem(id);
   if (item && item->status != status) {
     ash::ShelfItem new_item = *item;
     new_item.status = status;
     model_->Set(model_->ItemIndexByID(id), new_item);
   }
 }
 
-void ChromeLauncherController::CloseLauncherItem(ash::ShelfID id) {
-  CHECK(id);
+void ChromeLauncherController::CloseLauncherItem(const ash::ShelfID& id) {
+  CHECK(!id.IsEmpty());
   if (IsPinned(id)) {
     // Create a new shortcut delegate.
     SetItemStatus(id, ash::STATUS_CLOSED);
-    model_->SetShelfItemDelegate(id, AppShortcutLauncherItemController::Create(
-                                         GetItem(id)->app_launch_id));
+    model_->SetShelfItemDelegate(id,
+                                 AppShortcutLauncherItemController::Create(id));
   } else {
     RemoveShelfItem(id);
   }
 }
 
-void ChromeLauncherController::UnpinShelfItemInternal(ash::ShelfID id) {
+void ChromeLauncherController::UnpinShelfItemInternal(const ash::ShelfID& id) {
   const ash::ShelfItem* item = GetItem(id);
   if (item && item->status != ash::STATUS_CLOSED)
     UnpinRunningAppInternal(model_->ItemIndexByID(id));
   else
     RemoveShelfItem(id);
 }
 
-bool ChromeLauncherController::IsPinned(ash::ShelfID id) {
+bool ChromeLauncherController::IsPinned(const ash::ShelfID& id) {
   const ash::ShelfItem* item = GetItem(id);
   return item && ItemTypeIsPinned(*item);
 }
 
 void ChromeLauncherController::SetV1AppStatus(const std::string& app_id,
                                               ash::ShelfItemStatus status) {
   ash::ShelfID id = GetShelfIDForAppID(app_id);
   const ash::ShelfItem* item = GetItem(id);
   if (item) {
     if (!IsPinned(id) && status == ash::STATUS_CLOSED)
       RemoveShelfItem(id);
     else
       SetItemStatus(id, status);
   } else if (status != ash::STATUS_CLOSED && !app_id.empty()) {
     InsertAppLauncherItem(
-        AppShortcutLauncherItemController::Create(ash::AppLaunchId(app_id)),
-        status, model_->item_count(), ash::TYPE_APP);
+        AppShortcutLauncherItemController::Create(ash::ShelfID(app_id)), status,
+        model_->item_count(), ash::TYPE_APP);
   }
 }
 
-void ChromeLauncherController::Launch(ash::ShelfID id, int event_flags) {
-  ash::ShelfItemDelegate* delegate = model_->GetShelfItemDelegate(id);
-  if (!delegate)
-    return;  // In case invoked from menu and item closed while menu up.
-
-  // Launching some items replaces the associated item delegate instance,
-  // which destroys the app and launch id strings; making copies avoid crashes.
-  LaunchApp(ash::AppLaunchId(delegate->app_id(), delegate->launch_id()),
-            ash::LAUNCH_FROM_UNKNOWN, event_flags);
+void ChromeLauncherController::Launch(const ash::ShelfID& id, int event_flags) {
+  LaunchApp(id, ash::LAUNCH_FROM_UNKNOWN, event_flags);

[James Cook, 2017/05/04 16:38:49]

Double-checking: We don't need to copy the ID anymore? Who owns the |id| when
this is called?

[msw, 2017/05/04 19:05:57]

This should be fine. The one caller, LauncherContextMenu::ExecuteCommand, passes
in the id from a ShelfItem that it owns, which should not be destroyed here.

 }
 
-void ChromeLauncherController::Close(ash::ShelfID id) {
+void ChromeLauncherController::Close(const ash::ShelfID& id) {
   ash::ShelfItemDelegate* delegate = model_->GetShelfItemDelegate(id);
   if (!delegate)
     return;  // May happen if menu closed.
   delegate->Close();
 }
 
-bool ChromeLauncherController::IsOpen(ash::ShelfID id) {
+bool ChromeLauncherController::IsOpen(const ash::ShelfID& id) {
   const ash::ShelfItem* item = GetItem(id);
   return item && item->status != ash::STATUS_CLOSED;
 }
 
-bool ChromeLauncherController::IsPlatformApp(ash::ShelfID id) {
+bool ChromeLauncherController::IsPlatformApp(const ash::ShelfID& id) {
   std::string app_id = GetAppIDForShelfID(id);
   const extensions::Extension* extension =
       GetExtensionForAppID(app_id, profile());
   // An extension can be synced / updated at any time and therefore not be
   // available.
   return extension ? extension->is_platform_app() : false;
 }
 
-void ChromeLauncherController::LaunchApp(ash::AppLaunchId id,
+void ChromeLauncherController::LaunchApp(const ash::ShelfID& id,
                                          ash::ShelfLaunchSource source,
                                          int event_flags) {
   launcher_controller_helper_->LaunchApp(id, source, event_flags);
 }
 
 void ChromeLauncherController::ActivateApp(const std::string& app_id,
                                            ash::ShelfLaunchSource source,
                                            int event_flags) {
-  // If there is an existing non-shortcut delegate for this app, open it.
-  ash::ShelfID id = GetShelfIDForAppID(app_id);
-  if (id) {
-    SelectItemWithSource(model_->GetShelfItemDelegate(id), source);
+  // If there is an existing delegate for this app, select it.
+  const ash::ShelfID shelf_id(app_id);
+  ash::ShelfItemDelegate* delegate = model_->GetShelfItemDelegate(shelf_id);
+  if (delegate) {
+    SelectItemWithSource(delegate, source);
     return;
   }
 
-  // Create a temporary application launcher item and use it to see if there are
-  // running instances.
-  ash::AppLaunchId app_launch_id(app_id);
+  // Create a temporary delegate to see if there are running app instances.
   std::unique_ptr<AppShortcutLauncherItemController> item_delegate =
-      AppShortcutLauncherItemController::Create(app_launch_id);
+      AppShortcutLauncherItemController::Create(shelf_id);
   if (!item_delegate->GetRunningApplications().empty())
     SelectItemWithSource(item_delegate.get(), source);
   else
-    LaunchApp(app_launch_id, source, event_flags);
+    LaunchApp(shelf_id, source, event_flags);
 }
 
 void ChromeLauncherController::SetLauncherItemImage(
-    ash::ShelfID shelf_id,
+    const ash::ShelfID& shelf_id,
     const gfx::ImageSkia& image) {
   const ash::ShelfItem* item = GetItem(shelf_id);
   if (item) {
     ash::ShelfItem new_item = *item;
     new_item.image = image;
     model_->Set(model_->ItemIndexByID(shelf_id), new_item);
   }
 }
 
 void ChromeLauncherController::UpdateAppState(content::WebContents* contents,
                                               AppState app_state) {
   std::string app_id = launcher_controller_helper_->GetAppID(contents);
 
   // Check if the gMail app is loaded and it matches the given content.
   // This special treatment is needed to address crbug.com/234268.
   if (app_id.empty() && ContentCanBeHandledByGmailApp(contents))
     app_id = kGmailAppId;
 
   // Check the old |app_id| for a tab. If the contents has changed we need to
   // remove it from the previous app.
   if (web_contents_to_app_id_.find(contents) != web_contents_to_app_id_.end()) {
     std::string last_app_id = web_contents_to_app_id_[contents];
     if (last_app_id != app_id) {
       ash::ShelfID id = GetShelfIDForAppID(last_app_id);
-      if (id) {
+      if (!id.IsEmpty()) {
         // Since GetAppState() will use |web_contents_to_app_id_| we remove
         // the connection before calling it.
         web_contents_to_app_id_.erase(contents);
         SetItemStatus(id, GetAppState(last_app_id));
       }
     }
   }
 
   if (app_state == APP_STATE_REMOVED)
     web_contents_to_app_id_.erase(contents);
   else
     web_contents_to_app_id_[contents] = app_id;
 
   ash::ShelfID id = GetShelfIDForAppID(app_id);
-  if (id) {
+  if (!id.IsEmpty()) {
     SetItemStatus(id, (app_state == APP_STATE_WINDOW_ACTIVE ||
                        app_state == APP_STATE_ACTIVE)
                           ? ash::STATUS_ACTIVE
                           : GetAppState(app_id));
   }
 }
 
 ash::ShelfID ChromeLauncherController::GetShelfIDForWebContents(
     content::WebContents* contents) {
   std::string app_id = launcher_controller_helper_->GetAppID(contents);
   if (app_id.empty() && ContentCanBeHandledByGmailApp(contents))
     app_id = kGmailAppId;
 
   ash::ShelfID id = GetShelfIDForAppID(app_id);
   // If there is no dedicated app item, use the browser shortcut item.
-  return id == ash::kInvalidShelfID ? GetShelfIDForAppID(kChromeAppId) : id;
+  return id.IsEmpty() ? GetShelfIDForAppID(kChromeAppId) : id;
 }
 
-void ChromeLauncherController::SetRefocusURLPatternForTest(ash::ShelfID id,
-                                                           const GURL& url) {
+void ChromeLauncherController::SetRefocusURLPatternForTest(
+    const ash::ShelfID& id,
+    const GURL& url) {
   const ash::ShelfItem* item = GetItem(id);
   if (item && !IsPlatformApp(id) &&
       (item->type == ash::TYPE_PINNED_APP || item->type == ash::TYPE_APP)) {
     ash::ShelfItemDelegate* delegate = model_->GetShelfItemDelegate(id);
     AppShortcutLauncherItemController* item_controller =
         static_cast<AppShortcutLauncherItemController*>(delegate);
     item_controller->set_refocus_url(url);
   } else {
     NOTREACHED() << "Invalid launcher item or type";
   }
@@ skipping 107 matching lines @@
   if ((web_contents_to_app_id_.find(web_contents) !=
        web_contents_to_app_id_.end()) &&
       (web_contents_to_app_id_[web_contents] == app_id))
     return true;
   return (app_id == kGmailAppId && ContentCanBeHandledByGmailApp(web_contents));
 }
 
 bool ChromeLauncherController::ContentCanBeHandledByGmailApp(
     content::WebContents* web_contents) {
   ash::ShelfID id = GetShelfIDForAppID(kGmailAppId);
-  if (id) {
+  if (!id.IsEmpty()) {
     const GURL url = web_contents->GetURL();
     // We need to extend the application matching for the gMail app beyond the
     // manifest file's specification. This is required because of the namespace
     // overlap with the offline app ("/mail/mu/").
     if (!base::MatchPattern(url.path(), "/mail/mu/*") &&
         base::MatchPattern(url.path(), "/mail/*") &&
         GetExtensionForAppID(kGmailAppId, profile()) &&
         GetExtensionForAppID(kGmailAppId, profile())->OverlapsWithOrigin(url))
       return true;
   }
@@ skipping 67 matching lines @@
   if (user_switch_observer_.get())
     user_switch_observer_->OnUserProfileReadyToSwitch(profile);
 }
 
 ArcAppDeferredLauncherController*
 ChromeLauncherController::GetArcDeferredLauncher() {
   return arc_deferred_launcher_.get();
 }
 
 const std::string& ChromeLauncherController::GetLaunchIDForShelfID(
-    ash::ShelfID id) {
+    const ash::ShelfID& id) {
   ash::ShelfItemDelegate* delegate = model_->GetShelfItemDelegate(id);
   return delegate ? delegate->launch_id() : base::EmptyString();
 }
 
 AppIconLoader* ChromeLauncherController::GetAppIconLoaderForApp(
     const std::string& app_id) {
   for (const auto& app_icon_loader : app_icon_loaders_) {
     if (app_icon_loader->CanLoadImageForApp(app_id))
       return app_icon_loader.get();
   }
@@ skipping 61 matching lines @@
   return model_->GetShelfIDForAppID(app_id);
 }
 
 ash::ShelfID ChromeLauncherController::GetShelfIDForAppIDAndLaunchID(
     const std::string& app_id,
     const std::string& launch_id) {
   return model_->GetShelfIDForAppIDAndLaunchID(app_id, launch_id);
 }
 
 const std::string& ChromeLauncherController::GetAppIDForShelfID(
-    ash::ShelfID id) {
+    const ash::ShelfID& id) {
   return model_->GetAppIDForShelfID(id);
 }
 
 void ChromeLauncherController::PinAppWithID(const std::string& app_id) {
   model_->PinAppWithID(app_id);
 }
 
 bool ChromeLauncherController::IsAppPinned(const std::string& app_id) {
   return model_->IsAppPinned(app_id);
 }
@@ skipping 28 matching lines @@
     app_icon_loader->UpdateImage(app_id);
 }
 
 void ChromeLauncherController::OnAppUninstalledPrepared(
     content::BrowserContext* browser_context,
     const std::string& app_id) {
   // Since we might have windowed apps of this type which might have
   // outstanding locks which needs to be removed.
   const Profile* profile = Profile::FromBrowserContext(browser_context);
   ash::ShelfID shelf_id = GetShelfIDForAppID(app_id);
-  if (shelf_id != ash::kInvalidShelfID)
+  if (!shelf_id.IsEmpty())
     CloseWindowedAppsFromRemovedExtension(app_id, profile);
 
   if (IsAppPinned(app_id)) {
-    if (profile == this->profile() && shelf_id != ash::kInvalidShelfID) {
+    if (profile == this->profile() && !shelf_id.IsEmpty()) {
       // Some apps may be removed locally. Unpin the item without removing the
       // pin position from profile preferences. When needed, it is automatically
       // deleted on app list model update.
       UnpinShelfItemInternal(shelf_id);
     }
     AppIconLoader* app_icon_loader = GetAppIconLoaderForApp(app_id);
     if (app_icon_loader)
       app_icon_loader->ClearImage(app_id);
   }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // AppIconLoaderDelegate:
 
 void ChromeLauncherController::OnAppImageUpdated(const std::string& app_id,
                                                  const gfx::ImageSkia& image) {
   // TODO: need to get this working for shortcuts.
   for (int index = 0; index < model_->item_count(); ++index) {
     ash::ShelfItem item = model_->items()[index];
     ash::ShelfItemDelegate* delegate = model_->GetShelfItemDelegate(item.id);
     if (item.type == ash::TYPE_APP_PANEL || !delegate ||
-        delegate->image_set_by_controller() ||
-        item.app_launch_id.app_id() != app_id) {
+        delegate->image_set_by_controller() || item.id.app_id() != app_id) {
       continue;
     }
     item.image = image;
     if (arc_deferred_launcher_)
       arc_deferred_launcher_->MaybeApplySpinningEffect(app_id, &item.image);
     model_->Set(index, item);
     // It's possible we're waiting on more than one item, so don't break.
   }
 }
 
@@ skipping 11 matching lines @@
     return false;
 
   connector->BindInterface(ash::mojom::kServiceName, &shelf_controller_);
   return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // ChromeLauncherController private:
 
 ash::ShelfID ChromeLauncherController::CreateAppShortcutLauncherItem(
-    const ash::AppLaunchId& app_launch_id,
+    const ash::ShelfID& shelf_id,
     int index) {
   return InsertAppLauncherItem(
-      AppShortcutLauncherItemController::Create(app_launch_id),
-      ash::STATUS_CLOSED, index, ash::TYPE_PINNED_APP);
+      AppShortcutLauncherItemController::Create(shelf_id), ash::STATUS_CLOSED,
+      index, ash::TYPE_PINNED_APP);
 }
 
 void ChromeLauncherController::RememberUnpinnedRunningApplicationOrder() {
   RunningAppListIds list;
   for (int i = 0; i < model_->item_count(); i++) {
     if (model_->items()[i].type == ash::TYPE_APP)
       list.push_back(GetAppIDForShelfID(model_->items()[i].id));
   }
   const std::string user_email =
       multi_user_util::GetAccountIdFromProfile(profile()).GetUserEmail();
@@ skipping 14 matching lines @@
     if (item && item->type == ash::TYPE_APP) {
       int app_index = model_->ItemIndexByID(item->id);
       DCHECK_GE(app_index, 0);
       if (running_index != app_index)
         model_->Move(running_index, app_index);
       running_index++;
     }
   }
 }
 
-void ChromeLauncherController::RemoveShelfItem(ash::ShelfID id) {
+void ChromeLauncherController::RemoveShelfItem(const ash::ShelfID& id) {
   const int index = model_->ItemIndexByID(id);
   if (index >= 0 && index < model_->item_count())
     model_->RemoveItemAt(index);
 }
 
-void ChromeLauncherController::PinRunningAppInternal(int index,
-                                                     ash::ShelfID shelf_id) {
+void ChromeLauncherController::PinRunningAppInternal(
+    int index,
+    const ash::ShelfID& shelf_id) {
   DCHECK_EQ(GetItem(shelf_id)->type, ash::TYPE_APP);
   SetItemType(shelf_id, ash::TYPE_PINNED_APP);
   int running_index = model_->ItemIndexByID(shelf_id);
   if (running_index < index)
     --index;
   if (running_index != index)
     model_->Move(running_index, index);
 }
 
 void ChromeLauncherController::UnpinRunningAppInternal(int index) {
   DCHECK(index >= 0 && index < model_->item_count());
   ash::ShelfItem item = model_->items()[index];
   DCHECK_EQ(item.type, ash::TYPE_PINNED_APP);
   SetItemType(item.id, ash::TYPE_APP);
 }
 
-void ChromeLauncherController::SyncPinPosition(ash::ShelfID shelf_id) {
+void ChromeLauncherController::SyncPinPosition(const ash::ShelfID& shelf_id) {
   DCHECK(should_sync_pin_changes_);
-  DCHECK(shelf_id);
+  DCHECK(!shelf_id.IsEmpty());
 
   const int max_index = model_->item_count();
   const int index = model_->ItemIndexByID(shelf_id);
   DCHECK_GT(index, 0);
 
   const std::string& app_id = GetAppIDForShelfID(shelf_id);
   DCHECK(!app_id.empty());
   const std::string& launch_id = GetLaunchIDForShelfID(shelf_id);
 
   std::string app_id_before;
   std::string launch_id_before;
-  std::vector<ash::AppLaunchId> app_launch_ids_after;
+  std::vector<ash::ShelfID> shelf_ids_after;
 
   for (int i = index - 1; i > 0; --i) {
     const ash::ShelfID shelf_id_before = model_->items()[i].id;
     if (IsPinned(shelf_id_before)) {
       app_id_before = GetAppIDForShelfID(shelf_id_before);
       DCHECK(!app_id_before.empty());
       launch_id_before = GetLaunchIDForShelfID(shelf_id_before);
       break;
     }
   }
 
   for (int i = index + 1; i < max_index; ++i) {
     const ash::ShelfID shelf_id_after = model_->items()[i].id;
     if (IsPinned(shelf_id_after)) {
       const std::string app_id_after = GetAppIDForShelfID(shelf_id_after);
       DCHECK(!app_id_after.empty());
       const std::string launch_id_after = GetLaunchIDForShelfID(shelf_id_after);
-      app_launch_ids_after.push_back(
-          ash::AppLaunchId(app_id_after, launch_id_after));
+      shelf_ids_after.push_back(ash::ShelfID(app_id_after, launch_id_after));
     }
   }
 
-  ash::AppLaunchId app_launch_id_before =
-      app_id_before.empty() ? ash::AppLaunchId()
-                            : ash::AppLaunchId(app_id_before, launch_id_before);
-
-  ash::launcher::SetPinPosition(profile(), ash::AppLaunchId(app_id, launch_id),
-                                app_launch_id_before, app_launch_ids_after);
+  ash::ShelfID shelf_id_before = ash::ShelfID(app_id_before, launch_id_before);
+  ash::launcher::SetPinPosition(profile(), ash::ShelfID(app_id, launch_id),
+                                shelf_id_before, shelf_ids_after);
 }
 
 void ChromeLauncherController::OnSyncModelUpdated() {
   UpdateAppLaunchersFromPref();
 }
 
 void ChromeLauncherController::OnIsSyncingChanged() {
   UpdateAppLaunchersFromPref();
 }
 
 void ChromeLauncherController::ScheduleUpdateAppLaunchersFromPref() {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&ChromeLauncherController::UpdateAppLaunchersFromPref,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void ChromeLauncherController::UpdateAppLaunchersFromPref() {
   // Do not sync pin changes during this function to avoid cyclical updates.
   // This function makes the shelf model reflect synced prefs, and should not
   // cyclically trigger sync changes (eg. ShelfItemAdded calls SyncPinPosition).
   ScopedPinSyncDisabler scoped_pin_sync_disabler = GetScopedPinSyncDisabler();
 
-  const std::vector<ash::AppLaunchId> pinned_apps =
+  const std::vector<ash::ShelfID> pinned_apps =
       ash::launcher::GetPinnedAppsFromPrefs(profile()->GetPrefs(),
                                             launcher_controller_helper_.get());
 
   int index = 0;
   // Skip app list items if it exists.
   if (model_->items()[0].type == ash::TYPE_APP_LIST)
     ++index;
 
   // Apply pins in two steps. At the first step, go through the list of apps to
   // pin, move existing pin to current position specified by |index| or create
   // the new pin at that position.
-  for (const auto& pref_app_launch_id : pinned_apps) {
+  for (const auto& pref_shelf_id : pinned_apps) {
     // Filter out apps that may be mapped wrongly.
     // TODO(khmel):  b/31703859 is to refactore shelf mapping.
-    const std::string app_id = pref_app_launch_id.app_id();
+    const std::string app_id = pref_shelf_id.app_id();
     const std::string shelf_app_id =
         ArcAppWindowLauncherController::GetShelfAppIdFromArcAppId(app_id);
     if (shelf_app_id != app_id)
       continue;
 
     // Update apps icon if applicable.
     OnAppUpdated(profile(), app_id);
 
     // Find existing pin or app from the right of current |index|.
     int app_index = index;
     for (; app_index < model_->item_count(); ++app_index) {
       const ash::ShelfItem& item = model_->items()[app_index];
-      if (item.app_launch_id.app_id() == app_id &&
-          item.app_launch_id.launch_id() == pref_app_launch_id.launch_id()) {
+      if (item.id == pref_shelf_id)
         break;
-      }
     }
     if (app_index < model_->item_count()) {
       // Found existing pin or running app.
       const ash::ShelfItem item = model_->items()[app_index];
       if (ItemTypeIsPinned(item)) {
         // Just move to required position or keep it inplace.
         model_->Move(app_index, index);
       } else {
         PinRunningAppInternal(index, item.id);
       }
       DCHECK_EQ(model_->ItemIndexByID(item.id), index);
     } else {
       // This is fresh pin. Create new one.
       DCHECK_NE(app_id, kChromeAppId);
-      CreateAppShortcutLauncherItem(pref_app_launch_id, index);
+      CreateAppShortcutLauncherItem(pref_shelf_id, index);
     }
     ++index;
   }
 
   // At second step remove any pin to the right from the current index.
   while (index < model_->item_count()) {
     const ash::ShelfItem item = model_->items()[index];
     if (item.type == ash::TYPE_PINNED_APP)
       UnpinShelfItemInternal(item.id);
     else
       ++index;
   }
 
   UpdatePolicyPinnedAppsFromPrefs();
 }
 
 void ChromeLauncherController::UpdatePolicyPinnedAppsFromPrefs() {
   for (int index = 0; index < model_->item_count(); index++) {
     ash::ShelfItem item = model_->items()[index];
     const bool pinned_by_policy =
-        GetPinnableForAppID(item.app_launch_id.app_id(), profile()) ==
+        GetPinnableForAppID(item.id.app_id(), profile()) ==
         AppListControllerDelegate::PIN_FIXED;
     if (item.pinned_by_policy != pinned_by_policy) {
       item.pinned_by_policy = pinned_by_policy;
       model_->Set(index, item);
     }
   }
 }
 
 void ChromeLauncherController::SetVirtualKeyboardBehaviorFromPrefs() {
   const PrefService* service = profile()->GetPrefs();
@@ skipping 39 matching lines @@
     }
   }
   return status;
 }
 
 ash::ShelfID ChromeLauncherController::InsertAppLauncherItem(
     std::unique_ptr<ash::ShelfItemDelegate> item_delegate,
     ash::ShelfItemStatus status,
     int index,
     ash::ShelfItemType shelf_item_type) {
-  ash::ShelfID id = model_->next_id();
-  CHECK(!GetItem(id));
   CHECK(item_delegate);
+  CHECK(!GetItem(item_delegate->shelf_id()));
   // Ash's ShelfWindowWatcher handles app panel windows separately.
   DCHECK_NE(ash::TYPE_APP_PANEL, shelf_item_type);
   ash::ShelfItem item;
   item.status = status;
   item.type = shelf_item_type;
-  item.app_launch_id = item_delegate->app_launch_id();
+  item.id = item_delegate->shelf_id();
   // Set the delegate first to avoid constructing one in ShelfItemAdded.
-  model_->SetShelfItemDelegate(id, std::move(item_delegate));
+  model_->SetShelfItemDelegate(item.id, std::move(item_delegate));
   model_->AddAt(index, item);
-  return id;
+  return item.id;
 }
 
 void ChromeLauncherController::CreateBrowserShortcutLauncherItem() {
   // Do not sync the pin position of the browser shortcut item when it is added;
   // its initial position before prefs have loaded is unimportant and the sync
   // service may not yet be initialized.
   ScopedPinSyncDisabler scoped_pin_sync_disabler = GetScopedPinSyncDisabler();
 
   ash::ShelfItem browser_shortcut;
   browser_shortcut.type = ash::TYPE_BROWSER_SHORTCUT;
   ResourceBundle& rb = ResourceBundle::GetSharedInstance();
   browser_shortcut.image = *rb.GetImageSkiaNamed(IDR_PRODUCT_LOGO_32);
   browser_shortcut.title = l10n_util::GetStringUTF16(IDS_PRODUCT_NAME);
-  browser_shortcut.app_launch_id = ash::AppLaunchId(kChromeAppId);
-  ash::ShelfID id = model_->next_id();
+  browser_shortcut.id = ash::ShelfID(kChromeAppId);
   std::unique_ptr<BrowserShortcutLauncherItemController> item_delegate =
       base::MakeUnique<BrowserShortcutLauncherItemController>(model_);
   BrowserShortcutLauncherItemController* item_controller = item_delegate.get();
   // Set the delegate first to avoid constructing another one in ShelfItemAdded.
-  model_->SetShelfItemDelegate(id, std::move(item_delegate));
+  model_->SetShelfItemDelegate(browser_shortcut.id, std::move(item_delegate));
   model_->AddAt(0, browser_shortcut);
   item_controller->UpdateBrowserItemState();
 }
 
 bool ChromeLauncherController::IsIncognito(
     const content::WebContents* web_contents) const {
   const Profile* profile =
       Profile::FromBrowserContext(web_contents->GetBrowserContext());
   return profile->IsOffTheRecord() && !profile->IsGuestSession() &&
          !profile->IsSystemProfile();
@@ skipping 172 matching lines @@
 
 void ChromeLauncherController::ShelfItemAdded(int index) {
   // Update the pin position preference as needed.
   ash::ShelfItem item = model_->items()[index];
   if (ItemTypeIsPinned(item) && should_sync_pin_changes_)
     SyncPinPosition(item.id);
 
   // TODO(khmel): Fix this Arc application id mapping. See http://b/31703859
   const std::string shelf_app_id =
       ArcAppWindowLauncherController::GetShelfAppIdFromArcAppId(
-          item.app_launch_id.app_id());
+          item.id.app_id());
 
   // Fetch and update the icon for the app's item.
   AppIconLoader* app_icon_loader = GetAppIconLoaderForApp(shelf_app_id);
   if (app_icon_loader) {
     app_icon_loader->FetchImage(shelf_app_id);
     app_icon_loader->UpdateImage(shelf_app_id);
   }
 
   // Update the item with any missing Chrome-specific info.
   if (item.type == ash::TYPE_APP || item.type == ash::TYPE_PINNED_APP) {
@@ skipping 12 matching lines @@
       needs_update = true;
       item.status = status;
     }
     if (needs_update)
       model_->Set(index, item);
   }
 
   // Construct a ShelfItemDelegate for the item if one does not yet exist.
   if (!model_->GetShelfItemDelegate(item.id)) {
     model_->SetShelfItemDelegate(
-        item.id, AppShortcutLauncherItemController::Create(ash::AppLaunchId(
-                     shelf_app_id, item.app_launch_id.launch_id())));
+        item.id, AppShortcutLauncherItemController::Create(
+                     ash::ShelfID(shelf_app_id, item.id.launch_id())));
   }
 }
 
 void ChromeLauncherController::ShelfItemRemoved(
     int index,
     const ash::ShelfItem& old_item) {
   // TODO(khmel): Fix this Arc application id mapping. See http://b/31703859
   const std::string shelf_app_id =
       ArcAppWindowLauncherController::GetShelfAppIdFromArcAppId(
-          old_item.app_launch_id.app_id());
+          old_item.id.app_id());
 
   // Remove the pin position from preferences as needed.
   if (ItemTypeIsPinned(old_item) && should_sync_pin_changes_) {
-    ash::AppLaunchId app_launch_id(shelf_app_id,
-                                   old_item.app_launch_id.launch_id());
-    ash::launcher::RemovePinPosition(profile(), app_launch_id);
+    ash::ShelfID shelf_id(shelf_app_id, old_item.id.launch_id());
+    ash::launcher::RemovePinPosition(profile(), shelf_id);
   }
 
   AppIconLoader* app_icon_loader = GetAppIconLoaderForApp(shelf_app_id);
   if (app_icon_loader)
     app_icon_loader->ClearImage(shelf_app_id);
 }
 
 void ChromeLauncherController::ShelfItemMoved(int start_index,
                                               int target_index) {
   // Update the pin position preference as needed.
@@ skipping 10 matching lines @@
     return;
 
   const ash::ShelfItem& item = model_->items()[index];
   // Add or remove the pin position from preferences as needed.
   if (!ItemTypeIsPinned(old_item) && ItemTypeIsPinned(item)) {
     SyncPinPosition(item.id);
   } else if (ItemTypeIsPinned(old_item) && !ItemTypeIsPinned(item)) {
     // TODO(khmel): Fix this Arc application id mapping. See http://b/31703859
     const std::string shelf_app_id =
         ArcAppWindowLauncherController::GetShelfAppIdFromArcAppId(
-            old_item.app_launch_id.app_id());
+            old_item.id.app_id());
 
-    ash::AppLaunchId app_launch_id(shelf_app_id,
-                                   old_item.app_launch_id.launch_id());
-    ash::launcher::RemovePinPosition(profile(), app_launch_id);
+    ash::ShelfID shelf_id(shelf_app_id, old_item.id.launch_id());
+    ash::launcher::RemovePinPosition(profile(), shelf_id);
   }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // ash::WindowTreeHostManager::Observer:
 
 void ChromeLauncherController::OnDisplayConfigurationChanged() {
   // In BOTTOM_LOCKED state, ignore the call of SetShelfBehaviorsFromPrefs.
   // Because it might be called by some operations, like crbug.com/627040
   // rotating screen.
@@ skipping 14 matching lines @@
           : IDS_ASH_SHELF_APP_LIST_LAUNCHER_TITLE);
 
   const int app_list_index = model_->GetItemIndexForType(ash::TYPE_APP_LIST);
   DCHECK_GE(app_list_index, 0);
   ash::ShelfItem item = model_->items()[app_list_index];
   if (item.title != title) {
     item.title = title;
     model_->Set(app_list_index, item);
   }
 }