Add AppLauncherId wrapper for items shown in shelf

chrome/browser/ui/ash/launcher/chrome_launcher_controller_impl.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 <vector>
 
@@ skipping 357 matching lines @@
 
 void ChromeLauncherControllerImpl::Unpin(ash::ShelfID id) {
   UnpinAndUpdatePrefs(id, true /* update_prefs */);
 }
 
 void ChromeLauncherControllerImpl::UnpinAndUpdatePrefs(ash::ShelfID id,
                                                        bool update_prefs) {
   LauncherItemController* controller = GetLauncherItemController(id);
   CHECK(controller);
 
-  if (update_prefs)
-    ash::launcher::RemovePinPosition(profile(), GetAppIDForShelfID(id));
+  if (update_prefs) {
+    ash::launcher::RemovePinPosition(
+        profile(), ash::launcher::AppLauncherId(GetAppIDForShelfID(id)));
+  }
 
   if (controller->type() == LauncherItemController::TYPE_APP ||
       controller->locked()) {
     UnpinRunningAppInternal(model_->ItemIndexByID(id));
   } else {
     LauncherItemClosed(id);
   }
 }
 
 bool ChromeLauncherControllerImpl::IsPinned(ash::ShelfID id) {
@@ skipping 760 matching lines @@
     return;
 
   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());
 
   std::string app_id_before;
-  std::vector<std::string> app_ids_after;
+  std::vector<ash::launcher::AppLauncherId> app_launcher_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());
       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());
-      app_ids_after.push_back(app_id_after);
+      app_launcher_ids_after.push_back(
+          ash::launcher::AppLauncherId(app_id_after));
     }
   }
 
-  ash::launcher::SetPinPosition(profile(), app_id, app_id_before,
-                                app_ids_after);
+  ash::launcher::AppLauncherId app_launcher_id_before =
+      app_id_before.empty() ? ash::launcher::AppLauncherId()
+                            : ash::launcher::AppLauncherId(app_id_before);
+
+  ash::launcher::SetPinPosition(profile(), ash::launcher::AppLauncherId(app_id),
+                                app_launcher_id_before, app_launcher_ids_after);
 }
 
 void ChromeLauncherControllerImpl::OnSyncModelUpdated() {
   UpdateAppLaunchersFromPref();
 }
 
 void ChromeLauncherControllerImpl::ScheduleUpdateAppLaunchersFromPref() {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&ChromeLauncherControllerImpl::UpdateAppLaunchersFromPref,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void ChromeLauncherControllerImpl::UpdateAppLaunchersFromPref() {
   // There are various functions which will trigger a |SyncPinPosition| call
   // like a direct call to |DoPinAppWithID|, or an indirect call to the menu
   // model which will use weights to re-arrange the icons to new positions.
   // Since this function is meant to synchronize the "is state" with the
   // "sync state", it makes no sense to store any changes by this function back
   // into the pref state. Therefore we tell |persistPinnedState| to ignore any
   // invocations while we are running.
   base::AutoReset<bool> auto_reset(&ignore_persist_pinned_state_change_, true);
-  const std::vector<std::string> pinned_apps =
+  const std::vector<ash::launcher::AppLauncherId> pinned_apps =
       ash::launcher::GetPinnedAppsFromPrefs(profile()->GetPrefs(),
                                             launcher_controller_helper());
 
   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_id : pinned_apps) {
+  for (const auto& pref_app_launcher_id : pinned_apps) {
     // Filter out apps that may be mapped wrongly.
     // TODO(khmel):  b/31703859 is to refactore shelf mapping.
+    const std::string app_launcher_id_str = pref_app_launcher_id.ToString();
     const std::string shelf_app_id =
-        ArcAppWindowLauncherController::GetShelfAppIdFromArcAppId(pref_app_id);
-    if (shelf_app_id != pref_app_id)
+        ArcAppWindowLauncherController::GetShelfAppIdFromArcAppId(
+            app_launcher_id_str);
+    if (shelf_app_id != app_launcher_id_str)
       continue;
 
     // Update apps icon if applicable.
-    OnAppUpdated(profile(), pref_app_id);
+    OnAppUpdated(profile(), app_launcher_id_str);
 
     // 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];
       const IDToItemControllerMap::iterator it =
           id_to_item_controller_map_.find(item.id);
       if (it != id_to_item_controller_map_.end() &&
-          it->second->app_id() == pref_app_id) {
+          it->second->app_id() == app_launcher_id_str) {
         break;
       }
     }
     if (app_index < model_->item_count()) {
       // Found existing pin or running app.
       const ash::ShelfItem item = model_->items()[app_index];
       if (item.type == ash::TYPE_APP_SHORTCUT ||
           item.type == ash::TYPE_BROWSER_SHORTCUT) {
         // 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(pref_app_id, extension_misc::kChromeAppId);
-      CreateAppShortcutLauncherItem(pref_app_id, index);
+      DCHECK_NE(app_launcher_id_str, extension_misc::kChromeAppId);
+      CreateAppShortcutLauncherItem(app_launcher_id_str, 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_APP_SHORTCUT) {
       ++index;
       continue;
@@ skipping 277 matching lines @@
     if (index == -1)
       continue;
     ash::ShelfItem item = model_->items()[index];
     item.image = image;
     if (arc_deferred_launcher_)
       arc_deferred_launcher_->MaybeApplySpinningEffect(id, &item.image);
     model_->Set(index, item);
     // It's possible we're waiting on more than one item, so don't break.
   }
 }