Reduce namespaces for ash::launcher::AppLauncherId

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 345 matching lines @@
   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(), ash::launcher::AppLauncherId(GetAppIDForShelfID(id),
-                                                GetLaunchIDForShelfID(id)));
+        profile(),
+        ash::AppLauncherId(GetAppIDForShelfID(id), GetLaunchIDForShelfID(id)));
   }
 
   const ash::ShelfItem* item = GetItem(id);
   if (item && (item->status != ash::STATUS_CLOSED || controller->locked()))
     UnpinRunningAppInternal(model_->ItemIndexByID(id));
   else
     LauncherItemClosed(id);
 }
 
 bool ChromeLauncherControllerImpl::IsPinned(ash::ShelfID id) {
   const ash::ShelfItem* item = GetItem(id);
   return item && (item->type == ash::TYPE_APP_SHORTCUT ||
                   item->type == ash::TYPE_BROWSER_SHORTCUT);
 }
 
 void ChromeLauncherControllerImpl::TogglePinned(ash::ShelfID id) {
   if (!HasShelfIDToAppIDMapping(id))
     return;  // May happen if item closed with menu open.
 
   if (IsPinned(id))
     Unpin(id);
   else
     Pin(id);
 }
 
 void ChromeLauncherControllerImpl::LockV1AppWithID(const std::string& app_id) {
   ash::ShelfID id = GetShelfIDForAppID(app_id);
   if (id == ash::kInvalidShelfID) {
-    CreateAppShortcutLauncherItemWithType(ash::launcher::AppLauncherId(app_id),
+    CreateAppShortcutLauncherItemWithType(ash::AppLauncherId(app_id),
                                           model_->item_count(), ash::TYPE_APP);
     id = GetShelfIDForAppID(app_id);
   }
   CHECK(id);
   GetLauncherItemController(id)->lock();
 }
 
 void ChromeLauncherControllerImpl::UnlockV1AppWithID(
     const std::string& app_id) {
   ash::ShelfID id = GetShelfIDForAppID(app_id);
   CHECK_NE(id, ash::kInvalidShelfID);
   LauncherItemController* controller = GetLauncherItemController(id);
   controller->unlock();
   if (!controller->locked() && !IsPinned(id))
     CloseLauncherItem(id);
 }
 
 void ChromeLauncherControllerImpl::Launch(ash::ShelfID id, int event_flags) {
   LauncherItemController* controller = GetLauncherItemController(id);
   if (!controller)
     return;  // In case invoked from menu and item closed while menu up.
 
   // Launching some items replaces the associated item controller instance,
   // which destroys the app and launch id strings; making copies avoid crashes.
-  LaunchApp(ash::launcher::AppLauncherId(controller->app_id(),
-                                         controller->launch_id()),
+  LaunchApp(ash::AppLauncherId(controller->app_id(), controller->launch_id()),
             ash::LAUNCH_FROM_UNKNOWN, event_flags);
 }
 
 void ChromeLauncherControllerImpl::Close(ash::ShelfID id) {
   ash::ShelfItemDelegate* delegate = model_->GetShelfItemDelegate(id);
   if (!delegate)
     return;  // May happen if menu closed.
   delegate->Close();
 }
 
@@ skipping 24 matching lines @@
     return;
   }
 
   // Create a temporary application launcher item and use it to see if there are
   // running instances.
   std::unique_ptr<AppShortcutLauncherItemController> app_controller(
       AppShortcutLauncherItemController::Create(app_id, std::string(), this));
   if (!app_controller->GetRunningApplications().empty())
     app_controller->Activate(source);
   else
-    LaunchApp(ash::launcher::AppLauncherId(app_id), source, event_flags);
+    LaunchApp(ash::AppLauncherId(app_id), source, event_flags);
 }
 
 void ChromeLauncherControllerImpl::SetLauncherItemImage(
     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);
@@ skipping 473 matching lines @@
 
   // TODO(sky): update unit test so that this test isn't necessary.
   if (ash::Shell::HasInstance())
     SetVirtualKeyboardBehaviorFromPrefs();
 
   prefs_observer_ =
       ash::launcher::ChromeLauncherPrefsObserver::CreateIfNecessary(profile());
 }
 
 ash::ShelfID ChromeLauncherControllerImpl::CreateAppShortcutLauncherItem(
-    const ash::launcher::AppLauncherId& app_launcher_id,
+    const ash::AppLauncherId& app_launcher_id,
     int index) {
   return CreateAppShortcutLauncherItemWithType(app_launcher_id, index,
                                                ash::TYPE_APP_SHORTCUT);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // ChromeLauncherControllerImpl private:
 
 void ChromeLauncherControllerImpl::RememberUnpinnedRunningApplicationOrder() {
   RunningAppListIds list;
@@ skipping 22 matching lines @@
       DCHECK_GE(app_index, 0);
       if (running_index != app_index)
         model_->Move(running_index, app_index);
       running_index++;
     }
   }
 }
 
 ash::ShelfID
 ChromeLauncherControllerImpl::CreateAppShortcutLauncherItemWithType(
-    const ash::launcher::AppLauncherId& app_launcher_id,
+    const ash::AppLauncherId& app_launcher_id,
     int index,
     ash::ShelfItemType shelf_item_type) {
   AppShortcutLauncherItemController* controller =
       AppShortcutLauncherItemController::Create(
           app_launcher_id.app_id(), app_launcher_id.launch_id(), this);
   ash::ShelfID shelf_id =
       InsertAppLauncherItem(controller, app_launcher_id.app_id(),
                             ash::STATUS_CLOSED, index, shelf_item_type);
   return shelf_id;
 }
@@ skipping 18 matching lines @@
   // If there is an item, do nothing and return.
   if (IsAppPinned(app_id))
     return;
 
   ash::ShelfID shelf_id = GetShelfIDForAppID(app_id);
   if (shelf_id) {
     // App item exists, pin it
     Pin(shelf_id);
   } else {
     // Otherwise, create a shortcut item for it.
-    shelf_id = CreateAppShortcutLauncherItem(
-        ash::launcher::AppLauncherId(app_id), model_->item_count());
+    shelf_id = CreateAppShortcutLauncherItem(ash::AppLauncherId(app_id),
+                                             model_->item_count());
     SyncPinPosition(shelf_id);
   }
 }
 
 void ChromeLauncherControllerImpl::DoUnpinAppWithID(const std::string& app_id,
                                                     bool update_prefs) {
   ash::ShelfID shelf_id = GetShelfIDForAppID(app_id);
   if (shelf_id && IsPinned(shelf_id))
     UnpinAndUpdatePrefs(shelf_id, update_prefs);
 }
@@ skipping 25 matching lines @@
   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::launcher::AppLauncherId> app_launcher_ids_after;
+  std::vector<ash::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());
       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_launcher_ids_after.push_back(
-          ash::launcher::AppLauncherId(app_id_after, launch_id_after));
+          ash::AppLauncherId(app_id_after, launch_id_after));
     }
   }
 
-  ash::launcher::AppLauncherId app_launcher_id_before =
+  ash::AppLauncherId app_launcher_id_before =
       app_id_before.empty()
-          ? ash::launcher::AppLauncherId()
-          : ash::launcher::AppLauncherId(app_id_before, launch_id_before);
+          ? ash::AppLauncherId()
+          : ash::AppLauncherId(app_id_before, launch_id_before);
 
   ash::launcher::SetPinPosition(profile(),
-                                ash::launcher::AppLauncherId(app_id, launch_id),
+                                ash::AppLauncherId(app_id, launch_id),
                                 app_launcher_id_before, app_launcher_ids_after);
 }
 
 void ChromeLauncherControllerImpl::OnSyncModelUpdated() {
   UpdateAppLaunchersFromPref();
 }
 
 void ChromeLauncherControllerImpl::OnIsSyncingChanged() {
   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<ash::launcher::AppLauncherId> pinned_apps =
+  const std::vector<ash::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
@@ skipping 338 matching lines @@
     LauncherItemController* controller = GetLauncherItemController(item.id);
     if (!controller || controller->image_set_by_controller())
       continue;
     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.
   }
 }