Move and rename Chrome's AppLauncherId to ash::AppLaunchId.

chrome/browser/ui/ash/chrome_launcher_prefs.cc

 // Copyright (c) 2012 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/chrome_launcher_prefs.h"
 
 #include <stddef.h>
 
 #include <set>
 
+#include "ash/public/cpp/app_launch_id.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/app_mode/app_mode_utils.h"
 #include "chrome/browser/chromeos/arc/arc_support_host.h"
 #include "chrome/browser/prefs/pref_service_syncable_util.h"
 #include "chrome/browser/ui/app_list/app_list_syncable_service.h"
 #include "chrome/browser/ui/app_list/app_list_syncable_service_factory.h"
 #include "chrome/browser/ui/app_list/arc/arc_app_list_prefs.h"
-#include "chrome/browser/ui/ash/app_launcher_id.h"
 #include "chrome/browser/ui/ash/launcher/launcher_controller_helper.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/pref_names.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/prefs/pref_service.h"
 #include "components/prefs/scoped_user_pref_update.h"
 #include "components/sync/model/string_ordinal.h"
 #include "components/sync_preferences/pref_service_syncable.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
@@ skipping 187 matching lines @@
 // If no user-set value exists at |local_path|, the value from |synced_path| is
 // copied to |local_path|.
 void PropagatePrefToLocalIfNotSet(
     sync_preferences::PrefServiceSyncable* pref_service,
     const char* local_path,
     const char* synced_path) {
   if (!pref_service->FindPreference(local_path)->HasUserSetting())
     pref_service->SetString(local_path, pref_service->GetString(synced_path));
 }
 
-std::vector<AppLauncherId> AppIdsToAppLauncherIds(
+std::vector<AppLaunchId> AppIdsToAppLaunchIds(
     const std::vector<std::string> app_ids) {
-  std::vector<AppLauncherId> app_launcher_ids(app_ids.size(), AppLauncherId());
+  std::vector<AppLaunchId> app_launch_ids(app_ids.size(), AppLaunchId());
   for (size_t i = 0; i < app_ids.size(); ++i)
-    app_launcher_ids[i] = AppLauncherId(app_ids[i]);
-  return app_launcher_ids;
+    app_launch_ids[i] = AppLaunchId(app_ids[i]);
+  return app_launch_ids;
 }
 
 struct PinInfo {
   PinInfo(const std::string& app_id, const syncer::StringOrdinal& item_ordinal)
       : app_id(app_id), item_ordinal(item_ordinal) {}
 
   std::string app_id;
   syncer::StringOrdinal item_ordinal;
 };
 
@@ skipping 346 matching lines @@
     // Check if it is present but not in legacy pin.
     if (helper->IsValidIDForCurrentUser(app_id))
       continue;
     app_service->SetPinPosition(app_id, last_position);
     last_position = last_position.CreateAfter();
   }
 
   return legacy_pins_valid;
 }
 
-std::vector<AppLauncherId> GetPinnedAppsFromPrefs(
+std::vector<AppLaunchId> GetPinnedAppsFromPrefs(
     const PrefService* prefs,
     LauncherControllerHelper* helper) {
   app_list::AppListSyncableService* app_service =
       app_list::AppListSyncableServiceFactory::GetForProfile(helper->profile());
   // Some unit tests may not have it or service may not be initialized.
   if (!app_service || !app_service->IsInitialized())
-    return std::vector<AppLauncherId>();
+    return std::vector<AppLaunchId>();
 
   std::vector<PinInfo> pin_infos;
 
   // Empty pins indicates that sync based pin model is used for the first
   // time. In normal workflow we have at least Chrome browser pin info.
   bool first_run = true;
 
   for (const auto& sync_peer : app_service->sync_items()) {
     if (!sync_peer.second->item_pin_ordinal.IsValid())
       continue;
 
     first_run = false;
     // Don't include apps that currently do not exist on device.
     if (sync_peer.first != extension_misc::kChromeAppId &&
         !helper->IsValidIDForCurrentUser(sync_peer.first)) {
       continue;
     }
 
     pin_infos.push_back(
         PinInfo(sync_peer.first, sync_peer.second->item_pin_ordinal));
   }
 
   if (first_run) {
     // Return default apps in case profile is not synced yet.
     sync_preferences::PrefServiceSyncable* const pref_service_syncable =
         PrefServiceSyncableFromProfile(helper->profile());
     if (!pref_service_syncable->IsSyncing())
-      return AppIdsToAppLauncherIds(
+      return AppIdsToAppLaunchIds(
           GetPinnedAppsFromPrefsLegacy(prefs, helper, true));
 
     // We need to import legacy pins model and convert it to sync based
     // model.
-    return AppIdsToAppLauncherIds(ImportLegacyPinnedApps(prefs, helper));
+    return AppIdsToAppLaunchIds(ImportLegacyPinnedApps(prefs, helper));
   }
 
   // Sort pins according their ordinals.
   std::sort(pin_infos.begin(), pin_infos.end(), ComparePinInfo());
 
   AppTracker policy_apps;
   GetAppsPinnedByPolicy(prefs, helper, true, &policy_apps);
 
   // Pinned by policy apps appear first, if they were not shown before.
   syncer::StringOrdinal front_position = GetFirstPinPosition(helper->profile());
@@ skipping 25 matching lines @@
     if (!app_service->GetSyncItem(ArcSupportHost::kHostAppId)) {
       const syncer::StringOrdinal arc_host_position =
           GetLastPinPosition(helper->profile());
       pin_infos.insert(pin_infos.begin(),
                        PinInfo(ArcSupportHost::kHostAppId, arc_host_position));
       app_service->SetPinPosition(ArcSupportHost::kHostAppId,
                                   arc_host_position);
     }
   }
 
-  // Convert to AppLauncherId array.
+  // Convert to AppLaunchId array.
   std::vector<std::string> pins(pin_infos.size());
   for (size_t i = 0; i < pin_infos.size(); ++i)
     pins[i] = pin_infos[i].app_id;
 
-  return AppIdsToAppLauncherIds(pins);
+  return AppIdsToAppLaunchIds(pins);
 }
 
-void RemovePinPosition(Profile* profile, const AppLauncherId& app_launcher_id) {
+void RemovePinPosition(Profile* profile, const AppLaunchId& app_launch_id) {
   DCHECK(profile);
 
-  const std::string& app_id = app_launcher_id.app_id();
-  if (!app_launcher_id.launch_id().empty()) {
+  const std::string& app_id = app_launch_id.app_id();
+  if (!app_launch_id.launch_id().empty()) {
     VLOG(2) << "Syncing remove pin for '" << app_id
-            << "' with non-empty launch id '" << app_launcher_id.launch_id()
+            << "' with non-empty launch id '" << app_launch_id.launch_id()
             << "' is not supported.";
     return;
   }
   DCHECK(!app_id.empty());
 
   app_list::AppListSyncableService* app_service =
       app_list::AppListSyncableServiceFactory::GetForProfile(profile);
   app_service->SetPinPosition(app_id, syncer::StringOrdinal());
 }
 
 void SetPinPosition(Profile* profile,
-                    const AppLauncherId& app_launcher_id,
-                    const AppLauncherId& app_launcher_id_before,
-                    const std::vector<AppLauncherId>& app_launcher_ids_after) {
+                    const AppLaunchId& app_launch_id,
+                    const AppLaunchId& app_launch_id_before,
+                    const std::vector<AppLaunchId>& app_launch_ids_after) {
   DCHECK(profile);
 
-  const std::string& app_id = app_launcher_id.app_id();
-  if (!app_launcher_id.launch_id().empty()) {
+  const std::string& app_id = app_launch_id.app_id();
+  if (!app_launch_id.launch_id().empty()) {
     VLOG(2) << "Syncing set pin for '" << app_id
-            << "' with non-empty launch id '" << app_launcher_id.launch_id()
+            << "' with non-empty launch id '" << app_launch_id.launch_id()
             << "' is not supported.";
     return;
   }
 
-  const std::string& app_id_before = app_launcher_id_before.app_id();
+  const std::string& app_id_before = app_launch_id_before.app_id();
 
   DCHECK(!app_id.empty());
   DCHECK_NE(app_id, app_id_before);
 
   app_list::AppListSyncableService* app_service =
       app_list::AppListSyncableServiceFactory::GetForProfile(profile);
   // Some unit tests may not have this service.
   if (!app_service)
     return;
 
   syncer::StringOrdinal position_before =
       app_id_before.empty() ? syncer::StringOrdinal()
                             : app_service->GetPinPosition(app_id_before);
   syncer::StringOrdinal position_after;
-  for (const auto& app_launcher_id_after : app_launcher_ids_after) {
-    const std::string& app_id_after = app_launcher_id_after.app_id();
+  for (const auto& app_launch_id_after : app_launch_ids_after) {
+    const std::string& app_id_after = app_launch_id_after.app_id();
     DCHECK_NE(app_id_after, app_id);
     DCHECK_NE(app_id_after, app_id_before);
     syncer::StringOrdinal position = app_service->GetPinPosition(app_id_after);
     DCHECK(position.IsValid());
     if (!position.IsValid()) {
       LOG(ERROR) << "Sync pin position was not found for " << app_id_after;
       continue;
     }
     if (!position_before.IsValid() || !position.Equals(position_before)) {
       position_after = position;
       break;
     }
   }
 
   syncer::StringOrdinal pin_position;
   if (position_before.IsValid() && position_after.IsValid())
     pin_position = position_before.CreateBetween(position_after);
   else if (position_before.IsValid())
     pin_position = position_before.CreateAfter();
   else if (position_after.IsValid())
     pin_position = position_after.CreateBefore();
   else
     pin_position = syncer::StringOrdinal::CreateInitialOrdinal();
   app_service->SetPinPosition(app_id, pin_position);
 }
 
 }  // namespace launcher
 }  // namespace ash