Adding functions to the window_list_provider for accessing the activities window list

athena/resource_manager/resource_manager_impl.cc

 // Copyright 2014 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 "athena/resource_manager/public/resource_manager.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "athena/activity/public/activity.h"
 #include "athena/activity/public/activity_manager.h"
 #include "athena/activity/public/activity_manager_observer.h"
 #include "athena/resource_manager/memory_pressure_notifier.h"
 #include "athena/resource_manager/public/resource_manager_delegate.h"
+#include "athena/wm/public/window_list_provider.h"
+#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/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "ui/aura/window.h"
-#include "ui/aura/window_observer.h"
 
 namespace athena {
 
 class ResourceManagerImpl : public ResourceManager,
                             public WindowManagerObserver,
                             public ActivityManagerObserver,
                             public MemoryPressureObserver,
-                            public aura::WindowObserver {
+                            public WindowListProviderObserver {
  public:
   ResourceManagerImpl(ResourceManagerDelegate* delegate);
   virtual ~ResourceManagerImpl();
 
   // ResourceManager:
   virtual void SetMemoryPressureAndStopMonitoring(
       MemoryPressureObserver::MemoryPressure pressure) OVERRIDE;
   virtual void Pause(bool pause) OVERRIDE {
     if (pause) {
       if (!pause_)
@@ skipping 17 matching lines @@
   virtual void OnOverviewModeEnter() OVERRIDE;
   virtual void OnOverviewModeExit() OVERRIDE;
   virtual void OnSplitViewModeEnter() OVERRIDE;
   virtual void OnSplitViewModeExit() OVERRIDE;
 
   // MemoryPressureObserver:
   virtual void OnMemoryPressure(
       MemoryPressureObserver::MemoryPressure pressure) OVERRIDE;
   virtual ResourceManagerDelegate* GetDelegate() OVERRIDE;
 
-  // aura::WindowObserver:
-  virtual void OnWindowStackingChanged(aura::Window* window) OVERRIDE;
+  // WindowListProviderObserver:
+  virtual void OnActivityStackingChanged() OVERRIDE;
 
  private:
   // Manage the resources for our activities.
   void ManageResource();
 
   // 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();
 
@@ skipping 43 matching lines @@
 ResourceManagerImpl::ResourceManagerImpl(ResourceManagerDelegate* delegate)
     : delegate_(delegate),
       current_memory_pressure_(MemoryPressureObserver::MEMORY_PRESSURE_UNKNOWN),
       memory_pressure_notifier_(new MemoryPressureNotifier(this)),
       pause_(false),
       queued_command_(false),
       activity_order_changed_(false),
       in_overview_mode_(false),
       in_splitview_mode_(false) {
   WindowManager::GetInstance()->AddObserver(this);
+  WindowManager::GetInstance()->GetWindowListProvider()->AddObserver(this);
   ActivityManager::Get()->AddObserver(this);
 }
 
 ResourceManagerImpl::~ResourceManagerImpl() {
   ActivityManager::Get()->RemoveObserver(this);
+  WindowManager::GetInstance()->GetWindowListProvider()->RemoveObserver(this);
   WindowManager::GetInstance()->RemoveObserver(this);
 
   while (!activity_list_.empty())
     OnActivityEnding(activity_list_.front());
 }
 
 void ResourceManagerImpl::SetMemoryPressureAndStopMonitoring(
     MemoryPressureObserver::MemoryPressure pressure) {
   memory_pressure_notifier_->StopObserving();
   OnMemoryPressure(pressure);
 }
 
 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;
-  activity->GetWindow()->AddObserver(this);
 }
 
 void ResourceManagerImpl::OnActivityEnding(Activity* activity) {
   DCHECK(activity->GetWindow());
-  activity->GetWindow()->RemoveObserver(this);
   // 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::OnOverviewModeEnter() {
@@ skipping 12 matching lines @@
   ManageResource();
 }
 
 
 void ResourceManagerImpl::OnSplitViewModeExit() {
   // We don't do immediately something yet. The next ManageResource call will
   // come soon.
   in_splitview_mode_ = false;
 }
 
-void ResourceManagerImpl::OnWindowStackingChanged(aura::Window* window) {
+void ResourceManagerImpl::OnActivityStackingChanged() {
   // TODO(skuhne): This needs to be changed to some WindowListProvider observer
   // if we decouple window order from activity order.
+  activity_order_changed_ = true;
+  if (pause_) {

[oshima, 2014/09/09 18:28:37]

we don't need pause now, do we?

[Mr4D (OOO till 08-26), 2014/09/10 00:01:58]

It's used for unit tests (and it might come back for other things as well). We
can rename / remove once this stabelizes and only unittests need it.

[oshima, 2014/09/10 01:03:30]

Acknowledged.

+    queued_command_ = true;
+    return;
+  }
 
   // No need to do anything while being in overview mode.
   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.
@@ skipping 185 matching lines @@
 }
 
 ResourceManager::ResourceManager() {}
 
 ResourceManager::~ResourceManager() {
   DCHECK(instance);
   instance = NULL;
 }
 
 }  // namespace athena