Add support for managing active state of platform apps

chrome/browser/ui/views/ash/launcher/chrome_launcher_controller.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/views/ash/launcher/chrome_launcher_controller.h"
 
 #include <set>
 #include <vector>
 
 #include "ash/launcher/launcher_model.h"
@@ skipping 46 matching lines @@
 }
 
 // ChromeLauncherController ----------------------------------------------------
 
 // static
 ChromeLauncherController* ChromeLauncherController::instance_ = NULL;
 
 ChromeLauncherController::ChromeLauncherController(Profile* profile,
                                                    ash::LauncherModel* model)
     : model_(model),
-      profile_(profile) {
+      profile_(profile),
+      activation_client_(NULL) {
   if (!profile_) {
     // Use the original profile as on chromeos we may get a temporary off the
     // record profile.
     profile_ = ProfileManager::GetDefaultProfile()->GetOriginalProfile();
   }
   instance_ = this;
   model_->AddObserver(this);
   ShellWindowRegistry::Get(profile_)->AddObserver(this);
   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,
                               content::Source<Profile>(profile_));
   pref_change_registrar_.Init(profile_->GetPrefs());
   pref_change_registrar_.Add(prefs::kPinnedLauncherApps, this);
 }
 
 ChromeLauncherController::~ChromeLauncherController() {
   ShellWindowRegistry::Get(profile_)->RemoveObserver(this);
   model_->RemoveObserver(this);
   for (IDToItemMap::iterator i = id_to_item_map_.begin();
        i != id_to_item_map_.end(); ++i) {
     model_->RemoveItemAt(model_->ItemIndexByID(i->first));
   }
   if (instance_ == this)
     instance_ = NULL;
+  if (activation_client_)
+    activation_client_->RemoveObserver(this);
+
+  for (WindowToIDMap::iterator i = window_to_id_map_.begin();
+       i != window_to_id_map_.end(); ++i) {
+    i->first->RemoveObserver(this);
+  }
 }
 
 void ChromeLauncherController::Init() {
   // TODO(xiyuan): Remove migration code and kUseDefaultPinnedApp after M20.
   // Migration cases:
   // - Users that unpin all apps:
   //   - have default pinned apps
   //   - kUseDefaultPinnedApps set to false
   //   Migrate them by setting an empty list for kPinnedLauncherApps.
   //
@@ skipping 19 matching lines @@
   if (ash::Shell::HasInstance()) {
     std::string behavior_value(
         profile_->GetPrefs()->GetString(prefs::kShelfAutoHideBehavior));
     ash::ShelfAutoHideBehavior behavior =
         ash::SHELF_AUTO_HIDE_BEHAVIOR_DEFAULT;
     if (behavior_value == ash::kShelfAutoHideBehaviorNever)
       behavior = ash::SHELF_AUTO_HIDE_BEHAVIOR_NEVER;
     else if (behavior_value == ash::kShelfAutoHideBehaviorAlways)
       behavior = ash::SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS;
     ash::Shell::GetInstance()->SetShelfAutoHideBehavior(behavior);
+    activation_client_ =
+        aura::client::GetActivationClient(
+            ash::Shell::GetInstance()->GetPrimaryRootWindow());
+    activation_client_->AddObserver(this);
   }
 }
 
 ash::LauncherID ChromeLauncherController::CreateTabbedLauncherItem(
     BrowserLauncherItemController* controller,
     IncognitoState is_incognito,
     ash::LauncherItemStatus status) {
   ash::LauncherID id = model_->next_id();
   DCHECK(id_to_item_map_.find(id) == id_to_item_map_.end());
   id_to_item_map_[id].item_type = TYPE_TABBED_BROWSER;
@@ skipping 345 matching lines @@
         NOTREACHED() << "Unexpected pref change for " << pref_name;
       }
       break;
     }
     default:
       NOTREACHED() << "Unexpected notification type=" << type;
   }
 }
 
 void ChromeLauncherController::OnShellWindowAdded(ShellWindow* shell_window) {
+  aura::Window* window = shell_window->GetNativeWindow();
+  ash::LauncherItemStatus status =
+      ash::wm::IsActiveWindow(window) ?
+          ash::STATUS_ACTIVE : ash::STATUS_RUNNING;
+  window->AddObserver(this);
   const std::string app_id = shell_window->extension()->id();
   for (IDToItemMap::const_iterator i = id_to_item_map_.begin();
        i != id_to_item_map_.end(); ++i) {
     if (i->second.app_id == app_id) {
-      SetItemStatus(i->first, ash::STATUS_RUNNING);
+      window_to_id_map_[window] = i->first;
+      SetItemStatus(i->first, status);
       return;
     }
   }
-  CreateAppLauncherItem(NULL, app_id, ash::STATUS_RUNNING);
+  ash::LauncherID id = CreateAppLauncherItem(NULL, app_id, status);
+  window_to_id_map_[window] = id;
 }
 
 void ChromeLauncherController::OnShellWindowRemoved(ShellWindow* shell_window) {
-  const std::string app_id = shell_window->extension()->id();
-  ShellWindowRegistry* registry = ShellWindowRegistry::Get(profile_);
-  if (registry->GetShellWindowsForApp(app_id).size() > 0)
-    return;
+  // Window removal is handled in OnWindowRemovingFromRootWindow() below.
+}
 
-  for (IDToItemMap::const_iterator i = id_to_item_map_.begin();
-       i != id_to_item_map_.end(); ++i) {
-    if (i->second.app_id == app_id) {
-      int index = model_->ItemIndexByID(i->first);
-      DCHECK_GE(index, 0);
-      ash::LauncherItem item = model_->items()[index];
-      if (item.type == ash::TYPE_APP_SHORTCUT)
-        SetItemStatus(i->first, ash::STATUS_CLOSED);
-      else
-        LauncherItemClosed(i->first);
+void ChromeLauncherController::OnWindowActivated(aura::Window* active,
+                                                 aura::Window* old_active) {
+  if (window_to_id_map_.find(old_active) != window_to_id_map_.end()) {
+    if (window_to_id_map_.find(active) != window_to_id_map_.end() &&
+        window_to_id_map_[old_active] == window_to_id_map_[active]) {
+      // Old and new windows are for the same item. Don't change the status.
       return;
     }
+    SetItemStatus(window_to_id_map_[old_active], ash::STATUS_RUNNING);
   }
+  if (window_to_id_map_.find(active) != window_to_id_map_.end())
+    SetItemStatus(window_to_id_map_[active], ash::STATUS_ACTIVE);
+}
+
+void ChromeLauncherController::OnWindowRemovingFromRootWindow(
+    aura::Window* window) {
+  window->RemoveObserver(this);
+  DCHECK(window_to_id_map_.find(window) != window_to_id_map_.end());
+  ash::LauncherID id = window_to_id_map_[window];
+  window_to_id_map_.erase(window);
+
+  DCHECK(id_to_item_map_.find(id) != id_to_item_map_.end());
+  ShellWindowRegistry::ShellWindowSet remaining_windows =
+      ShellWindowRegistry::Get(profile_)->GetShellWindowsForApp(
+      id_to_item_map_[id].app_id);
+
+  // We can't count on getting called before or after the ShellWindowRegistry.
+  if (remaining_windows.size() > 1 ||
+      (remaining_windows.size() == 1 &&
+          (*remaining_windows.begin())->GetNativeWindow() != window)) {
+    return;
+  }
+
+  // Close or remove item.
+  int index = model_->ItemIndexByID(id);
+  DCHECK_GE(index, 0);
+  ash::LauncherItem item = model_->items()[index];
+  if (item.type == ash::TYPE_APP_SHORTCUT)
+    SetItemStatus(id, ash::STATUS_CLOSED);
+  else
+    LauncherItemClosed(id);
 }
 
 void ChromeLauncherController::PersistPinnedState() {
   // It is a coding error to call PersistPinnedState() if the pinned apps are
   // not user-editable. The code should check earlier and not perform any
   // modification actions that trigger persisting the state.
   if (!CanPin()) {
     NOTREACHED() << "Can't pin but pinned state being updated";
     return;
   }
@@ skipping 184 matching lines @@
   }
   model_->AddAt(index, item);
 
   if (!controller || controller->type() !=
       BrowserLauncherItemController::TYPE_EXTENSION_PANEL) {
     if (item.status != ash::STATUS_IS_PENDING)
       app_icon_loader_->FetchImage(app_id);
   }
   return id;
 }