Remove LauncherItemController::type; use ShelfItems::type.

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 280 matching lines @@
 
   prefs_observer_ =
       ash::launcher::ChromeLauncherPrefsObserver::CreateIfNecessary(profile());
 }
 
 ash::ShelfID ChromeLauncherControllerImpl::CreateAppLauncherItem(
     LauncherItemController* controller,
     const std::string& app_id,
     ash::ShelfItemStatus status) {
   return InsertAppLauncherItem(controller, app_id, status, model_->item_count(),
-                               controller->GetShelfItemType());
+                               ash::TYPE_APP);

[msw, 2016/12/02 02:59:26]

note: the two callers of CreateAppLauncherItem supplied
ArcAppWindowLauncherItemController (always TYPE_APP) and
ExtensionAppWindowLauncherItemController instances constructed with TYPE_APP, so
it's safe to infer that CreateAppLauncherItem callers want TYPE_APP items.

+}
+
+const ash::ShelfItem& ChromeLauncherControllerImpl::GetItem(
+    ash::ShelfID id) const {
+  const int index = model_->ItemIndexByID(id);
+  DCHECK_GE(index, 0);
+  return model_->items()[index];
+}
+
+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);
+  }
 }
 
 void ChromeLauncherControllerImpl::SetItemStatus(ash::ShelfID id,
                                                  ash::ShelfItemStatus status) {
-  int index = model_->ItemIndexByID(id);
-  ash::ShelfItemStatus old_status = model_->items()[index].status;
-  // Since ordinary browser windows are not registered, we might get a negative
-  // index here.
-  if (index >= 0 && old_status != status) {
-    ash::ShelfItem item = model_->items()[index];
+  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);
   }
 }
 
 void ChromeLauncherControllerImpl::SetItemController(
     ash::ShelfID id,
     LauncherItemController* controller) {
   CHECK(controller);
   IDToItemControllerMap::iterator iter = id_to_item_controller_map_.find(id);
@@ skipping 49 matching lines @@
                                                        bool update_prefs) {
   LauncherItemController* controller = GetLauncherItemController(id);
   CHECK(controller);
 
   if (update_prefs) {
     ash::launcher::RemovePinPosition(
         profile(), ash::launcher::AppLauncherId(GetAppIDForShelfID(id),
                                                 GetLaunchIDForShelfID(id)));
   }
 
-  if (controller->type() == LauncherItemController::TYPE_APP ||
-      controller->locked()) {
+  if (GetItem(id).status != ash::STATUS_CLOSED || controller->locked())
     UnpinRunningAppInternal(model_->ItemIndexByID(id));
-  } else {
+  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);
 }
 
@@ skipping 282 matching lines @@
   if (!controller || !GetShelfIDForAppID(controller->app_id()))
     return ChromeLauncherAppMenuItems();
 
   return controller->GetApplicationList(event_flags);
 }
 
 std::vector<content::WebContents*>
 ChromeLauncherControllerImpl::GetV1ApplicationsFromAppId(
     const std::string& app_id) {
   ash::ShelfID id = GetShelfIDForAppID(app_id);
-
-  // If there is no such an item pinned to the launcher, no menu gets created.
-  if (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);
-    DCHECK(controller);
-    if (controller->type() == LauncherItemController::TYPE_SHORTCUT)
-      return GetV1ApplicationsFromController(controller);
+    AppShortcutLauncherItemController* app_controller =
+        static_cast<AppShortcutLauncherItemController*>(controller);
+    return app_controller->GetRunningApplications();
   }
   return std::vector<content::WebContents*>();
 }
 
 void ChromeLauncherControllerImpl::ActivateShellApp(const std::string& app_id,
-                                                    int index) {
+                                                    int window_index) {
   ash::ShelfID id = GetShelfIDForAppID(app_id);
-  if (id) {
+  if (id != ash::kInvalidShelfID && GetItem(id).type == ash::TYPE_APP) {
     LauncherItemController* controller = GetLauncherItemController(id);
-    if (controller && controller->type() == LauncherItemController::TYPE_APP) {
-      AppWindowLauncherItemController* app_window_controller =
-          static_cast<AppWindowLauncherItemController*>(controller);
-      app_window_controller->ActivateIndexedApp(index);
-    }
+    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) !=
        web_contents_to_app_id_.end()) &&
       (web_contents_to_app_id_[web_contents] == app_id))
     return true;
@@ skipping 535 matching lines @@
     if (item.type != ash::TYPE_APP_SHORTCUT) {
       ++index;
       continue;
     }
 
     const LauncherItemController* controller =
         GetLauncherItemController(item.id);
     DCHECK(controller);
     DCHECK_NE(controller->app_id(), extension_misc::kChromeAppId);
 
-    if (controller->locked() ||
-        controller->type() == LauncherItemController::TYPE_APP) {
+    if (item.status != ash::STATUS_CLOSED || controller->locked()) {
       UnpinRunningAppInternal(index);
       // Note, item can be moved to the right due weighting in shelf model.
       DCHECK_GE(model_->ItemIndexByID(item.id), index);
     } else {
       LauncherItemClosed(item.id);
     }
   }
 }
 
 void ChromeLauncherControllerImpl::SetVirtualKeyboardBehaviorFromPrefs() {
@@ skipping 42 matching lines @@
 ash::ShelfID ChromeLauncherControllerImpl::InsertAppLauncherItem(
     LauncherItemController* controller,
     const std::string& app_id,
     ash::ShelfItemStatus status,
     int index,
     ash::ShelfItemType shelf_item_type) {
   ash::ShelfID id = model_->next_id();
   CHECK(!HasShelfIDToAppIDMapping(id));
   CHECK(controller);
   // Ash's ShelfWindowWatcher handles app panel windows separately.
-  DCHECK_NE(ash::TYPE_APP_PANEL, controller->GetShelfItemType());
+  DCHECK_NE(ash::TYPE_APP_PANEL, shelf_item_type);
   id_to_item_controller_map_[id] = controller;
   controller->set_shelf_id(id);
 
   ash::ShelfItem item;
   item.type = shelf_item_type;
   item.image = extensions::util::GetDefaultAppIcon();
 
   ash::ShelfItemStatus new_state = GetAppState(app_id);
   if (new_state != ash::STATUS_CLOSED)
     status = new_state;
 
   item.status = status;
   model_->AddAt(index, item);
 
   AppIconLoader* app_icon_loader = GetAppIconLoaderForApp(app_id);
   if (app_icon_loader) {
     app_icon_loader->FetchImage(app_id);
     app_icon_loader->UpdateImage(app_id);
   }
 
   SetShelfItemDelegate(id, controller);
 
   return id;
 }
 
-std::vector<content::WebContents*>
-ChromeLauncherControllerImpl::GetV1ApplicationsFromController(
-    LauncherItemController* controller) {
-  DCHECK(controller->type() == LauncherItemController::TYPE_SHORTCUT);
-  AppShortcutLauncherItemController* app_controller =
-      static_cast<AppShortcutLauncherItemController*>(controller);
-  return app_controller->GetRunningApplications();
-}
-
 void ChromeLauncherControllerImpl::CreateBrowserShortcutLauncherItem() {
   ash::ShelfItem browser_shortcut;
   browser_shortcut.type = ash::TYPE_BROWSER_SHORTCUT;
   ResourceBundle& rb = ResourceBundle::GetSharedInstance();
   browser_shortcut.image = *rb.GetImageSkiaNamed(IDR_PRODUCT_LOGO_32);
   ash::ShelfID id = model_->next_id();
   model_->AddAt(0, browser_shortcut);
   id_to_item_controller_map_[id] =
       new BrowserShortcutLauncherItemController(this, model_);
   id_to_item_controller_map_[id]->set_shelf_id(id);
@@ skipping 154 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.
   }
 }