athena: Expose the list of activities from the ActivityManager.

Notable implementation details of the change:
. Have ActivityManagerImpl observer each aura::Window of the activities, and
  update order of the activities when their windows are restacked.
. Introduce ActivityManagerObserver::OnActivityOrderChanged().
. Remove the code from ResourceManagerImpl that tracks the activity order, and
  replace it to get the list from ActivityManager instead.
  - Make sure the code traverses the activities in the correct order.

BUG=413928
R=oshima@chromium.org, skuhne@chromium.org

Review URL: https://codereview.chromium.org/694353004

Cr-Commit-Position: refs/heads/master@{#302574}

athena/activity/DEPS

@@ -6,4 +6,5 @@ include_rules = [
   "+ui/base",
   "+ui/gfx",
   "+ui/views",
+  "+ui/wm",
 ]

athena/activity/activity_manager_impl.cc

@@ -10,9 +10,12 @@
 #include "athena/activity/public/activity.h"
 #include "athena/activity/public/activity_manager_observer.h"
 #include "athena/activity/public/activity_view_model.h"
+#include "athena/screen/public/screen_manager.h"
 #include "base/logging.h"
 #include "base/observer_list.h"
+#include "ui/aura/window.h"
 #include "ui/views/widget/widget.h"
+#include "ui/wm/public/activation_client.h"
 
 namespace athena {
 
@@ -46,9 +49,16 @@ views::Widget* GetWidget(Activity* activity) {
 ActivityManagerImpl::ActivityManagerImpl() {
   CHECK(!instance);
   instance = this;
+
+  aura::Window* root_window =
+      ScreenManager::Get()->GetContext()->GetRootWindow();
+  aura::client::GetActivationClient(root_window)->AddObserver(this);
 }
 
 ActivityManagerImpl::~ActivityManagerImpl() {
+  aura::Window* root_window =
+      ScreenManager::Get()->GetContext()->GetRootWindow();
+  aura::client::GetActivationClient(root_window)->RemoveObserver(this);
   while (!activities_.empty())
     Activity::Delete(activities_.front());
 
@@ -59,9 +69,9 @@ ActivityManagerImpl::~ActivityManagerImpl() {
 void ActivityManagerImpl::AddActivity(Activity* activity) {
   CHECK(activities_.end() ==
         std::find(activities_.begin(), activities_.end(), activity));
-  activities_.push_back(activity);
+  activities_.insert(activities_.begin(), activity);
   views::Widget* widget = CreateWidget(activity);
-  widget->AddObserver(this);
+  widget->GetNativeView()->AddObserver(this);
   FOR_EACH_OBSERVER(ActivityManagerObserver,
                     observers_,
                     OnActivityStarted(activity));
@@ -76,7 +86,7 @@ void ActivityManagerImpl::RemoveActivity(Activity* activity) {
         ActivityManagerObserver, observers_, OnActivityEnding(activity));
     activities_.erase(find);
     views::Widget* widget = GetWidget(activity);
-    widget->RemoveObserver(this);
+    widget->GetNativeView()->RemoveObserver(this);
     widget->Close();
   }
 }
@@ -87,6 +97,10 @@ void ActivityManagerImpl::UpdateActivity(Activity* activity) {
   widget->UpdateWindowTitle();
 }
 
+const ActivityList& ActivityManagerImpl::GetActivityList() {
+  return activities_;
+}
+
 Activity* ActivityManagerImpl::GetActivityForWindow(aura::Window* window) {
   struct Matcher {
     Matcher(aura::Window* w) : window(w) {}
@@ -108,14 +122,33 @@ void ActivityManagerImpl::RemoveObserver(ActivityManagerObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
-void ActivityManagerImpl::OnWidgetDestroying(views::Widget* widget) {
-  Activity* activity = GetActivityForWindow(widget->GetNativeWindow());
+void ActivityManagerImpl::OnWindowDestroying(aura::Window* window) {
+  Activity* activity = GetActivityForWindow(window);
   if (activity) {
-    widget->RemoveObserver(this);
+    window->RemoveObserver(this);
     Activity::Delete(activity);
   }
 }
 
+void ActivityManagerImpl::OnWindowActivated(aura::Window* gained_active,
+                                            aura::Window* lost_active) {
+  Activity* activity = GetActivityForWindow(gained_active);
+  if (!activity)
+    return;
+  CHECK(!activities_.empty());
+  if (activity == activities_.front())
+    return;
+  // Move the activity for |gained_active| at the front of the list.
+  ActivityList::reverse_iterator iter = std::find(activities_.rbegin(),
+                                                  activities_.rend(),
+                                                  activity);
+  CHECK(iter != activities_.rend());
+  std::rotate(iter, iter + 1, activities_.rend());
+  FOR_EACH_OBSERVER(ActivityManagerObserver,
+                    observers_,
+                    OnActivityOrderChanged());
+}
+
 // static
 ActivityManager* ActivityManager::Create() {
   new ActivityManagerImpl();

athena/activity/activity_manager_impl.h

@@ -8,14 +8,16 @@
 
 #include "base/macros.h"
 #include "base/observer_list.h"
-#include "ui/views/widget/widget_observer.h"
+#include "ui/aura/window_observer.h"
+#include "ui/wm/public/activation_change_observer.h"
 
 namespace athena {
 
 class ActivityManagerObserver;
 
 class ActivityManagerImpl : public ActivityManager,
-                            public views::WidgetObserver {
+                            public aura::WindowObserver,
+                            public aura::client::ActivationChangeObserver {
  public:
   ActivityManagerImpl();
   ~ActivityManagerImpl() override;
@@ -26,14 +28,19 @@ class ActivityManagerImpl : public ActivityManager,
   void AddActivity(Activity* activity) override;
   void RemoveActivity(Activity* activity) override;
   void UpdateActivity(Activity* activity) override;
+  const ActivityList& GetActivityList() override;
   Activity* GetActivityForWindow(aura::Window* window) override;
   void AddObserver(ActivityManagerObserver* observer) override;
   void RemoveObserver(ActivityManagerObserver* observer) override;
 
-  // views::WidgetObserver
-  void OnWidgetDestroying(views::Widget* widget) override;
-
  private:
+  // aura::WindowObserver:
+  void OnWindowDestroying(aura::Window* window) override;
+
+  // aura::client::ActivationChangeObserver:
+  void OnWindowActivated(aura::Window* gained_active,
+                         aura::Window* lost_active) override;
+
   std::vector<Activity*> activities_;
 
   ObserverList<ActivityManagerObserver> observers_;

athena/activity/activity_manager_unittest.cc

@@ -9,6 +9,7 @@
 #include "athena/test/base/athena_test_base.h"
 #include "athena/test/base/test_windows.h"
 #include "ui/aura/window.h"
+#include "ui/wm/core/window_util.h"
 
 namespace athena {
 
@@ -58,4 +59,25 @@ TEST_F(ActivityManagerTest, GetActivityForWindow) {
   EXPECT_EQ(nullptr, manager->GetActivityForWindow(window.get()));
 }
 
+TEST_F(ActivityManagerTest, ActivationBringsActivityToTop) {
+  ActivityManager* manager = ActivityManager::Get();
+  ActivityFactory* factory = ActivityFactory::Get();
+
+  Activity* activity1 =
+      factory->CreateWebActivity(nullptr, base::string16(), GURL());
+  Activity* activity2 =
+      factory->CreateWebActivity(nullptr, base::string16(), GURL());
+  activity1->GetWindow()->Show();
+  activity2->GetWindow()->Show();
+
+  ASSERT_EQ(2u, manager->GetActivityList().size());
+  EXPECT_EQ(activity2, manager->GetActivityList()[0]);
+  EXPECT_EQ(activity1, manager->GetActivityList()[1]);
+
+  wm::ActivateWindow(activity1->GetWindow());
+  ASSERT_EQ(2u, manager->GetActivityList().size());
+  EXPECT_EQ(activity1, manager->GetActivityList()[0]);
+  EXPECT_EQ(activity2, manager->GetActivityList()[1]);
+}
+
 }  // namespace athena

athena/activity/public/activity_manager.h

@@ -5,6 +5,8 @@
 #ifndef ATHENA_ACTIVITY_PUBLIC_ACTIVITY_MANAGER_H_
 #define ATHENA_ACTIVITY_PUBLIC_ACTIVITY_MANAGER_H_
 
+#include <vector>
+
 #include "athena/athena_export.h"
 
 namespace aura {
@@ -16,6 +18,8 @@ namespace athena {
 class Activity;
 class ActivityManagerObserver;
 
+using ActivityList = std::vector<Activity*>;
+
 // Manages a set of activities.
 class ATHENA_EXPORT ActivityManager {
  public:
@@ -29,13 +33,17 @@ class ATHENA_EXPORT ActivityManager {
   virtual void AddActivity(Activity* activity) = 0;
   virtual void RemoveActivity(Activity* activity) = 0;
 
+  // Updates the UI when the task color/title changes.
+  virtual void UpdateActivity(Activity* activity) = 0;
+
+  // Returns a list of activities, sorted in their activation order (the most
+  // recently used activity is at the front of the returned list).
+  virtual const ActivityList& GetActivityList() = 0;
+
   // Returns the activity that has a |window| as toplevel window, or
   // nullptr if such activity does not exist.
   virtual Activity* GetActivityForWindow(aura::Window* window) = 0;
 
-  // Updates the UI when the task color/title changes.
-  virtual void UpdateActivity(Activity* activity) = 0;
-
   virtual void AddObserver(ActivityManagerObserver* observer) = 0;
   virtual void RemoveObserver(ActivityManagerObserver* observer) = 0;
 };

athena/activity/public/activity_manager_observer.h

@@ -20,6 +20,9 @@ class ATHENA_EXPORT ActivityManagerObserver {
 
   // Called before an |activity| gets destroyed.
   virtual void OnActivityEnding(Activity* activity) = 0;
+
+  // Called when the order of the activities in the list has changed.
+  virtual void OnActivityOrderChanged() = 0;
 };
 
 }  // namespace athena

athena/resource_manager/resource_manager_impl.cc

@@ -16,6 +16,7 @@
 #include "athena/wm/public/window_list_provider_observer.h"
 #include "athena/wm/public/window_manager.h"
 #include "athena/wm/public/window_manager_observer.h"
+#include "base/containers/adapters.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/time/time.h"
@@ -51,16 +52,15 @@ class ResourceManagerImpl : public ResourceManager,
     } else {
       DCHECK(pause_);
       --pause_;
-      if (!pause && queued_command_) {
-        UpdateActivityOrder();
+      if (!pause && queued_command_)
         ManageResource();
     }
   }
-  }
 
   // ActivityManagerObserver:
   virtual void OnActivityStarted(Activity* activity) override;
   virtual void OnActivityEnding(Activity* activity) override;
+  virtual void OnActivityOrderChanged() override;
 
   // WindowManagerObserver:
   virtual void OnOverviewModeEnter() override;
@@ -88,11 +88,6 @@ class ResourceManagerImpl : public ResourceManager,
   // Check if activities can be unloaded to reduce memory pressure.
   void TryToUnloadAnActivity();
 
-  // Order our activity list to the order of activities of the stream.
-  // TODO(skuhne): Once the ActivityManager is responsible to create this list
-  // for us, we can remove this code here.
-  void UpdateActivityOrder();
-
   // Resources were released and a quiet period is needed before we release
   // more since it takes a while to trickle through the system.
   void OnResourcesReleased();
@@ -105,11 +100,6 @@ class ResourceManagerImpl : public ResourceManager,
   // unloading another activity.
   bool AllowedToUnloadActivity();
 
-  // The sorted (new(front) -> old(back)) activity list.
-  // TODO(skuhne): Once the ActivityManager is responsible to create this list
-  // for us, we can remove this code here.
-  std::vector<Activity*> activity_list_;
-
   // The resource manager delegate.
   scoped_ptr<ResourceManagerDelegate> delegate_;
 
@@ -177,9 +167,6 @@ ResourceManagerImpl::~ResourceManagerImpl() {
   ActivityManager::Get()->RemoveObserver(this);
   WindowManager::Get()->GetWindowListProvider()->RemoveObserver(this);
   WindowManager::Get()->RemoveObserver(this);
-
-  while (!activity_list_.empty())
-    OnActivityEnding(activity_list_.front());
 }
 
 void ResourceManagerImpl::SetMemoryPressureAndStopMonitoring(
@@ -189,24 +176,16 @@ void ResourceManagerImpl::SetMemoryPressureAndStopMonitoring(
 }
 
 void ResourceManagerImpl::OnActivityStarted(Activity* activity) {
-  // As long as we have to manage the list of activities ourselves, we need to
-  // order it here.
-  activity_list_.push_back(activity);
-  UpdateActivityOrder();
   // Update the activity states.
   ManageResource();
-  // Remember that the activity order has changed.
   activity_order_changed_ = true;
 }
 
 void ResourceManagerImpl::OnActivityEnding(Activity* activity) {
-  DCHECK(activity->GetWindow());
-  // Remove the activity from the list again.
-  std::vector<Activity*>::iterator it =
-      std::find(activity_list_.begin(), activity_list_.end(), activity);
-  DCHECK(it != activity_list_.end());
-  activity_list_.erase(it);
-  // Remember that the activity order has changed.
+  activity_order_changed_ = true;
+}
+
+void ResourceManagerImpl::OnActivityOrderChanged() {
   activity_order_changed_ = true;
 }
 
@@ -216,9 +195,6 @@ void ResourceManagerImpl::OnOverviewModeEnter() {
 
 void ResourceManagerImpl::OnOverviewModeExit() {
   in_overview_mode_ = false;
-  // Reorder the activities and manage the resources again since an order change
-  // might have caused a visibility change.
-  UpdateActivityOrder();
   ManageResource();
 }
 
@@ -236,7 +212,6 @@ void ResourceManagerImpl::OnSplitViewModeExit() {
 }
 
 void ResourceManagerImpl::OnWindowStackingChangedInList() {
-  activity_order_changed_ = true;
   if (pause_) {
     queued_command_ = true;
     return;
@@ -246,10 +221,6 @@ void ResourceManagerImpl::OnWindowStackingChangedInList() {
   if (in_overview_mode_)
     return;
 
-  // As long as we have to manage the list of activities ourselves, we need to
-  // order it here.
-  UpdateActivityOrder();
-
   // Manage the resources of each activity.
   ManageResource();
 }
@@ -267,7 +238,7 @@ ResourceManagerDelegate* ResourceManagerImpl::GetDelegate() {
 
 void ResourceManagerImpl::ManageResource() {
   // If there is none or only one app running we cannot do anything.
-  if (activity_list_.size() <= 1U)
+  if (ActivityManager::Get()->GetActivityList().size() <= 1U)
     return;
 
   if (pause_) {
@@ -296,23 +267,22 @@ void ResourceManagerImpl::UpdateVisibilityStates() {
   if (current_memory_pressure_ == MEMORY_PRESSURE_CRITICAL)
     max_activities = in_split_view_mode_ ? 2 : 1;
 
-  // Restart and / or bail if the order of activities changes due to our calls.
+  do {
     activity_order_changed_ = false;
 
     // Change the visibility of our activities in a pre-processing step. This is
     // required since it might change the order/number of activities.
-  size_t index = 0;
-  while (index < activity_list_.size()) {
-    Activity* activity = activity_list_[index];
+    size_t count = 0;
+    for (Activity* activity : ActivityManager::Get()->GetActivityList()) {
       Activity::ActivityState state = activity->GetCurrentState();
 
       // The first |kMaxVisibleActivities| entries should be visible, all others
       // invisible or at a lower activity state.
-    if (index < max_activities ||
+      if (count < max_activities ||
           (state == Activity::ACTIVITY_INVISIBLE ||
            state == Activity::ACTIVITY_VISIBLE)) {
         Activity::ActivityState visiblity_state =
-          index < max_activities ? Activity::ACTIVITY_VISIBLE :
+            count < max_activities ? Activity::ACTIVITY_VISIBLE :
                                      Activity::ACTIVITY_INVISIBLE;
         // Only change the state when it changes. Note that when the memory
         // pressure is critical, only the primary activities (1 or 2) are made
@@ -329,14 +299,14 @@ void ResourceManagerImpl::UpdateVisibilityStates() {
         }
       }
 
-    // See which index we should handle next.
-    if (activity_order_changed_) {
-      activity_order_changed_ = false;
-      index = 0;
-    } else {
-      ++index;
-    }
+      // See which count we should handle next.
+      if (activity_order_changed_)
+        break;
+      ++count;
     }
+    // If we stopped iterating over the list of activities because of the change
+    // in ordering, then restart processing the activities from the beginning.
+  } while (activity_order_changed_);
 }
 
 void ResourceManagerImpl::TryToUnloadAnActivity() {
@@ -365,25 +335,28 @@ void ResourceManagerImpl::TryToUnloadAnActivity() {
 
   // Check if / which activity we want to unload.
   Activity* oldest_media_activity = nullptr;
-  std::vector<Activity*> unloadable_activities;
-  for (std::vector<Activity*>::iterator it = activity_list_.begin();
-       it != activity_list_.end(); ++it) {
-    Activity::ActivityState state = (*it)->GetCurrentState();
+  Activity* oldest_unloadable_activity = nullptr;
+  size_t unloadable_activity_count = 0;
+  const ActivityList& activity_list = ActivityManager::Get()->GetActivityList();
+  for (Activity* activity : activity_list) {
+    Activity::ActivityState state = activity->GetCurrentState();
     // The activity should neither be unloaded nor visible.
     if (state != Activity::ACTIVITY_UNLOADED &&
         state != Activity::ACTIVITY_VISIBLE) {
-      if ((*it)->GetMediaState() == Activity::ACTIVITY_MEDIA_STATE_NONE) {
+      if (activity->GetMediaState() == Activity::ACTIVITY_MEDIA_STATE_NONE) {
         // Does not play media - so we can unload this immediately.
-        unloadable_activities.push_back(*it);
+        ++unloadable_activity_count;
+        oldest_unloadable_activity = activity;
       } else {
-        oldest_media_activity = *it;
+        oldest_media_activity = activity;
       }
     }
   }
 
-  if (unloadable_activities.size() > max_running_activities) {
+  if (unloadable_activity_count > max_running_activities) {
+    CHECK(oldest_unloadable_activity);
     OnResourcesReleased();
-    unloadable_activities.back()->SetCurrentState(Activity::ACTIVITY_UNLOADED);
+    oldest_unloadable_activity->SetCurrentState(Activity::ACTIVITY_UNLOADED);
     return;
   } else if (current_memory_pressure_ == MEMORY_PRESSURE_CRITICAL) {
     if (oldest_media_activity) {
@@ -402,39 +375,10 @@ void ResourceManagerImpl::TryToUnloadAnActivity() {
     LOG(WARNING) << "[ResourceManager]: No way to release memory pressure (" <<
         current_memory_pressure_ <<
         "), Activities (running, allowed, unloadable)=(" <<
-        activity_list_.size() << ", " <<
+        activity_list.size() << ", " <<
         max_running_activities << ", " <<
-        unloadable_activities.size() << ")";
-  }
-}
-
-void ResourceManagerImpl::UpdateActivityOrder() {
-  queued_command_ = true;
-  if (activity_list_.empty())
-    return;
-  std::vector<Activity*> new_activity_list;
-  const aura::Window::Windows children =
-      WindowManager::Get()->GetWindowListProvider()->GetWindowList();
-  // Find the first window in the container which is part of the application.
-  for (aura::Window::Windows::const_reverse_iterator child_iterator =
-         children.rbegin();
-      child_iterator != children.rend(); ++child_iterator) {
-    for (std::vector<Activity*>::iterator activity_iterator =
-             activity_list_.begin();
-        activity_iterator != activity_list_.end(); ++activity_iterator) {
-      if (*child_iterator == (*activity_iterator)->GetWindow()) {
-        new_activity_list.push_back(*activity_iterator);
-        activity_list_.erase(activity_iterator);
-        break;
-      }
+        unloadable_activity_count << ")";
   }
-  }
-  // At this point the old list should be empty and we can swap the lists.
-  DCHECK(!activity_list_.size());
-  activity_list_ = new_activity_list;
-
-  // Remember that the activity order has changed.
-  activity_order_changed_ = true;
 }
 
 void ResourceManagerImpl::OnResourcesReleased() {

athena/test/base/activity_lifetime_tracker.cc

@@ -25,6 +25,9 @@ void ActivityLifetimeTracker::OnActivityEnding(Activity* activity) {
   deleted_activity_ = activity;
 }
 
+void ActivityLifetimeTracker::OnActivityOrderChanged() {
+}
+
 Activity* ActivityLifetimeTracker::GetNewActivityAndReset() {
   Activity* activity = new_activity_;
   new_activity_ = nullptr;

athena/test/base/activity_lifetime_tracker.h

@@ -17,11 +17,10 @@ class ActivityLifetimeTracker : public ActivityManagerObserver {
   ActivityLifetimeTracker();
   ~ActivityLifetimeTracker() override;
 
-  // Called after an |activity| got created.
+  // ActivityManagerObserver:
   void OnActivityStarted(Activity* activity) override;
-
-  // Called before an |activity| gets destroyed.
   void OnActivityEnding(Activity* activity) override;
+  void OnActivityOrderChanged() override;
 
   // Returns the newly created activity (if any) and resets its reference.
   Activity* GetNewActivityAndReset();