Use ChromeLauncherControllerImpl::GetItem; cleanup.

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 246 matching lines @@
 ChromeLauncherControllerImpl::~ChromeLauncherControllerImpl() {
   // Reset the BrowserStatusMonitor as it has a weak pointer to this.
   browser_status_monitor_.reset();
 
   // Reset the app window controllers here since it has a weak pointer to this.
   app_window_controllers_.clear();
 
   model_->RemoveObserver(this);
   if (ash::Shell::HasInstance())
     ash::Shell::GetInstance()->window_tree_host_manager()->RemoveObserver(this);
-  for (IDToItemControllerMap::iterator i = id_to_item_controller_map_.begin();
-       i != id_to_item_controller_map_.end(); ++i) {
-    int index = model_->ItemIndexByID(i->first);
+  for (const auto& pair : id_to_item_controller_map_) {
+    int index = model_->ItemIndexByID(pair.first);
     // A "browser proxy" is not known to the model and this removal does
     // therefore not need to be propagated to the model.
     if (index != -1 &&
         model_->items()[index].type != ash::TYPE_BROWSER_SHORTCUT)
       model_->RemoveItemAt(index);
   }
 
   // Release all profile dependent resources.
   ReleaseProfile();
 
@@ skipping 14 matching lines @@
 }
 
 ash::ShelfID ChromeLauncherControllerImpl::CreateAppLauncherItem(
     LauncherItemController* controller,
     const std::string& app_id,
     ash::ShelfItemStatus status) {
   return InsertAppLauncherItem(controller, app_id, status, model_->item_count(),
                                ash::TYPE_APP);
 }
 
-const ash::ShelfItem& ChromeLauncherControllerImpl::GetItem(
+const ash::ShelfItem* ChromeLauncherControllerImpl::GetItem(
     ash::ShelfID id) const {
   const int index = model_->ItemIndexByID(id);
-  DCHECK_GE(index, 0);
-  return model_->items()[index];
+  if (index >= 0 && index < model_->item_count())
+    return &model_->items()[index];
+  return nullptr;
 }
 
 void ChromeLauncherControllerImpl::SetItemType(ash::ShelfID id,
                                                ash::ShelfItemType type) {
-  const int index = model_->ItemIndexByID(id);
-  DCHECK_GE(index, 0);
-  ash::ShelfItem item = model_->items()[index];
-  if (item.type != type) {
-    item.type = type;
-    model_->Set(index, item);
+  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 ChromeLauncherControllerImpl::SetItemStatus(ash::ShelfID id,
                                                  ash::ShelfItemStatus status) {
-  const int index = model_->ItemIndexByID(id);
-  DCHECK_GE(index, 0);
-  ash::ShelfItem item = model_->items()[index];
-  if (item.status != status) {
-    item.status = status;
-    model_->Set(index, item);
+  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 ChromeLauncherControllerImpl::SetItemController(
     ash::ShelfID id,
     LauncherItemController* controller) {
   CHECK(controller);
   IDToItemControllerMap::iterator iter = id_to_item_controller_map_.find(id);
   CHECK(iter != id_to_item_controller_map_.end());
   controller->set_shelf_id(id);
@@ skipping 16 matching lines @@
     iter->second->set_shelf_id(id);
     // Existing controller is destroyed and replaced by registering again.
     SetShelfItemDelegate(id, iter->second);
   } else {
     LauncherItemClosed(id);
   }
 }
 
 void ChromeLauncherControllerImpl::Pin(ash::ShelfID id) {
   DCHECK(HasShelfIDToAppIDMapping(id));
-
-  int index = model_->ItemIndexByID(id);
-  DCHECK_GE(index, 0);
-
-  ash::ShelfItem item = model_->items()[index];
-
-  if (item.type == ash::TYPE_APP) {
-    item.type = ash::TYPE_APP_SHORTCUT;
-    model_->Set(index, item);
-  } else if (item.type != ash::TYPE_APP_SHORTCUT) {
+  const ash::ShelfItem* item = GetItem(id);
+  if (item && item->type == ash::TYPE_APP)
+    SetItemType(id, ash::TYPE_APP_SHORTCUT);
+  else if (!item || item->type != ash::TYPE_APP_SHORTCUT)
     return;
-  }
 
   SyncPinPosition(id);
 }
 
 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(), ash::launcher::AppLauncherId(GetAppIDForShelfID(id),
                                                 GetLaunchIDForShelfID(id)));
   }
 
-  if (GetItem(id).status != ash::STATUS_CLOSED || controller->locked())
+  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) {
-  int index = model_->ItemIndexByID(id);
-  if (index < 0)
-    return false;
-  ash::ShelfItemType type = model_->items()[index].type;
-  return (type == ash::TYPE_APP_SHORTCUT || type == ash::TYPE_BROWSER_SHORTCUT);
+  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);
 }
 
 bool ChromeLauncherControllerImpl::IsPinnable(ash::ShelfID id) const {
-  int index = model_->ItemIndexByID(id);
-  if (index == -1)
-    return false;
-
-  ash::ShelfItemType type = model_->items()[index].type;
-  std::string app_id;
-  return ((type == ash::TYPE_APP_SHORTCUT || type == ash::TYPE_APP) &&
+  const ash::ShelfItem* item = GetItem(id);
+  return (item && (item->type == ash::TYPE_APP_SHORTCUT ||
+                   item->type == ash::TYPE_APP) &&
           model_->GetShelfItemDelegate(id)->CanPin());
 }
 
 void ChromeLauncherControllerImpl::LockV1AppWithID(const std::string& app_id) {
   ash::ShelfID id = GetShelfIDForAppID(app_id);
   if (id == ash::kInvalidShelfID) {
     CreateAppShortcutLauncherItemWithType(ash::launcher::AppLauncherId(app_id),
                                           model_->item_count(), ash::TYPE_APP);
     id = GetShelfIDForAppID(app_id);
   }
@@ skipping 19 matching lines @@
 }
 
 void ChromeLauncherControllerImpl::Close(ash::ShelfID id) {
   ash::ShelfItemDelegate* delegate = model_->GetShelfItemDelegate(id);
   if (!delegate)
     return;  // May happen if menu closed.
   delegate->Close();
 }
 
 bool ChromeLauncherControllerImpl::IsOpen(ash::ShelfID id) {
-  const int index = model_->ItemIndexByID(id);
-  return index >= 0 && model_->items()[index].status != ash::STATUS_CLOSED;
+  const ash::ShelfItem* item = GetItem(id);
+  return item && item->status != ash::STATUS_CLOSED;
 }
 
 bool ChromeLauncherControllerImpl::IsPlatformApp(ash::ShelfID id) {
   if (!HasShelfIDToAppIDMapping(id))
     return false;
 
   std::string app_id = GetAppIDForShelfID(id);
   const Extension* extension = GetExtensionForAppID(app_id, profile());
   // An extension can be synced / updated at any time and therefore not be
   // available.
@@ skipping 30 matching lines @@
   if (!extension)
     return extensions::LAUNCH_TYPE_DEFAULT;
 
   return extensions::GetLaunchType(extensions::ExtensionPrefs::Get(profile()),
                                    extension);
 }
 
 void ChromeLauncherControllerImpl::SetLauncherItemImage(
     ash::ShelfID shelf_id,
     const gfx::ImageSkia& image) {
-  int index = model_->ItemIndexByID(shelf_id);
-  if (index == -1)
-    return;
-  ash::ShelfItem item = model_->items()[index];
-  item.image = image;
-  model_->Set(index, item);
+  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 ChromeLauncherControllerImpl::SetLaunchType(
     ash::ShelfID id,
     extensions::LaunchType launch_type) {
   LauncherItemController* controller = GetLauncherItemController(id);
   if (!controller)
     return;
 
   extensions::SetLaunchType(profile(), controller->app_id(), launch_type);
@@ skipping 53 matching lines @@
     int browser_index = model_->GetItemIndexForType(ash::TYPE_BROWSER_SHORTCUT);
     return model_->items()[browser_index].id;
   }
 
   return id;
 }
 
 void ChromeLauncherControllerImpl::SetRefocusURLPatternForTest(
     ash::ShelfID id,
     const GURL& url) {
-  int index = model_->ItemIndexByID(id);
-  if (index == -1) {
-    NOTREACHED() << "Invalid launcher id";
-    return;
-  }
-
-  ash::ShelfItemType type = model_->items()[index].type;
-  if ((type == ash::TYPE_APP_SHORTCUT || type == ash::TYPE_APP) &&
-      !IsPlatformApp(id)) {
+  const ash::ShelfItem* item = GetItem(id);
+  if (item && !IsPlatformApp(id) &&
+      (item->type == ash::TYPE_APP_SHORTCUT || item->type == ash::TYPE_APP)) {
     LauncherItemController* controller = GetLauncherItemController(id);
     DCHECK(controller);
     AppShortcutLauncherItemController* app_controller =
         static_cast<AppShortcutLauncherItemController*>(controller);
     app_controller->set_refocus_url(url);
   } else {
-    NOTREACHED() << "Invalid launcher type";
+    NOTREACHED() << "Invalid launcher item or type";
   }
 }
 
 ash::ShelfItemDelegate::PerformedAction
 ChromeLauncherControllerImpl::ActivateWindowOrMinimizeIfActive(
     ui::BaseWindow* window,
     bool allow_minimize) {
   // In separated desktop mode we might have to teleport a window back to the
   // current user.
   if (chrome::MultiUserWindowManager::GetMultiProfileMode() ==
@@ skipping 55 matching lines @@
 void ChromeLauncherControllerImpl::AdditionalUserAddedToSession(
     Profile* profile) {
   // Switch the running applications to the new user.
   for (auto& controller : app_window_controllers_)
     controller->AdditionalUserAddedToSession(profile);
 }
 
 ChromeLauncherAppMenuItems ChromeLauncherControllerImpl::GetApplicationList(
     const ash::ShelfItem& item,
     int event_flags) {
-  // Make sure that there is a controller associated with the id and that the
-  // extension itself is a valid application and not a panel.
   LauncherItemController* controller = GetLauncherItemController(item.id);
-  if (!controller || !GetShelfIDForAppID(controller->app_id()))
-    return ChromeLauncherAppMenuItems();
-
-  return controller->GetApplicationList(event_flags);
+  return controller ? controller->GetApplicationList(event_flags)
+                    : ChromeLauncherAppMenuItems();
 }
 
 std::vector<content::WebContents*>
 ChromeLauncherControllerImpl::GetV1ApplicationsFromAppId(
     const std::string& app_id) {
-  ash::ShelfID id = GetShelfIDForAppID(app_id);
+  const ash::ShelfItem* item = GetItem(GetShelfIDForAppID(app_id));
   // If there is no such item pinned to the launcher, no menu gets created.
-  if (id != ash::kInvalidShelfID &&
-      GetItem(id).type == ash::TYPE_APP_SHORTCUT) {
-    LauncherItemController* controller = GetLauncherItemController(id);
-    AppShortcutLauncherItemController* app_controller =
-        static_cast<AppShortcutLauncherItemController*>(controller);
-    return app_controller->GetRunningApplications();
-  }
-  return std::vector<content::WebContents*>();
+  if (!item || item->type != ash::TYPE_APP_SHORTCUT)
+    return std::vector<content::WebContents*>();
+  LauncherItemController* controller = GetLauncherItemController(item->id);
+  AppShortcutLauncherItemController* app_controller =
+      static_cast<AppShortcutLauncherItemController*>(controller);
+  return app_controller->GetRunningApplications();
 }
 
 void ChromeLauncherControllerImpl::ActivateShellApp(const std::string& app_id,
                                                     int window_index) {
-  ash::ShelfID id = GetShelfIDForAppID(app_id);
-  if (id != ash::kInvalidShelfID && GetItem(id).type == ash::TYPE_APP) {
-    LauncherItemController* controller = GetLauncherItemController(id);
+  const ash::ShelfItem* item = GetItem(GetShelfIDForAppID(app_id));
+  if (item && item->type == ash::TYPE_APP) {
+    LauncherItemController* controller = GetLauncherItemController(item->id);
     AppWindowLauncherItemController* app_window_controller =
         static_cast<AppWindowLauncherItemController*>(controller);
     app_window_controller->ActivateIndexedApp(window_index);
   }
 }
 
 bool ChromeLauncherControllerImpl::IsWebContentHandledByApplication(
     content::WebContents* web_contents,
     const std::string& app_id) {
   if ((web_contents_to_app_id_.find(web_contents) !=
@@ skipping 45 matching lines @@
     const extensions::Extension* extension =
         GetExtensionForAppID(app_id, profile());
     if (extension)
       return base::UTF8ToUTF16(extension->name());
   }
   return l10n_util::GetStringUTF16(IDS_NEW_TAB_TITLE);
 }
 
 BrowserShortcutLauncherItemController*
 ChromeLauncherControllerImpl::GetBrowserShortcutLauncherItemController() {
-  for (IDToItemControllerMap::iterator i = id_to_item_controller_map_.begin();
-       i != id_to_item_controller_map_.end(); ++i) {
-    int index = model_->ItemIndexByID(i->first);
-    const ash::ShelfItem& item = model_->items()[index];
-    if (item.type == ash::TYPE_BROWSER_SHORTCUT)
-      return static_cast<BrowserShortcutLauncherItemController*>(i->second);
+  for (const auto& pair : id_to_item_controller_map_) {
+    const ash::ShelfItem* item = GetItem(pair.first);
+    if (item && item->type == ash::TYPE_BROWSER_SHORTCUT)
+      return static_cast<BrowserShortcutLauncherItemController*>(pair.second);
   }
   NOTREACHED()
       << "There should be always be a BrowserShortcutLauncherItemController.";
   return nullptr;
 }
 
 LauncherItemController* ChromeLauncherControllerImpl::GetLauncherItemController(
     const ash::ShelfID id) {
   if (!HasShelfIDToAppIDMapping(id))
     return nullptr;
@@ skipping 137 matching lines @@
   if (GetPinnableForAppID(shelf_app_id, profile()) ==
       AppListControllerDelegate::PIN_EDITABLE)
     DoPinAppWithID(shelf_app_id);
   else
     NOTREACHED();
 }
 
 bool ChromeLauncherControllerImpl::IsAppPinned(const std::string& app_id) {
   const std::string shelf_app_id =
       ArcAppWindowLauncherController::GetShelfAppIdFromArcAppId(app_id);
-  for (IDToItemControllerMap::const_iterator i =
-           id_to_item_controller_map_.begin();
-       i != id_to_item_controller_map_.end(); ++i) {
-    if (IsPinned(i->first) && i->second->app_id() == shelf_app_id)
+  for (const auto& pair : id_to_item_controller_map_) {
+    if (IsPinned(pair.first) && pair.second->app_id() == shelf_app_id)
       return true;
   }
   return false;
 }
 
 void ChromeLauncherControllerImpl::UnpinAppWithID(const std::string& app_id) {
   const std::string shelf_app_id =
       ArcAppWindowLauncherController::GetShelfAppIdFromArcAppId(app_id);
   if (GetPinnableForAppID(shelf_app_id, profile()) ==
       AppListControllerDelegate::PIN_EDITABLE)
@@ skipping 76 matching lines @@
 
 void ChromeLauncherControllerImpl::RestoreUnpinnedRunningApplicationOrder(
     const std::string& user_id) {
   const RunningAppListIdMap::iterator app_id_list =
       last_used_running_application_order_.find(user_id);
   if (app_id_list == last_used_running_application_order_.end())
     return;
 
   // Find the first insertion point for running applications.
   int running_index = model_->FirstRunningAppIndex();
-  for (RunningAppListIds::iterator app_id = app_id_list->second.begin();
-       app_id != app_id_list->second.end(); ++app_id) {
-    ash::ShelfID shelf_id = GetShelfIDForAppID(*app_id);
-    if (shelf_id) {
-      int app_index = model_->ItemIndexByID(shelf_id);
+  for (const std::string& app_id : app_id_list->second) {
+    const ash::ShelfItem* item = GetItem(GetShelfIDForAppID(app_id));
+    if (item && item->type == ash::TYPE_APP) {
+      int app_index = model_->ItemIndexByID(item->id);
       DCHECK_GE(app_index, 0);
-      if (model_->items()[app_index].type == ash::TYPE_APP) {
-        if (running_index != app_index)
-          model_->Move(running_index, app_index);
-        running_index++;
-      }
+      if (running_index != app_index)
+        model_->Move(running_index, app_index);
+      running_index++;
     }
   }
 }
 
 ash::ShelfID
 ChromeLauncherControllerImpl::CreateAppShortcutLauncherItemWithType(
     const ash::launcher::AppLauncherId& app_launcher_id,
     int index,
     ash::ShelfItemType shelf_item_type) {
   AppShortcutLauncherItemController* controller =
@@ skipping 41 matching lines @@
 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);
 }
 
 void ChromeLauncherControllerImpl::PinRunningAppInternal(
     int index,
     ash::ShelfID shelf_id) {
+  DCHECK_EQ(GetItem(shelf_id)->type, ash::TYPE_APP);
+  SetItemType(shelf_id, ash::TYPE_APP_SHORTCUT);
   int running_index = model_->ItemIndexByID(shelf_id);
-  ash::ShelfItem item = model_->items()[running_index];
-  DCHECK_EQ(item.type, ash::TYPE_APP);
-  item.type = ash::TYPE_APP_SHORTCUT;
-  model_->Set(running_index, item);
-  // The |ShelfModel|'s weight system might reposition the item to a
-  // new index, so we get the index again.
-  running_index = model_->ItemIndexByID(shelf_id);
   if (running_index < index)
     --index;
   if (running_index != index)
     model_->Move(running_index, index);
 }
 
 void ChromeLauncherControllerImpl::UnpinRunningAppInternal(int index) {
-  DCHECK_GE(index, 0);
+  DCHECK(index >= 0 && index < model_->item_count());
   ash::ShelfItem item = model_->items()[index];
   DCHECK_EQ(item.type, ash::TYPE_APP_SHORTCUT);
-  item.type = ash::TYPE_APP;
-  model_->Set(index, item);
+  SetItemType(item.id, ash::TYPE_APP);
 }
 
 void ChromeLauncherControllerImpl::SyncPinPosition(ash::ShelfID shelf_id) {
   DCHECK(shelf_id);
   if (ignore_persist_pinned_state_change_)
     return;
 
   const int max_index = model_->item_count();
   const int index = model_->ItemIndexByID(shelf_id);
   DCHECK_GT(index, 0);
@@ skipping 381 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.
   }
 }