Enhance chrome.app.window API for shelf integration with pinning support (cont.)

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 20 matching lines @@
 #include "chrome/browser/chromeos/extensions/gfx_utils.h"
 #include "chrome/browser/defaults.h"
 #include "chrome/browser/extensions/extension_util.h"
 #include "chrome/browser/extensions/launch_util.h"
 #include "chrome/browser/prefs/incognito_mode_prefs.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/ui/app_list/app_list_syncable_service_factory.h"
 #include "chrome/browser/ui/app_list/arc/arc_app_utils.h"
 #include "chrome/browser/ui/ash/app_sync_ui_state.h"
-#include "chrome/browser/ui/ash/chrome_launcher_prefs.h"
 #include "chrome/browser/ui/ash/chrome_shell_delegate.h"
 #include "chrome/browser/ui/ash/launcher/app_shortcut_launcher_item_controller.h"
 #include "chrome/browser/ui/ash/launcher/app_window_launcher_controller.h"
 #include "chrome/browser/ui/ash/launcher/app_window_launcher_item_controller.h"
 #include "chrome/browser/ui/ash/launcher/arc_app_deferred_launcher_controller.h"
 #include "chrome/browser/ui/ash/launcher/arc_app_window_launcher_controller.h"
 #include "chrome/browser/ui/ash/launcher/browser_shortcut_launcher_item_controller.h"
 #include "chrome/browser/ui/ash/launcher/browser_status_monitor.h"
 #include "chrome/browser/ui/ash/launcher/chrome_launcher_app_menu_item.h"
 #include "chrome/browser/ui/ash/launcher/chrome_launcher_app_menu_item_browser.h"
@@ skipping 318 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)));
+        profile(), ash::launcher::AppLauncherId(GetAppIDForShelfID(id),
+                                                GetLaunchIDForShelfID(id)));
   }
 
   if (controller->type() == LauncherItemController::TYPE_APP ||
       controller->locked()) {
     UnpinRunningAppInternal(model_->ItemIndexByID(id));
   } else {
     LauncherItemClosed(id);
   }
 }
 
@@ skipping 23 matching lines @@
   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) &&
           model_->GetShelfItemDelegate(id)->CanPin());
 }
 
 void ChromeLauncherControllerImpl::LockV1AppWithID(const std::string& app_id) {
   ash::ShelfID id = GetShelfIDForAppID(app_id);
   if (!IsPinned(id) && !IsWindowedAppInLauncher(app_id)) {
-    CreateAppShortcutLauncherItemWithType(app_id, model_->item_count(),
+    CreateAppShortcutLauncherItemWithType(ash::launcher::AppLauncherId(app_id),
+                                          model_->item_count(),
                                           ash::TYPE_WINDOWED_APP);
     id = GetShelfIDForAppID(app_id);
   }
   CHECK(id);
   id_to_item_controller_map_[id]->lock();
 }
 
 void ChromeLauncherControllerImpl::UnlockV1AppWithID(
     const std::string& app_id) {
   ash::ShelfID id = GetShelfIDForAppID(app_id);
@@ skipping 398 matching lines @@
     Profile* profile) {
   if (user_switch_observer_.get())
     user_switch_observer_->OnUserProfileReadyToSwitch(profile);
 }
 
 ArcAppDeferredLauncherController*
 ChromeLauncherControllerImpl::GetArcDeferredLauncher() {
   return arc_deferred_launcher_.get();
 }
 
+const std::string& ChromeLauncherControllerImpl::GetLaunchIDForShelfID(
+    ash::ShelfID id) {
+  LauncherItemController* controller = GetLauncherItemController(id);
+  return controller ? controller->launch_id() : base::EmptyString();
+}
+
 void ChromeLauncherControllerImpl::AttachProfile(Profile* profile_to_attach) {
   // The base class implementation updates the helper and app icon loaders.
   ChromeLauncherController::AttachProfile(profile_to_attach);
 
   pref_change_registrar_.Init(profile()->GetPrefs());
   pref_change_registrar_.Add(
       prefs::kPolicyPinnedLauncherApps,
       base::Bind(&ChromeLauncherControllerImpl::UpdateAppLaunchersFromPref,
                  base::Unretained(this)));
   // Handling of prefs::kArcEnabled change should be called deferred to avoid
@@ skipping 153 matching lines @@
     AppIconLoader* app_icon_loader = GetAppIconLoaderForApp(app_id);
     if (app_icon_loader)
       app_icon_loader->ClearImage(app_id);
   }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // ChromeLauncherControllerImpl protected:
 
 ash::ShelfID ChromeLauncherControllerImpl::CreateAppShortcutLauncherItem(
-    const std::string& app_id,
+    const ash::launcher::AppLauncherId& app_launcher_id,
     int index) {
-  return CreateAppShortcutLauncherItemWithType(app_id, index,
+  return CreateAppShortcutLauncherItemWithType(app_launcher_id, index,
                                                ash::TYPE_APP_SHORTCUT);
 }
 
 const std::string& ChromeLauncherControllerImpl::GetAppIdFromShelfIdForTest(
     ash::ShelfID id) {
   return id_to_item_controller_map_[id]->app_id();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // ChromeLauncherControllerImpl private:
@@ skipping 30 matching lines @@
         if (running_index != app_index)
           model_->Move(running_index, app_index);
         running_index++;
       }
     }
   }
 }
 
 ash::ShelfID
 ChromeLauncherControllerImpl::CreateAppShortcutLauncherItemWithType(
-    const std::string& app_id,
+    const ash::launcher::AppLauncherId& app_launcher_id,
     int index,
     ash::ShelfItemType shelf_item_type) {
   AppShortcutLauncherItemController* controller =
-      AppShortcutLauncherItemController::Create(app_id, "", this);
-  ash::ShelfID shelf_id = InsertAppLauncherItem(
-      controller, app_id, ash::STATUS_CLOSED, index, shelf_item_type);
+      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;
 }
 
 void ChromeLauncherControllerImpl::LauncherItemClosed(ash::ShelfID id) {
   IDToItemControllerMap::iterator iter = id_to_item_controller_map_.find(id);
   CHECK(iter != id_to_item_controller_map_.end());
   CHECK(iter->second);
   const std::string& app_id = iter->second->app_id();
   AppIconLoader* app_icon_loader = GetAppIconLoaderForApp(app_id);
   if (app_icon_loader)
@@ skipping 10 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(app_id, model_->item_count());
+    shelf_id = CreateAppShortcutLauncherItem(
+        ash::launcher::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 33 matching lines @@
   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);
 
   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;
 
   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));
+          ash::launcher::AppLauncherId(app_id_after, launch_id_after));
     }
   }
 
   ash::launcher::AppLauncherId app_launcher_id_before =
-      app_id_before.empty() ? ash::launcher::AppLauncherId()
-                            : ash::launcher::AppLauncherId(app_id_before);
+      app_id_before.empty()
+          ? ash::launcher::AppLauncherId()
+          : ash::launcher::AppLauncherId(app_id_before, launch_id_before);
 
-  ash::launcher::SetPinPosition(profile(), ash::launcher::AppLauncherId(app_id),
+  ash::launcher::SetPinPosition(profile(),
+                                ash::launcher::AppLauncherId(app_id, launch_id),
                                 app_launcher_id_before, app_launcher_ids_after);
 }
 
 void ChromeLauncherControllerImpl::OnSyncModelUpdated() {
   UpdateAppLaunchersFromPref();
 }
 
 void ChromeLauncherControllerImpl::ScheduleUpdateAppLaunchersFromPref() {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
@@ skipping 18 matching lines @@
   // 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
   // the new pin at that position.
   for (const auto& pref_app_launcher_id : pinned_apps) {
     // Filter out apps that may be mapped wrongly.
     // TODO(khmel):  b/31703859 is to refactore shelf mapping.
-    const std::string app_launcher_id_str = pref_app_launcher_id.ToString();
+    const std::string app_id = pref_app_launcher_id.app_id();
     const std::string shelf_app_id =
-        ArcAppWindowLauncherController::GetShelfAppIdFromArcAppId(
-            app_launcher_id_str);
-    if (shelf_app_id != app_launcher_id_str)
+        ArcAppWindowLauncherController::GetShelfAppIdFromArcAppId(app_id);
+    if (shelf_app_id != app_id)
       continue;
 
     // Update apps icon if applicable.
-    OnAppUpdated(profile(), app_launcher_id_str);
+    OnAppUpdated(profile(), app_id);
 
     // Find existing pin or app from the right of current |index|.
     int app_index = index;
     for (; app_index < model_->item_count(); ++app_index) {
       const ash::ShelfItem& item = model_->items()[app_index];
       const IDToItemControllerMap::iterator it =
           id_to_item_controller_map_.find(item.id);
       if (it != id_to_item_controller_map_.end() &&
-          it->second->app_id() == app_launcher_id_str) {
+          it->second->app_id() == app_id &&
+          it->second->launch_id() == pref_app_launcher_id.launch_id()) {
         break;
       }
     }
     if (app_index < model_->item_count()) {
       // Found existing pin or running app.
       const ash::ShelfItem item = model_->items()[app_index];
       if (item.type == ash::TYPE_APP_SHORTCUT ||
           item.type == ash::TYPE_BROWSER_SHORTCUT) {
         // Just move to required position or keep it inplace.
         model_->Move(app_index, index);
       } else {
         PinRunningAppInternal(index, item.id);
       }
       DCHECK_EQ(model_->ItemIndexByID(item.id), index);
     } else {
       // This is fresh pin. Create new one.
-      DCHECK_NE(app_launcher_id_str, extension_misc::kChromeAppId);
-      CreateAppShortcutLauncherItem(app_launcher_id_str, index);
+      DCHECK_NE(app_id, extension_misc::kChromeAppId);
+      CreateAppShortcutLauncherItem(pref_app_launcher_id, index);
     }
     ++index;
   }
 
   // At second step remove any pin to the right from the current index.
   while (index < model_->item_count()) {
     const ash::ShelfItem item = model_->items()[index];
     if (item.type != ash::TYPE_APP_SHORTCUT) {
       ++index;
       continue;
@@ skipping 277 matching lines @@
     if (index == -1)
       continue;
     ash::ShelfItem item = model_->items()[index];
     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.
   }
 }