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

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 337 matching lines @@
 }
 
 void ChromeLauncherControllerImpl::CloseLauncherItem(ash::ShelfID id) {
   CHECK(id);
   if (IsPinned(id)) {
     // Create a new shortcut controller.
     IDToItemControllerMap::iterator iter = id_to_item_controller_map_.find(id);
     CHECK(iter != id_to_item_controller_map_.end());
     SetItemStatus(id, ash::STATUS_CLOSED);
     std::string app_id = iter->second->app_id();
-    iter->second = AppShortcutLauncherItemController::Create(app_id, this);
+    std::string app_shelf_id = iter->second->app_id();
+    if (iter->second->type() == LauncherItemController::TYPE_APP) {
+      AppWindowLauncherItemController* app_window_controller =
+          static_cast<AppWindowLauncherItemController*>(iter->second);
+      app_shelf_id = app_window_controller->app_shelf_id();
+    }
+    iter->second =
+        AppShortcutLauncherItemController::Create(app_id, app_shelf_id, this);
     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));
@@ skipping 52 matching lines @@
     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) &&
           model_->GetShelfItemDelegate(id)->CanPin());
 }
 
 void ChromeLauncherControllerImpl::LockV1AppWithID(const std::string& app_id) {
-  ash::ShelfID id = GetShelfIDForAppID(app_id);
+  ash::ShelfID id = GetShelfIDForAppID(app_id, app_id);
   if (!IsPinned(id) && !IsWindowedAppInLauncher(app_id)) {
     CreateAppShortcutLauncherItemWithType(app_id, model_->item_count(),
                                           ash::TYPE_WINDOWED_APP);
-    id = GetShelfIDForAppID(app_id);
+    id = GetShelfIDForAppID(app_id, 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);
+  ash::ShelfID id = GetShelfIDForAppID(app_id, app_id);
   CHECK(id);
   CHECK(IsPinned(id) || IsWindowedAppInLauncher(app_id));
   LauncherItemController* controller = id_to_item_controller_map_[id];
   controller->unlock();
   if (!controller->locked() && !IsPinned(id))
     CloseLauncherItem(id);
 }
 
 void ChromeLauncherControllerImpl::Launch(ash::ShelfID id, int event_flags) {
   LauncherItemController* controller = GetLauncherItemController(id);
@@ skipping 30 matching lines @@
 void ChromeLauncherControllerImpl::LaunchApp(const std::string& app_id,
                                              ash::LaunchSource source,
                                              int event_flags) {
   launcher_controller_helper_->LaunchApp(app_id, source, event_flags);
 }
 
 void ChromeLauncherControllerImpl::ActivateApp(const std::string& app_id,
                                                ash::LaunchSource source,
                                                int event_flags) {
   // If there is an existing non-shortcut controller for this app, open it.
-  ash::ShelfID id = GetShelfIDForAppID(app_id);
+  ash::ShelfID id = GetShelfIDForAppID(app_id, app_id);
   if (id) {
     LauncherItemController* controller = GetLauncherItemController(id);
     controller->Activate(source);
     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, this));
+      AppShortcutLauncherItemController::Create(app_id, app_id, this));
   if (!app_controller->GetRunningApplications().empty())
     app_controller->Activate(source);
   else
     LaunchApp(app_id, source, event_flags);
 }
 
 extensions::LaunchType ChromeLauncherControllerImpl::GetLaunchType(
     ash::ShelfID id) {
   const Extension* extension =
       GetExtensionForAppID(GetAppIDForShelfID(id), profile_);
@@ skipping 12 matching lines @@
   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));
+  int index = model_->ItemIndexByID(GetShelfIDForAppID(app_id, 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) {
@@ skipping 16 matching lines @@
   // Check if the gMail app is loaded and it matches the given content.
   // This special treatment is needed to address crbug.com/234268.
   if (app_id.empty() && ContentCanBeHandledByGmailApp(contents))
     app_id = kGmailAppId;
 
   // Check the old |app_id| for a tab. If the contents has changed we need to
   // remove it from the previous app.
   if (web_contents_to_app_id_.find(contents) != web_contents_to_app_id_.end()) {
     std::string last_app_id = web_contents_to_app_id_[contents];
     if (last_app_id != app_id) {
-      ash::ShelfID id = GetShelfIDForAppID(last_app_id);
+      ash::ShelfID id = GetShelfIDForAppID(last_app_id, last_app_id);
       if (id) {
         // Since GetAppState() will use |web_contents_to_app_id_| we remove
         // the connection before calling it.
         web_contents_to_app_id_.erase(contents);
         SetItemStatus(id, GetAppState(last_app_id));
       }
     }
   }
 
   if (app_state == APP_STATE_REMOVED)
     web_contents_to_app_id_.erase(contents);
   else
     web_contents_to_app_id_[contents] = app_id;
 
-  ash::ShelfID id = GetShelfIDForAppID(app_id);
+  ash::ShelfID id = GetShelfIDForAppID(app_id, app_id);
   if (id) {
     SetItemStatus(id, (app_state == APP_STATE_WINDOW_ACTIVE ||
                        app_state == APP_STATE_ACTIVE)
                           ? ash::STATUS_ACTIVE
                           : GetAppState(app_id));
   }
 }
 
 ash::ShelfID ChromeLauncherControllerImpl::GetShelfIDForWebContents(
     content::WebContents* contents) {
   DCHECK(contents);
 
   std::string app_id = launcher_controller_helper_->GetAppID(contents);
 
   if (app_id.empty() && ContentCanBeHandledByGmailApp(contents))
     app_id = kGmailAppId;
 
-  ash::ShelfID id = GetShelfIDForAppID(app_id);
+  ash::ShelfID id = GetShelfIDForAppID(app_id, app_id);
 
   if (app_id.empty() || !id) {
     int browser_index = model_->GetItemIndexForType(ash::TYPE_BROWSER_SHORTCUT);
     return model_->items()[browser_index].id;
   }
 
   return id;
 }
 
 void ChromeLauncherControllerImpl::SetRefocusURLPatternForTest(
@@ skipping 86 matching lines @@
   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()))
+  if (!controller ||
+      !GetShelfIDForAppID(controller->app_id(), 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);
+  ash::ShelfID id = GetShelfIDForAppID(app_id, app_id);
 
   // If there is no such an item pinned to the launcher, no menu gets created.
   if (id) {
     LauncherItemController* controller = GetLauncherItemController(id);
     DCHECK(controller);
     if (controller->type() == LauncherItemController::TYPE_SHORTCUT)
       return GetV1ApplicationsFromController(controller);
   }
   return std::vector<content::WebContents*>();
 }
 
 void ChromeLauncherControllerImpl::ActivateShellApp(const std::string& app_id,
                                                     int index) {
-  ash::ShelfID id = GetShelfIDForAppID(app_id);
+  ash::ShelfID id = GetShelfIDForAppID(app_id, app_id);
   if (id) {
     LauncherItemController* controller = GetLauncherItemController(id);
     if (controller && controller->type() == LauncherItemController::TYPE_APP) {
       AppWindowLauncherItemController* app_window_controller =
           static_cast<AppWindowLauncherItemController*>(controller);
       app_window_controller->ActivateIndexedApp(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;
   return (app_id == kGmailAppId && ContentCanBeHandledByGmailApp(web_contents));
 }
 
 bool ChromeLauncherControllerImpl::ContentCanBeHandledByGmailApp(
     content::WebContents* web_contents) {
-  ash::ShelfID id = GetShelfIDForAppID(kGmailAppId);
+  ash::ShelfID id = GetShelfIDForAppID(kGmailAppId, kGmailAppId);
   if (id) {
     const GURL url = web_contents->GetURL();
     // We need to extend the application matching for the gMail app beyond the
     // manifest file's specification. This is required because of the namespace
     // overlap with the offline app ("/mail/mu/").
     if (!base::MatchPattern(url.path(), "/mail/mu/*") &&
         base::MatchPattern(url.path(), "/mail/*") &&
         GetExtensionForAppID(kGmailAppId, profile_) &&
         GetExtensionForAppID(kGmailAppId, profile_)->OverlapsWithOrigin(url))
       return true;
@@ skipping 116 matching lines @@
                                               shelf->auto_hide_behavior());
 }
 
 void ChromeLauncherControllerImpl::OnShelfAutoHideStateChanged(
     ash::Shelf* shelf) {}
 
 void ChromeLauncherControllerImpl::OnShelfVisibilityStateChanged(
     ash::Shelf* shelf) {}
 
 ash::ShelfID ChromeLauncherControllerImpl::GetShelfIDForAppID(
-    const std::string& app_id) {
+    const std::string& app_id,
+    const std::string& app_shelf_id) {
   for (IDToItemControllerMap::const_iterator i =
            id_to_item_controller_map_.begin();
        i != id_to_item_controller_map_.end(); ++i) {

[stevenjb, 2016/08/29 15:56:30]

Convert this to a C++11 style iterator

[Andra Paraschiv, 2016/08/30 09:58:24]

Done.

     if (i->second->type() == LauncherItemController::TYPE_APP_PANEL)
       continue;  // Don't include panels
-    if (i->second->app_id() == app_id)
+    // If app window controller, check app_id and app_shelf_id.
+    if (i->second->type() == LauncherItemController::TYPE_APP) {
+      AppWindowLauncherItemController* app_window_controller =
+          static_cast<AppWindowLauncherItemController*>(i->second);
+      if ((app_window_controller->app_id() == app_id) &&
+          (app_window_controller->app_shelf_id() == app_shelf_id)) {
+        return i->first;
+      }
+      // If not browser shortcut controller, check app_id and app_shelf_id.
+    } else if ((i->second->type() == LauncherItemController::TYPE_SHORTCUT) &&
+               (i->second->app_id() != extension_misc::kChromeAppId)) {
+      AppShortcutLauncherItemController* app_shortcut_controller =
+          static_cast<AppShortcutLauncherItemController*>(i->second);
+      if ((app_shortcut_controller->app_id() == app_id) &&
+          (app_shortcut_controller->app_shelf_id() == app_shelf_id)) {
+        return i->first;
+      }
+    } else if (i->second->app_id() == app_id) {
       return i->first;
+    }
   }
   return 0;
 }
 
 bool ChromeLauncherControllerImpl::HasShelfIDToAppIDMapping(
     ash::ShelfID id) const {
   return id_to_item_controller_map_.find(id) !=
          id_to_item_controller_map_.end();
 }
 
@@ skipping 54 matching lines @@
   if (app_icon_loader)
     app_icon_loader->UpdateImage(app_id);
 }
 
 void ChromeLauncherControllerImpl::OnAppUninstalledPrepared(
     content::BrowserContext* browser_context,
     const std::string& app_id) {
   // Since we might have windowed apps of this type which might have
   // outstanding locks which needs to be removed.
   const Profile* profile = Profile::FromBrowserContext(browser_context);
-  if (GetShelfIDForAppID(app_id))
+  if (GetShelfIDForAppID(app_id, app_id))
     CloseWindowedAppsFromRemovedExtension(app_id, profile);
 
   if (IsAppPinned(app_id)) {
     if (profile == profile_)
       DoUnpinAppWithID(app_id);
     AppIconLoader* app_icon_loader = GetAppIconLoaderForApp(app_id);
     if (app_icon_loader)
       app_icon_loader->ClearImage(app_id);
   }
 }
@@ skipping 44 matching lines @@
     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);
+    ash::ShelfID shelf_id = GetShelfIDForAppID(*app_id, *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 (running_index != app_index)
           model_->Move(running_index, app_index);
         running_index++;
       }
     }
   }
 }
 
 ash::ShelfID
 ChromeLauncherControllerImpl::CreateAppShortcutLauncherItemWithType(
     const std::string& app_id,
     int index,
     ash::ShelfItemType shelf_item_type) {
   AppShortcutLauncherItemController* controller =
-      AppShortcutLauncherItemController::Create(app_id, this);
+      AppShortcutLauncherItemController::Create(app_id, app_id, this);
   ash::ShelfID shelf_id = InsertAppLauncherItem(
       controller, 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)
     app_icon_loader->ClearImage(app_id);
   id_to_item_controller_map_.erase(iter);
   int index = model_->ItemIndexByID(id);
   // 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_->RemoveItemAt(index);
 }
 
 void ChromeLauncherControllerImpl::DoPinAppWithID(const std::string& app_id) {
   // If there is an item, do nothing and return.
   if (IsAppPinned(app_id))
     return;
 
-  ash::ShelfID shelf_id = GetShelfIDForAppID(app_id);
+  ash::ShelfID shelf_id = GetShelfIDForAppID(app_id, 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());
     SyncPinPosition(shelf_id);
   }
 }
 
 void ChromeLauncherControllerImpl::DoUnpinAppWithID(const std::string& app_id) {
-  ash::ShelfID shelf_id = GetShelfIDForAppID(app_id);
+  ash::ShelfID shelf_id = GetShelfIDForAppID(app_id, app_id);
   if (shelf_id && IsPinned(shelf_id))
     Unpin(shelf_id);
 }
 
 int 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);
@@ skipping 137 matching lines @@
             --max_index;
           }
           --index;
         }
       }
       // If the item wasn't found, that means id_to_item_controller_map_
       // is out of sync.
       DCHECK(index <= max_index);
     } else {
       // Check if the item was already running but not yet pinned.
-      ash::ShelfID shelf_id = GetShelfIDForAppID(*pref_app_id);
+      ash::ShelfID shelf_id = GetShelfIDForAppID(*pref_app_id, *pref_app_id);
       if (shelf_id) {
         // This app is running but not yet pinned. So pin and move it.
         index = PinRunningAppInternal(index, shelf_id);
       } else {
         // This app wasn't pinned before, insert a new entry.
         shelf_id = CreateAppShortcutLauncherItem(*pref_app_id, index);
         ++max_index;
         index = model_->ItemIndexByID(shelf_id);
       }
       ++pref_app_id;
@@ skipping 22 matching lines @@
   for (; pref_app_id != pinned_apps.end(); ++pref_app_id) {
     // Update apps icon if applicable.
     OnAppUpdated(profile_, *pref_app_id);
     if (*pref_app_id == extension_misc::kChromeAppId) {
       int target_index = FindInsertionPoint();
       DCHECK(seen_chrome_index >= 0 && seen_chrome_index < target_index);
       model_->Move(seen_chrome_index, target_index);
     } else {
       DoPinAppWithID(*pref_app_id);
       int target_index = FindInsertionPoint();
-      ash::ShelfID id = GetShelfIDForAppID(*pref_app_id);
+      ash::ShelfID id = GetShelfIDForAppID(*pref_app_id, *pref_app_id);
       int source_index = model_->ItemIndexByID(id);
       if (source_index != target_index)
         model_->Move(source_index, target_index);
     }
   }
 }
 
 void ChromeLauncherControllerImpl::SetShelfAutoHideBehaviorFromPrefs() {
   for (ash::WmWindow* window : ash::WmShell::Get()->GetAllRootWindows()) {
     ash::Shelf* shelf = ash::Shelf::ForWindow(window);
@@ skipping 365 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.
   }
 }