Combine shelf platform and windowed app types.

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 335 matching lines @@
 }
 
 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_PLATFORM_APP ||
-      item.type == ash::TYPE_WINDOWED_APP) {
+  if (item.type == ash::TYPE_APP) {
     item.type = ash::TYPE_APP_SHORTCUT;
     model_->Set(index, item);
   } else if (item.type != ash::TYPE_APP_SHORTCUT) {
     return;
   }
 
   SyncPinPosition(id);
 }
 
 void ChromeLauncherControllerImpl::Unpin(ash::ShelfID id) {
@@ skipping 37 matching lines @@
     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_PLATFORM_APP ||
-           type == ash::TYPE_WINDOWED_APP) &&
+  return ((type == ash::TYPE_APP_SHORTCUT || type == ash::TYPE_APP) &&
           model_->GetShelfItemDelegate(id)->CanPin());
 }
 
 void ChromeLauncherControllerImpl::LockV1AppWithID(const std::string& app_id) {
   ash::ShelfID id = GetShelfIDForAppID(app_id);
-  if (!IsPinned(id) && !IsWindowedAppInLauncher(app_id)) {
+  if (id == ash::kInvalidShelfID) {
     CreateAppShortcutLauncherItemWithType(ash::launcher::AppLauncherId(app_id),
-                                          model_->item_count(),
-                                          ash::TYPE_WINDOWED_APP);
+                                          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(id);
-  CHECK(IsPinned(id) || IsWindowedAppInLauncher(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.
@@ skipping 61 matching lines @@
     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);
 }
 
-bool ChromeLauncherControllerImpl::IsWindowedAppInLauncher(
-    const std::string& app_id) {
-  int index = model_->ItemIndexByID(GetShelfIDForAppID(app_id));
-  if (index < 0)
-    return false;
-
-  ash::ShelfItemType type = model_->items()[index].type;
-  return type == ash::TYPE_WINDOWED_APP;
-}
-
 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 51 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) {
-  LauncherItemController* controller = GetLauncherItemController(id);
-  DCHECK(controller);
-
   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_WINDOWED_APP) {
+  if ((type == ash::TYPE_APP_SHORTCUT || type == ash::TYPE_APP) &&
+      !IsPlatformApp(id)) {
+    LauncherItemController* controller = GetLauncherItemController(id);

[Mr4D (OOO till 08-26), 2016/11/23 23:11:51]

You might want to dcheck the controller?

[msw, 2016/11/24 00:00:55]

I don't usually DCHECK immediately before a dereference; line 597 will crash if
it's null; but I can add a DCHECK if you still prefer that.

[Mr4D (OOO till 08-26), 2016/11/24 02:21:33]

I'd like that - Thanks!

[msw, 2016/11/28 20:13:31]

Done.

     AppShortcutLauncherItemController* app_controller =
         static_cast<AppShortcutLauncherItemController*>(controller);
     app_controller->set_refocus_url(url);
   } else {
     NOTREACHED() << "Invalid launcher type";
   }
 }
 
 ash::ShelfItemDelegate::PerformedAction
 ChromeLauncherControllerImpl::ActivateWindowOrMinimizeIfActive(
@@ skipping 402 matching lines @@
   return CreateAppShortcutLauncherItemWithType(app_launcher_id, index,
                                                ash::TYPE_APP_SHORTCUT);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // ChromeLauncherControllerImpl private:
 
 void ChromeLauncherControllerImpl::RememberUnpinnedRunningApplicationOrder() {
   RunningAppListIds list;
   for (int i = 0; i < model_->item_count(); i++) {
-    ash::ShelfItemType type = model_->items()[i].type;
-    if (type == ash::TYPE_WINDOWED_APP || type == ash::TYPE_PLATFORM_APP)
+    if (model_->items()[i].type == ash::TYPE_APP)
       list.push_back(GetAppIDForShelfID(model_->items()[i].id));
   }
   const std::string user_email =
       multi_user_util::GetAccountIdFromProfile(profile()).GetUserEmail();
   last_used_running_application_order_[user_email] = list;
 }
 
 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);
       DCHECK_GE(app_index, 0);
-      ash::ShelfItemType type = model_->items()[app_index].type;
-      if (type == ash::TYPE_WINDOWED_APP || type == ash::TYPE_PLATFORM_APP) {
+      if (model_->items()[app_index].type == ash::TYPE_APP) {
         if (running_index != app_index)
           model_->Move(running_index, app_index);
         running_index++;
       }
     }
   }
 }
 
 ash::ShelfID
 ChromeLauncherControllerImpl::CreateAppShortcutLauncherItemWithType(
@@ skipping 47 matching lines @@
   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) {
   int running_index = model_->ItemIndexByID(shelf_id);
   ash::ShelfItem item = model_->items()[running_index];
-  DCHECK(item.type == ash::TYPE_WINDOWED_APP ||
-         item.type == ash::TYPE_PLATFORM_APP);
+  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);
   ash::ShelfItem item = model_->items()[index];
   DCHECK_EQ(item.type, ash::TYPE_APP_SHORTCUT);
-  item.type = ash::TYPE_WINDOWED_APP;
-  // A platform app and a windowed app are sharing TYPE_APP_SHORTCUT. As such
-  // we have to check here what this was before it got a shortcut.
-  LauncherItemController* controller = GetLauncherItemController(item.id);
-  if (controller && controller->type() == LauncherItemController::TYPE_APP)
-    item.type = ash::TYPE_PLATFORM_APP;
+  item.type = ash::TYPE_APP;
   model_->Set(index, item);
 }
 
 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);
@@ skipping 392 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.
   }
 }