Showing launcher items for windowed v1 apps - pinned or not. Also - don't show windowed v1 apps in …

chrome/browser/ui/ash/launcher/chrome_launcher_controller_per_app.cc

 // Copyright (c) 2012 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_per_app.h"
 
 #include <vector>
 
 #include "ash/launcher/launcher_model.h"
 #include "ash/launcher/launcher_util.h"
@@ skipping 282 matching lines @@
   id_to_item_controller_map_[id] = controller;
   controller->set_launcher_id(id);
   return id;
 }
 
 ash::LauncherID ChromeLauncherControllerPerApp::CreateAppLauncherItem(
     LauncherItemController* controller,
     const std::string& app_id,
     ash::LauncherItemStatus status) {
   DCHECK(controller);
-  return InsertAppLauncherItem(controller, app_id, status,
-                               model_->item_count());
+  return InsertAppLauncherItem(controller,
+                               app_id,
+                               status,
+                               model_->item_count(),
+                               controller->GetLauncherItemType());
 }
 
 void ChromeLauncherControllerPerApp::SetItemStatus(
     ash::LauncherID id,
     ash::LauncherItemStatus status) {
   int index = model_->ItemIndexByID(id);
   // Since ordinary browser windows are not registered, we might get a negative
   // index here.
   if (index >= 0) {
     ash::LauncherItem item = model_->items()[index];
@@ skipping 32 matching lines @@
 }
 
 void ChromeLauncherControllerPerApp::Pin(ash::LauncherID id) {
   DCHECK(HasItemController(id));
 
   int index = model_->ItemIndexByID(id);
   DCHECK_GE(index, 0);
 
   ash::LauncherItem item = model_->items()[index];
 
-  if (item.type != ash::TYPE_PLATFORM_APP)
+  if (item.type == ash::TYPE_PLATFORM_APP ||
+      item.type == ash::TYPE_WINDOWED_APP) {
+    item.type = ash::TYPE_APP_SHORTCUT;
+    model_->Set(index, item);
+  } else if (item.type != ash::TYPE_APP_SHORTCUT) {
     return;
-
-  item.type = ash::TYPE_APP_SHORTCUT;
-  model_->Set(index, item);
+  }
 
   if (CanPin())
     PersistPinnedState();
 }
 
 void ChromeLauncherControllerPerApp::Unpin(ash::LauncherID id) {
   DCHECK(HasItemController(id));
 
   LauncherItemController* controller = id_to_item_controller_map_[id];
   if (controller->type() == LauncherItemController::TYPE_APP) {
     int index = model_->ItemIndexByID(id);
     DCHECK_GE(index, 0);
     ash::LauncherItem item = model_->items()[index];
     item.type = ash::TYPE_PLATFORM_APP;
     model_->Set(index, item);
   } else {
-    LauncherItemClosed(id);
+    // Prevent the removal of items upon unpin if it is locked by a running
+    // windowed V1 app.
+    if (!controller->locked()) {
+      LauncherItemClosed(id);
+    } else {
+      int index = model_->ItemIndexByID(id);
+      DCHECK_GE(index, 0);
+      ash::LauncherItem item = model_->items()[index];
+      item.type = ash::TYPE_WINDOWED_APP;
+      model_->Set(index, item);
+    }
   }
   if (CanPin())
     PersistPinnedState();
 }
 
 bool ChromeLauncherControllerPerApp::IsPinned(ash::LauncherID id) {
   int index = model_->ItemIndexByID(id);
   if (index < 0)
     return false;
   ash::LauncherItemType type = model_->items()[index].type;
   return type == ash::TYPE_APP_SHORTCUT;
 }
 
 void ChromeLauncherControllerPerApp::TogglePinned(ash::LauncherID id) {
   if (!HasItemController(id))
     return;  // May happen if item closed with menu open.
 
   if (IsPinned(id))
     Unpin(id);
   else
     Pin(id);
 }
 
 bool ChromeLauncherControllerPerApp::IsPinnable(ash::LauncherID id) const {
   int index = model_->ItemIndexByID(id);
   if (index == -1)
     return false;
 
   ash::LauncherItemType type = model_->items()[index].type;
-  return ((type == ash::TYPE_APP_SHORTCUT || type == ash::TYPE_PLATFORM_APP) &&
+  return ((type == ash::TYPE_APP_SHORTCUT ||
+           type == ash::TYPE_PLATFORM_APP ||
+           type == ash::TYPE_WINDOWED_APP) &&
           CanPin());
 }
 
+void ChromeLauncherControllerPerApp::LockV1AppWithID(
+    const std::string& app_id) {
+  ash::LauncherID id = GetLauncherIDForAppID(app_id);
+  if (!IsPinned(id) && !IsWindowedAppInLauncher(app_id)) {
+    CreateAppShortcutLauncherItemWithType(app_id,
+                                          model_->item_count(),
+                                          ash::TYPE_WINDOWED_APP);
+    id = GetLauncherIDForAppID(app_id);
+  }
+  DCHECK(id);
+  id_to_item_controller_map_[id]->lock();
+}
+
+void ChromeLauncherControllerPerApp::UnlockV1AppWithID(
+    const std::string& app_id) {
+  ash::LauncherID id = GetLauncherIDForAppID(app_id);
+  DCHECK(IsPinned(id) || IsWindowedAppInLauncher(app_id));
+  DCHECK(id);
+  LauncherItemController* controller = id_to_item_controller_map_[id];
+  controller->unlock();
+  if (!controller->locked() && !IsPinned(id))
+    CloseLauncherItem(id);
+}
+
 void ChromeLauncherControllerPerApp::Launch(ash::LauncherID id,
                                             int event_flags) {
   if (!HasItemController(id))
     return;  // In case invoked from menu and item closed while menu up.
   id_to_item_controller_map_[id]->Launch(event_flags);
 }
 
 void ChromeLauncherControllerPerApp::Close(ash::LauncherID id) {
   if (!HasItemController(id))
     return;  // May happen if menu closed.
@@ skipping 143 matching lines @@
 bool ChromeLauncherControllerPerApp::IsAppPinned(const std::string& 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() == app_id)
       return true;
   }
   return false;
 }
 
+bool ChromeLauncherControllerPerApp::IsWindowedAppInLauncher(
+    const std::string& app_id) {
+  int index = model_->ItemIndexByID(GetLauncherIDForAppID(app_id));
+  if (index < 0)
+    return false;
+
+  ash::LauncherItemType type = model_->items()[index].type;
+  return type == ash::TYPE_WINDOWED_APP;
+}
+
 void ChromeLauncherControllerPerApp::PinAppWithID(const std::string& app_id) {
   if (CanPin())
     DoPinAppWithID(app_id);
   else
     NOTREACHED();
 }
 
 void ChromeLauncherControllerPerApp::SetLaunchType(
     ash::LauncherID id,
     extensions::ExtensionPrefs::LaunchType launch_type) {
@@ skipping 188 matching lines @@
   DCHECK(HasItemController(id));
   LauncherItemController* controller = id_to_item_controller_map_[id];
 
   int index = model_->ItemIndexByID(id);
   if (index == -1) {
     NOTREACHED() << "Invalid launcher id";
     return;
   }
 
   ash::LauncherItemType type = model_->items()[index].type;
-  if (type == ash::TYPE_APP_SHORTCUT) {
+  if (type == ash::TYPE_APP_SHORTCUT || type == ash::TYPE_WINDOWED_APP) {
     AppShortcutLauncherItemController* app_controller =
         static_cast<AppShortcutLauncherItemController*>(controller);
     app_controller->set_refocus_url(url);
   } else {
     NOTREACHED() << "Invalid launcher type";
   }
 }
 
 const Extension* ChromeLauncherControllerPerApp::GetExtensionForAppID(
     const std::string& app_id) {
@@ skipping 63 matching lines @@
   }
   // Coming here we are looking for the associated browser item as the default.
   int browser_index = ash::launcher::GetBrowserItemIndex(*model_);
   // Note that there should always be a browser item in the launcher.
   DCHECK_GE(browser_index, 0);
   return model_->items()[browser_index].id;
 }
 
 bool ChromeLauncherControllerPerApp::IsDraggable(
     const ash::LauncherItem& item) {
-  return item.type == ash::TYPE_APP_SHORTCUT ? CanPin() : true;
+  return (item.type == ash::TYPE_APP_SHORTCUT ||
+          item.type == ash::TYPE_WINDOWED_APP) ? CanPin() : true;
 }
 
 void ChromeLauncherControllerPerApp::LauncherItemAdded(int index) {
 }
 
 void ChromeLauncherControllerPerApp::LauncherItemRemoved(
     int index,
     ash::LauncherID id) {
 }
 
@@ skipping 182 matching lines @@
 void ChromeLauncherControllerPerApp::OnBrowserRemoved(Browser* browser) {
   // When called by a unit test it is possible that there is no shell.
   // In that case, the following function should not get called.
   if (ash::Shell::HasInstance())
     UpdateBrowserItemStatus();
 }
 
 ash::LauncherID ChromeLauncherControllerPerApp::CreateAppShortcutLauncherItem(
     const std::string& app_id,
     int index) {
-  AppShortcutLauncherItemController* controller =
-      new AppShortcutLauncherItemController(app_id, this);
-  ash::LauncherID launcher_id = InsertAppLauncherItem(
-      controller, app_id, ash::STATUS_CLOSED, index);
-  return launcher_id;
+  return CreateAppShortcutLauncherItemWithType(app_id,
+                                               index,
+                                               ash::TYPE_APP_SHORTCUT);
 }
 
 void ChromeLauncherControllerPerApp::SetAppTabHelperForTest(
     AppTabHelper* helper) {
   app_tab_helper_.reset(helper);
 }
 
 void ChromeLauncherControllerPerApp::SetAppIconLoaderForTest(
     ash::AppIconLoader* loader) {
   app_icon_loader_.reset(loader);
 }
 
 const std::string&
 ChromeLauncherControllerPerApp::GetAppIdFromLauncherIdForTest(
     ash::LauncherID id) {
   return id_to_item_controller_map_[id]->app_id();
 }
 
+ash::LauncherID
+ChromeLauncherControllerPerApp::CreateAppShortcutLauncherItemWithType(
+    const std::string& app_id,
+    int index,
+    ash::LauncherItemType launcher_item_type) {
+  AppShortcutLauncherItemController* controller =
+      new AppShortcutLauncherItemController(app_id, this);
+  ash::LauncherID launcher_id = InsertAppLauncherItem(
+      controller, app_id, ash::STATUS_CLOSED, index, launcher_item_type);
+  return launcher_id;
+}
+
 void ChromeLauncherControllerPerApp::UpdateBrowserItemStatus() {
   // Determine the new browser's active state and change if necessary.
   int browser_index = ash::launcher::GetBrowserItemIndex(*model_);
   DCHECK(browser_index >= 0);
   ash::LauncherItem browser_item = model_->items()[browser_index];
   ash::LauncherItemStatus browser_status = browser_item.status;
   // See if the active window is a browser.
   aura::Window* window = ash::wm::GetActiveWindow();
   if (window && chrome::FindBrowserWithWindow(window)) {
     browser_status = ash::STATUS_ACTIVE;
@@ skipping 207 matching lines @@
   if (i == app_id_to_web_contents_list_.end())
     return NULL;
   DCHECK_GT(i->second.size(), 0u);
   return *i->second.begin();
 }
 
 ash::LauncherID ChromeLauncherControllerPerApp::InsertAppLauncherItem(
     LauncherItemController* controller,
     const std::string& app_id,
     ash::LauncherItemStatus status,
-    int index) {
+    int index,
+    ash::LauncherItemType launcher_item_type) {
   ash::LauncherID id = model_->next_id();
   DCHECK(!HasItemController(id));
   DCHECK(controller);
   id_to_item_controller_map_[id] = controller;
   controller->set_launcher_id(id);
 
   ash::LauncherItem item;
-  item.type = controller->GetLauncherItemType();
+  item.type = launcher_item_type;
   item.is_incognito = false;
   item.image = Extension::GetDefaultIcon(true);
 
   WebContents* active_tab = GetLastActiveWebContents(app_id);
   if (active_tab) {
     Browser* browser = chrome::FindBrowserWithWebContents(active_tab);
     DCHECK(browser);
     if (browser->window()->IsActive())
       status = ash::STATUS_ACTIVE;
     else
@@ skipping 34 matching lines @@
           l10n_util::GetStringUTF16(IDS_PRODUCT_NAME)), NULL));
   const chrome::BrowserListImpl* ash_browser_list =
       chrome::BrowserListImpl::GetInstance(chrome::HOST_DESKTOP_TYPE_ASH);
   int index = 1;
   for (chrome::BrowserListImpl::const_reverse_iterator it =
            ash_browser_list->begin_last_active();
        it != ash_browser_list->end_last_active(); ++it, ++index) {
     Browser* browser = *it;
     if (browser->is_type_tabbed())
       found_tabbed_browser = true;
+    else if (browser->is_app() &&
+             browser->is_type_popup() &&
+             GetLauncherIDForAppID(web_app::GetExtensionIdFromApplicationName(
+                                       browser->app_name())) > 0)
+      continue;
     TabStripModel* tab_strip = browser->tab_strip_model();
     WebContents* web_contents =
         tab_strip->GetWebContentsAt(tab_strip->active_index());
     gfx::Image app_icon = GetAppListIcon(web_contents);
     items.push_back(new ChromeLauncherAppMenuItemBrowser(
         web_contents->GetTitle(),
         app_icon.IsEmpty() ? NULL : &app_icon,
         browser));
   }
   // If only windowed applications are open, we return an empty list to
   // enforce the creation of a new browser.
   if (!found_tabbed_browser)
     items.clear();
   return items.Pass();
 }