Fixing activation states from the new launcher. Also adding a whole bunch of unit tests for the new…

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 147 matching lines @@
     // Use the original profile as on chromeos we may get a temporary off the
     // record profile.
     profile_ = ProfileManager::GetDefaultProfile()->GetOriginalProfile();
 
     app_sync_ui_state_ = AppSyncUIState::Get(profile_);
     if (app_sync_ui_state_)
       app_sync_ui_state_->AddObserver(this);
   }
 
   model_->AddObserver(this);
+  BrowserList::AddObserver(this);
   // TODO(stevenjb): Find a better owner for shell_window_controller_?
   shell_window_controller_.reset(new ShellWindowLauncherController(this));
   app_tab_helper_.reset(new LauncherAppTabHelper(profile_));
   app_icon_loader_.reset(new LauncherAppIconLoader(profile_, this));
 
   notification_registrar_.Add(this,
                               chrome::NOTIFICATION_EXTENSION_LOADED,
                               content::Source<Profile>(profile_));
   notification_registrar_.Add(this,
                               chrome::NOTIFICATION_EXTENSION_UNLOADED,
@@ skipping 12 matching lines @@
       base::Bind(&ChromeLauncherControllerPerApp::
                      SetShelfAutoHideBehaviorFromPrefs,
                  base::Unretained(this)));
 }
 
 ChromeLauncherControllerPerApp::~ChromeLauncherControllerPerApp() {
   // Reset the shell window controller here since it has a weak pointer to this.
   shell_window_controller_.reset();
 
   model_->RemoveObserver(this);
+  BrowserList::RemoveObserver(this);
   for (IDToItemControllerMap::iterator i = id_to_item_controller_map_.begin();
        i != id_to_item_controller_map_.end(); ++i) {
     i->second->OnRemoved();
     // TODO(skuhne): After getting rid of the old launcher, get also rid of the
     // BrowserLauncherItemController (since it is only used for activation
     // tracking at that point.
     int index = model_->ItemIndexByID(i->first);
     // 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)
@@ skipping 68 matching lines @@
   // Since ordinary browser windows are not registered, we might get a negative
   // index here.
   if (index >= 0) {
     ash::LauncherItem item = model_->items()[index];
     item.status = status;
     model_->Set(index, item);
 
     if (model_->items()[index].type == ash::TYPE_BROWSER_SHORTCUT)
       return;
   }
-  // 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.
-  if (chrome::FindBrowserWithWindow(ash::wm::GetActiveWindow())) {
-    browser_status = ash::STATUS_ACTIVE;
-  } else if (!BrowserList::empty()) {
-    browser_status = ash::STATUS_RUNNING;
-  } else {
-    browser_status = ash::STATUS_CLOSED;
-  }
-  if (browser_status != browser_item.status) {
-    browser_item.status = browser_status;
-    model_->Set(browser_index, browser_item);
-  }
+  UpdateBrowserItemStatus();
 }
 
 void ChromeLauncherControllerPerApp::SetItemController(
     ash::LauncherID id,
     LauncherItemController* controller) {
   IDToItemControllerMap::iterator iter = id_to_item_controller_map_.find(id);
   DCHECK(iter != id_to_item_controller_map_.end());
   iter->second->OnRemoved();
   iter->second = controller;
   controller->set_launcher_id(id);
@@ skipping 11 matching lines @@
     iter->second->set_launcher_id(id);
   } else {
     LauncherItemClosed(id);
   }
 }
 
 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)
     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);
   }
   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);
@@ skipping 74 matching lines @@
   }
 
   // If there is an existing non-shortcut controller for this app, open it.
   ash::LauncherID id = GetLauncherIDForAppID(app_id);
   if (id) {
     LauncherItemController* controller = id_to_item_controller_map_[id];
     controller->Activate();
     return;
   }
 
-  // Otherwise launch the app.
-  LaunchApp(app_id, event_flags);
+  // Create a temporary application launcher item and use it to see if there are
+  // running instances.
+  scoped_ptr<AppShortcutLauncherItemController> app_controller(
+      new AppShortcutLauncherItemController(app_id, this));
+  if (!app_controller->GetRunningApplications().empty())
+    app_controller->Activate();
+  else
+    LaunchApp(app_id, event_flags);
 }
 
 extensions::ExtensionPrefs::LaunchType
     ChromeLauncherControllerPerApp::GetLaunchType(ash::LauncherID id) {
   DCHECK(HasItemController(id));
 
   const Extension* extension = GetExtensionForAppID(
       id_to_item_controller_map_[id]->app_id());
   return profile_->GetExtensionService()->extension_prefs()->GetLaunchType(
       extension,
@@ skipping 34 matching lines @@
       continue;
 
     // Panel items may share the same app_id as the app that created them,
     // but they set their icon image in
     // BrowserLauncherItemController::UpdateLauncher(), so do not set panel
     // images here.
     if (i->second->type() == LauncherItemController::TYPE_EXTENSION_PANEL)
       continue;
 
     int index = model_->ItemIndexByID(i->first);
+    if (index == -1)
+      continue;
     ash::LauncherItem item = model_->items()[index];
     item.image = image;
     model_->Set(index, item);
     // It's possible we're waiting on more than one item, so don't break.
   }
 }
 
 void ChromeLauncherControllerPerApp::SetLauncherItemImage(
     ash::LauncherID launcher_id,
     const gfx::ImageSkia& image) {
@@ skipping 161 matching lines @@
   std::string app_id = GetAppID(contents);
 
   // 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)
       RemoveTabFromRunningApp(contents, last_app_id);
   }
 
-  if (app_id.empty())
+  if (app_id.empty()) {
+    // Even if there is no application running, we should update the activation
+    // state of the associated browser.
+    UpdateBrowserItemStatus();
     return;
+  }
 
   web_contents_to_app_id_[contents] = app_id;
 
   if (app_state == APP_STATE_REMOVED) {
     // The tab has gone away.
     RemoveTabFromRunningApp(contents, app_id);
   } else {
     WebContentsList& tab_list(app_id_to_web_contents_list_[app_id]);
 
     if (app_state == APP_STATE_INACTIVE) {
@@ skipping 301 matching lines @@
       Profile::FromBrowserContext(web_contents->GetBrowserContext());
   if (profile->IsOffTheRecord() && !profile->IsGuestSession()) {
     ResourceBundle& rb = ResourceBundle::GetSharedInstance();
     return rb.GetImageNamed(IDR_AURA_LAUNCHER_INCOGNITO_BROWSER);
   }
   FaviconTabHelper* favicon_tab_helper =
       FaviconTabHelper::FromWebContents(web_contents);
   return favicon_tab_helper->GetFavicon();
 }
 
+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;
 }
 
 void ChromeLauncherControllerPerApp::SetAppTabHelperForTest(
     AppTabHelper* helper) {
   app_tab_helper_.reset(helper);
 }
 
 void ChromeLauncherControllerPerApp::SetAppIconLoaderForTest(
     AppIconLoader* loader) {
   app_icon_loader_.reset(loader);
 }
 
 const std::string&
 ChromeLauncherControllerPerApp::GetAppIdFromLauncherIdForTest(
     ash::LauncherID id) {
   return id_to_item_controller_map_[id]->app_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;
+  } else if (!BrowserList::empty()) {
+    browser_status = ash::STATUS_RUNNING;
+  } else {
+    browser_status = ash::STATUS_CLOSED;
+  }
+  if (browser_status != browser_item.status) {
+    browser_item.status = browser_status;
+    model_->Set(browser_index, browser_item);
+  }
+}
+
 Profile* ChromeLauncherControllerPerApp::GetProfileForNewWindows() {
   return ProfileManager::GetDefaultProfileOrOffTheRecord();
 }
 
 void ChromeLauncherControllerPerApp::LauncherItemClosed(ash::LauncherID id) {
   IDToItemControllerMap::iterator iter = id_to_item_controller_map_.find(id);
   DCHECK(iter != id_to_item_controller_map_.end());
   app_icon_loader_->ClearImage(iter->second->app_id());
   iter->second->OnRemoved();
   id_to_item_controller_map_.erase(iter);
@@ skipping 244 matching lines @@
     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));
   }
   return items;
 }