Split Screen mode implementation

athena/wm/window_manager_impl.cc

Index: athena/wm/window_manager_impl.cc
diff --git a/athena/wm/window_manager_impl.cc b/athena/wm/window_manager_impl.cc
index a5bbf53b990b895244aa2bc9d6a69c7e023d8381..08eac8bbd7778cfc5a722da7b22892b7f62faee4 100644
--- a/athena/wm/window_manager_impl.cc
+++ b/athena/wm/window_manager_impl.cc
@@ -10,6 +10,7 @@
 #include "athena/wm/public/window_manager_observer.h"
 #include "athena/wm/split_view_controller.h"
 #include "athena/wm/window_overview_mode.h"
+#include "athena/wm/window_stack_provider.h"
 #include "base/logging.h"
 #include "base/observer_list.h"
 #include "ui/aura/layout_manager.h"
@@ -20,6 +21,7 @@ namespace athena {
 namespace {
 
 class WindowManagerImpl : public WindowManager,
+                          public WindowStackProvider,
                           public WindowOverviewModeDelegate,
                           public aura::WindowObserver,
                           public AcceleratorHandler {
@@ -31,17 +33,28 @@ class WindowManagerImpl : public WindowManager,
 
   // WindowManager:
   virtual void ToggleOverview() OVERRIDE {
+    LOG(ERROR) << "ToggleOverview";
     if (overview_) {

[Jun Mukai, 2014/07/25 20:21:30]

Keep in mind that pkotwicz is changing the code around |overview_|, see
crbug.com/396368 for its progress (his first patch was reverted though...)

-      overview_.reset();
       FOR_EACH_OBSERVER(WindowManagerObserver, observers_,
                         OnOverviewModeExit());
+      overview_.reset();
     } else {
-      overview_ = WindowOverviewMode::Create(container_.get(), this);
+      // Re-stack all windows in the order defined by ordered_windows_.
+      aura::Window::Windows::iterator it;
+      for (it = ordered_windows_.begin(); it != ordered_windows_.end(); ++it) {
+        container_->StackChildAtTop(*it);
+      }
       FOR_EACH_OBSERVER(WindowManagerObserver, observers_,
                         OnOverviewModeEnter());
+      overview_ =
+          WindowOverviewMode::Create(container_.get(), GetWindowStack(), this);
     }
   }
 
+  virtual bool IsOverviewModeActive() OVERRIDE {
+    return overview_;
+  }
+
  private:
   enum Command {
     COMMAND_TOGGLE_OVERVIEW,
@@ -65,10 +78,24 @@ class WindowManagerImpl : public WindowManager,
     observers_.RemoveObserver(observer);
   }
 
-  // WindowOverviewModeDelegate:
-  virtual void OnSelectWindow(aura::Window* window) OVERRIDE {
+  // WindowStackProvider:
+  virtual void MoveWindowToFront(aura::Window* window) OVERRIDE{
     CHECK_EQ(container_.get(), window->parent());
+    aura::Window::Windows::iterator it = std::find(
+        ordered_windows_.begin(), ordered_windows_.end(), window);
+    DCHECK(it != ordered_windows_.end());
+    ordered_windows_.erase(it);
+    ordered_windows_.push_back(window);
     container_->StackChildAtTop(window);

[oshima, 2014/07/28 17:58:43]

This should have called wm::ActivateWindow instead.

[mfomitchev, 2014/08/05 19:56:57]

Done.

+  }
+
+  virtual const aura::Window::Windows& GetWindowStack() OVERRIDE {
+    return ordered_windows_;
+  }
+
+  // WindowOverviewModeDelegate:
+  virtual void OnSelectWindow(aura::Window* window) OVERRIDE {
+    MoveWindowToFront(window);
     overview_.reset();
     FOR_EACH_OBSERVER(WindowManagerObserver, observers_,
                       OnOverviewModeExit());
@@ -80,6 +107,16 @@ class WindowManagerImpl : public WindowManager,
       container_.reset();
   }
 
+  virtual void OnWillRemoveWindow(aura::Window* window) OVERRIDE {
+    aura::Window::Windows::iterator it = std::find(
+        ordered_windows_.begin(), ordered_windows_.end(), window);
+    ordered_windows_.erase(it);
+  }
+
+  virtual void OnWindowAdded(aura::Window* new_window) OVERRIDE {
+    ordered_windows_.push_back(new_window);
+  }
+
   // AcceleratorHandler:
   virtual bool IsCommandEnabled(int command_id) const OVERRIDE { return true; }
   virtual bool OnAcceleratorFired(int command_id,
@@ -93,6 +130,7 @@ class WindowManagerImpl : public WindowManager,
   }
 
   scoped_ptr<aura::Window> container_;
+  aura::Window::Windows ordered_windows_;

[oshima, 2014/07/25 21:41:10]

what's the reason to keep its own list?

[mfomitchev, 2014/07/25 23:27:38]

The order within the container changes when you interact with the UI. When a
window becomes the target of a gesture, it is stacked on top of all the other
windows.

[oshima, 2014/07/28 17:58:42]

StackChildAtTop does change the order within the container. My question was why
you need to keep separate list.

I think we eventually need MRU like ash has, but it should live in resource
management rather than here.

[mfomitchev, 2014/07/28 18:15:00]

I can't rely on the container's window order for the purposes of window-cycling
(alt-tab like behavior). The container's window order changes as the user
interacts with the UI - e.g. when a window becomes the target of a gesture, it
is stacked on top of all the other windows. So what happens is that the window
which is shown always ends up on top of all the other windows. But in order to
implement the cycling, we need the window order to be static - otherwise it's
hard to figure out what the next/prev window is.

[oshima, 2014/07/28 18:35:20]

I know that container's window order isn't enough to implement alt-tab,
and ash has ash/wm/mru_window_tracker for it. What I'm saying is that\
if you're going to implement alt-tab (are you going to add it in this CL?),
then it should be handled by separate entity like ash's mru tracker and use
activation observer, not here.

[mfomitchev, 2014/07/28 18:57:42]

SplitViewController implements window switching - you can swipe left/right to
switch to the next/prev window. You can continue swiping to cycle through all
windows. It's similar to alt-tab in that it needs to know the window order. 

I can factor the functionality out of window manager and into a separate class.
athena::MruWindowTracker?

Note that we can't update MRU order every time we switch to the previous window
by swiping: if we do that, you'll keep cycling between 2 windows: the most
recent and second most recent. Each time you swipe, the second most recent
becomes the most recent, and the most recent becomes trhe second most recent. So
currently the order is only updated when you switch to the overview mode. That
is probably not enough - we'll likely also want to update the order once you've
spent some time in the new window after swiping to it.. or something along those
lines.

[mfomitchev, 2014/08/05 19:56:57]

I have implemented a very basic, stripped down MruWindowTracker. Currently it's
not even tracking the window activations - only creations and deletions. It's
quite possible that it will need to track activations as well in the future, but
it's not clear until we have a defined UX.

   scoped_ptr<WindowOverviewMode> overview_;
   scoped_ptr<BezelController> bezel_controller_;
   scoped_ptr<SplitViewController> split_view_controller_;
@@ -138,7 +176,8 @@ WindowManagerImpl::WindowManagerImpl() {
   container_->SetLayoutManager(new AthenaContainerLayoutManager);
   container_->AddObserver(this);
   bezel_controller_.reset(new BezelController(container_.get()));
-  split_view_controller_.reset(new SplitViewController());
+  split_view_controller_.reset(new SplitViewController(
+      container_.get(), this, this));
   bezel_controller_->set_left_right_delegate(split_view_controller_.get());
   container_->AddPreTargetHandler(bezel_controller_.get());
   instance = this;