athena: A simpler implementation of WindowListProvider.

Introduce WindowListProviderImpl that simply works with the stacking order of
child windows of the container. This changes the behaviour of repeated bezel
swipes from the left edge to swipe between the last two active windows, which
is the desired behaviour.

BUG=403444
R=mfomitchev@chromium.org, oshima@chromium.org

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

Cr-Commit-Position: refs/heads/master@{#289984}
git-svn-id: svn://svn.chromium.org/chrome/trunk/src@289984 0039d316-1c4b-4281-b951-d872f2087c98

10 files changed, 199 insertions, 243 deletions

diff --git a/athena/wm/mru_window_tracker.cc b/athena/wm/mru_window_tracker.cc
deleted file mode 100644
index b2cda0c..0000000
--- a/athena/wm/mru_window_tracker.cc
+++ /dev/null
@@ -1,53 +0,0 @@
-// 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/wm/mru_window_tracker.h"
-
-#include "ui/aura/window.h"
-
-namespace athena {
-
-MruWindowTracker::MruWindowTracker(aura::Window* container)
-    : container_(container) {
-  container->AddObserver(this);
-}
-
-MruWindowTracker::~MruWindowTracker() {
-  if (container_)
-    container_->RemoveObserver(this);
-}
-
-aura::Window::Windows MruWindowTracker::GetWindowList() const {
-  return aura::Window::Windows(mru_windows_.begin(), mru_windows_.end());
-}
-
-void MruWindowTracker::MoveToFront(aura::Window* window) {
-  DCHECK(window);
-  CHECK_EQ(container_, window->parent());
-  std::list<aura::Window*>::iterator it =
-      std::find(mru_windows_.begin(), mru_windows_.end(), window);
-  DCHECK(it != mru_windows_.end());
-  mru_windows_.erase(it);
-  mru_windows_.push_back(window);
-}
-
-// Overridden from WindowObserver:
-void MruWindowTracker::OnWillRemoveWindow(aura::Window* window) {
-  std::list<aura::Window*>::iterator it =
-      std::find(mru_windows_.begin(), mru_windows_.end(), window);
-  if (it == mru_windows_.end()) {
-    // All normal windows should be tracked in mru_windows_
-    DCHECK_NE(window->type(), ui::wm::WINDOW_TYPE_NORMAL);
-    return;
-  }
-  mru_windows_.erase(it);
-}
-
-void MruWindowTracker::OnWindowAdded(aura::Window* new_window) {
-  // We are only interested in ordering normal windows.
-  if (new_window->type() == ui::wm::WINDOW_TYPE_NORMAL)
-    mru_windows_.push_back(new_window);
-}
-
-}  // namespace athena
diff --git a/athena/wm/mru_window_tracker.h b/athena/wm/mru_window_tracker.h
deleted file mode 100644
index 0ec9d98..0000000
--- a/athena/wm/mru_window_tracker.h
+++ /dev/null
@@ -1,49 +0,0 @@
-// 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.
-
-#ifndef ATHENA_WM_MRU_WINDOW_TRACKER_H_
-#define ATHENA_WM_MRU_WINDOW_TRACKER_H_
-
-#include <list>
-
-#include "athena/wm/public/window_list_provider.h"
-#include "ui/aura/window_observer.h"
-
-namespace aura {
-class Window;
-}
-
-namespace athena {
-
-// Maintains a most recently used list of windows. This is used for window
-// cycling and overview mode.
-class MruWindowTracker : public WindowListProvider,
-                         public aura::WindowObserver {
- public:
-  explicit MruWindowTracker(aura::Window* container);
-  virtual ~MruWindowTracker();
-
-  // Overridden from WindowListProvider
-  virtual aura::Window::Windows GetWindowList() const OVERRIDE;
-
-  // Updates the mru_windows_ list to move |window| to the front.
-  // |window| must be the child of |container_|.
-  virtual void MoveToFront(aura::Window* window) OVERRIDE;
-
- private:
-  // Overridden from WindowObserver:
-  virtual void OnWillRemoveWindow(aura::Window* window) OVERRIDE;
-  virtual void OnWindowAdded(aura::Window* new_window) OVERRIDE;
-
-  // List of windows that have been used in the container, sorted by most
-  // recently used.
-  std::list<aura::Window*> mru_windows_;
-  aura::Window* container_;
-
-  DISALLOW_COPY_AND_ASSIGN(MruWindowTracker);
-};
-
-}  // namespace athena
-
-#endif  // ATHENA_WM_MRU_WINDOW_TRACKER_H_
diff --git a/athena/wm/public/window_list_provider.h b/athena/wm/public/window_list_provider.h
index 7ffadf4..d22aa3d 100644
--- a/athena/wm/public/window_list_provider.h
+++ b/athena/wm/public/window_list_provider.h
@@ -17,9 +17,6 @@ class ATHENA_EXPORT WindowListProvider {
 
   // Returns an ordered list of windows.
   virtual aura::Window::Windows GetWindowList() const = 0;
-
-  // Moves the window to the front of the list.
-  virtual void MoveToFront(aura::Window* window) = 0;
 };
 
 }  // namespace athena
diff --git a/athena/wm/split_view_controller.cc b/athena/wm/split_view_controller.cc
index 997c107..088de30 100644
--- a/athena/wm/split_view_controller.cc
+++ b/athena/wm/split_view_controller.cc
@@ -16,29 +16,23 @@
 #include "ui/events/event_handler.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/screen.h"
+#include "ui/wm/core/window_util.h"
 
 namespace athena {
 
 SplitViewController::SplitViewController(
     aura::Window* container,
-    WindowListProvider* window_list_provider,
-    WindowManager* window_manager)
+    WindowListProvider* window_list_provider)
     : state_(INACTIVE),
       container_(container),
-      window_manager_(window_manager),
       window_list_provider_(window_list_provider),
-      current_activity_window_(NULL),
       left_window_(NULL),
       right_window_(NULL),
       separator_position_(0),
       weak_factory_(this) {
-  if (window_manager_)
-    window_manager_->AddObserver(this);
 }
 
 SplitViewController::~SplitViewController() {
-  if (window_manager_)
-    window_manager_->RemoveObserver(this);
 }
 
 bool SplitViewController::IsSplitViewModeActive() const {
@@ -91,6 +85,12 @@ void SplitViewController::ActivateSplitMode(aura::Window* left,
   UpdateLayout(true);
 }
 
+void SplitViewController::DeactivateSplitMode() {
+  CHECK_NE(SCROLLING, state_);
+  state_ = INACTIVE;
+  left_window_ = right_window_ = NULL;
+}
+
 void SplitViewController::UpdateLayout(bool animate) {
   if  (!left_window_)
     return;
@@ -180,67 +180,43 @@ void SplitViewController::UpdateSeparatorPositionFromScrollDelta(float delta) {
                 : display_bounds.right() - container_bounds.x() + delta;
 }
 
-aura::Window* SplitViewController::GetCurrentActivityWindow() {
-  if (!current_activity_window_) {
-    aura::Window::Windows windows = window_list_provider_->GetWindowList();
-    if (windows.empty())
-      return NULL;
-    current_activity_window_ = windows.back();
-  }
-  return current_activity_window_;
-}
-
 ///////////////////////////////////////////////////////////////////////////////
-// Begin BezelController::ScrollDelegate overrides.
+// BezelController::ScrollDelegate:
+
 void SplitViewController::ScrollBegin(BezelController::Bezel bezel,
                                       float delta) {
   if (!CanScroll())
     return;
   state_ = SCROLLING;
-  aura::Window* current_window = GetCurrentActivityWindow();
-  CHECK(current_window);
 
   aura::Window::Windows windows = window_list_provider_->GetWindowList();
   CHECK(windows.size() >= 2);
-  aura::Window::Windows::const_iterator it =
-      std::find(windows.begin(), windows.end(), current_window);
-  CHECK(it != windows.end());
+  aura::Window::Windows::const_reverse_iterator iter = windows.rbegin();
+  aura::Window* current_window = *(iter);
+  CHECK(wm::IsActiveWindow(current_window));
 
   if (delta > 0) {
     right_window_ = current_window;
-    // reverse iterator points to the position before normal iterator |it|
-    aura::Window::Windows::const_reverse_iterator rev_it(it);
-    // circle to end if needed.
-    left_window_ = rev_it == windows.rend() ? windows.back() : *(rev_it);
+    left_window_ = *(iter + 1);
   } else {
     left_window_ = current_window;
-    ++it;
-    // circle to front if needed.
-    right_window_ = it == windows.end() ? windows.front() : *it;
+    right_window_ = *(iter + 1);
   }
 
   CHECK(left_window_);
   CHECK(right_window_);
 
-  // TODO(oshima|mfomitchev): crbug.com/388362
-  // Until we are properly hiding off-screen windows in window manager:
-  // Loop through all windows and hide them
-  for (it = windows.begin(); it != windows.end(); ++it) {
-    if (*it != left_window_ && *it != right_window_)
-      (*it)->Hide();
-  }
-
   UpdateSeparatorPositionFromScrollDelta(delta);
   UpdateLayout(false);
 }
 
-// Max distance from the scroll end position to the middle of the screen where
-// we would go into the split view mode.
-const int kMaxDistanceFromMiddle = 120;
 void SplitViewController::ScrollEnd() {
   if (state_ != SCROLLING)
     return;
 
+  // Max distance from the scroll end position to the middle of the screen where
+  // we would go into the split view mode.
+  const int kMaxDistanceFromMiddle = 120;
   int container_width = container_->GetBoundsInScreen().width();
   if (std::abs(container_width / 2 - separator_position_) <=
       kMaxDistanceFromMiddle) {
@@ -248,12 +224,12 @@ void SplitViewController::ScrollEnd() {
     separator_position_ = container_width / 2;
   } else if (separator_position_ < container_width / 2) {
     separator_position_ = 0;
-    current_activity_window_ = right_window_;
     state_ = INACTIVE;
+    wm::ActivateWindow(right_window_);
   } else {
     separator_position_ = container_width;
-    current_activity_window_ = left_window_;
     state_ = INACTIVE;
+    wm::ActivateWindow(left_window_);
   }
   UpdateLayout(true);
 }
@@ -267,34 +243,9 @@ void SplitViewController::ScrollUpdate(float delta) {
 
 bool SplitViewController::CanScroll() {
   // TODO(mfomitchev): return false in vertical orientation, in full screen.
-  bool result = (window_manager_ && !window_manager_->IsOverviewModeActive() &&
-                 !IsSplitViewModeActive() &&
+  bool result = (!IsSplitViewModeActive() &&
                  window_list_provider_->GetWindowList().size() >= 2);
   return result;
 }
 
-///////////////////////////////////////////////////////////////////////////////
-// WindowManagerObserver overrides
-void SplitViewController::OnOverviewModeEnter() {
-  if (state_ == ACTIVE) {
-    CHECK(left_window_);
-    CHECK(right_window_);
-    window_list_provider_->MoveToFront(right_window_);
-    window_list_provider_->MoveToFront(left_window_);
-    // TODO(mfomitchev): This shouldn't be done here, but the overview mode's
-    // transition animation currently looks bad if the starting transform of
-    // any window is not gfx::Transform().
-    right_window_->SetTransform(gfx::Transform());
-  } else if (current_activity_window_) {
-    window_list_provider_->MoveToFront(current_activity_window_);
-  }
-  state_ = INACTIVE;
-  left_window_ = NULL;
-  right_window_ = NULL;
-  current_activity_window_ = NULL;
-}
-
-void SplitViewController::OnOverviewModeExit() {
-}
-
 }  // namespace athena
diff --git a/athena/wm/split_view_controller.h b/athena/wm/split_view_controller.h
index 2e5d0ce0..4e0d3cc 100644
--- a/athena/wm/split_view_controller.h
+++ b/athena/wm/split_view_controller.h
@@ -7,8 +7,6 @@
 
 #include "athena/athena_export.h"
 #include "athena/wm/bezel_controller.h"
-#include "athena/wm/public/window_manager_observer.h"
-#include "athena/wm/window_overview_mode.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 
@@ -18,18 +16,14 @@ class Transform;
 
 namespace athena {
 class WindowListProvider;
-class WindowManager;
-class WindowOverviewModeDelegate;
 
 // Responsible for entering split view mode, exiting from split view mode, and
 // laying out the windows in split view mode.
 class ATHENA_EXPORT SplitViewController
-    : public BezelController::ScrollDelegate,
-    public WindowManagerObserver {
+    : public BezelController::ScrollDelegate {
  public:
   SplitViewController(aura::Window* container,
-                      WindowListProvider* window_list_provider,
-                      WindowManager* window_manager);
+                      WindowListProvider* window_list_provider);
 
   virtual ~SplitViewController();
 
@@ -40,6 +34,11 @@ class ATHENA_EXPORT SplitViewController
   // |left| nor |right|) is selected instead.
   void ActivateSplitMode(aura::Window* left, aura::Window* right);
 
+  // Resets the internal state to an inactive state. Calling this does not
+  // change the window bounds/transforms etc. The caller must take care of
+  // making any necessary changes.
+  void DeactivateSplitMode();
+
   aura::Window* left_window() { return left_window_; }
   aura::Window* right_window() { return right_window_; }
 
@@ -67,38 +66,19 @@ class ATHENA_EXPORT SplitViewController
 
   void UpdateSeparatorPositionFromScrollDelta(float delta);
 
-  // Returns the current activity shown to the user. Persists through the
-  // SCROLLING and ACTIVE states and gets updated if the current activity goes
-  // off screen when the user switches between activities.
-  aura::Window* GetCurrentActivityWindow();
-
-  // BezelController::ScrollDelegate overrides.
+  // BezelController::ScrollDelegate:
   virtual void ScrollBegin(BezelController::Bezel bezel, float delta) OVERRIDE;
   virtual void ScrollEnd() OVERRIDE;
   virtual void ScrollUpdate(float delta) OVERRIDE;
   virtual bool CanScroll() OVERRIDE;
 
-  // WindowManagerObserver
-  virtual void OnOverviewModeEnter() OVERRIDE;
-  virtual void OnOverviewModeExit() OVERRIDE;
-
   State state_;
 
   aura::Window* container_;
 
-  // Window Manager which owns this SplitViewController. The window manager must
-  // be alive for the duration of the lifetime of the SplitViewController.
-  // Can be NULL (in tests).
-  WindowManager* window_manager_;
-
   // Provider of the list of windows to cycle through. Not owned.
   WindowListProvider* window_list_provider_;
 
-  // Keeps track of the current activity shown as the user switches between
-  // activities. Persists through the SCROLLING and ACTIVE states. Gets reset
-  // to NULL when overview mode is activated.
-  aura::Window* current_activity_window_;
-
   // Windows for the left and right activities shown in SCROLLING and ACTIVE
   // states. In INACTIVE state these are NULL.
   aura::Window* left_window_;
diff --git a/athena/wm/split_view_controller_unittest.cc b/athena/wm/split_view_controller_unittest.cc
index 36b244c..78e44db 100644
--- a/athena/wm/split_view_controller_unittest.cc
+++ b/athena/wm/split_view_controller_unittest.cc
@@ -7,6 +7,7 @@
 #include "athena/common/fill_layout_manager.h"
 #include "athena/test/athena_test_base.h"
 #include "athena/wm/public/window_list_provider.h"
+#include "athena/wm/window_list_provider_impl.h"
 #include "base/memory/scoped_vector.h"
 #include "ui/aura/test/test_window_delegate.h"
 #include "ui/aura/window.h"
@@ -15,28 +16,6 @@ namespace athena {
 
 typedef test::AthenaTestBase SplitViewControllerTest;
 
-class SimpleWindowListProvider : public WindowListProvider {
- public:
-  explicit SimpleWindowListProvider(aura::Window* container)
-      : container_(container) {}
-  virtual ~SimpleWindowListProvider() {}
-
-  // WindowListProvider:
-  virtual aura::Window::Windows GetWindowList() const OVERRIDE {
-    return container_->children();
-  }
-
-  virtual void MoveToFront(aura::Window* window) OVERRIDE {
-    CHECK_EQ(container_, window->parent());
-    container_->StackChildAtTop(window);
-  }
-
- private:
-  aura::Window* container_;
-
-  DISALLOW_COPY_AND_ASSIGN(SimpleWindowListProvider);
-};
-
 // Tests that when split mode is activated, the windows on the left and right
 // are selected correctly.
 TEST_F(SplitViewControllerTest, SplitModeActivation) {
@@ -45,13 +24,15 @@ TEST_F(SplitViewControllerTest, SplitModeActivation) {
   const int kNumWindows = 6;
   for (size_t i = 0; i < kNumWindows; ++i) {
     aura::Window* window = new aura::Window(&delegate);
+    window->SetType(ui::wm::WINDOW_TYPE_NORMAL);
     window->Init(aura::WINDOW_LAYER_SOLID_COLOR);
     root_window()->AddChild(window);
     windows.push_back(window);
   }
 
-  SimpleWindowListProvider list_provider(root_window());
-  SplitViewController controller(root_window(), &list_provider, NULL);
+  scoped_ptr<WindowListProvider> list_provider(
+      new WindowListProviderImpl(root_window()));
+  SplitViewController controller(root_window(), list_provider.get());
   ASSERT_FALSE(controller.IsSplitViewModeActive());
 
   controller.ActivateSplitMode(NULL, NULL);
@@ -75,18 +56,18 @@ TEST_F(SplitViewControllerTest, SplitModeActivation) {
   controller.ActivateSplitMode(NULL, windows[0]);
   EXPECT_EQ(windows[kNumWindows - 1], controller.left_window());
   EXPECT_EQ(windows[0], controller.right_window());
-  EXPECT_EQ(windows[0], *list_provider.GetWindowList().rbegin());
+  EXPECT_EQ(windows[0], *list_provider->GetWindowList().rbegin());
 
   controller.ActivateSplitMode(windows[1], NULL);
   EXPECT_EQ(windows[1], controller.left_window());
   EXPECT_EQ(windows[0], controller.right_window());
-  EXPECT_EQ(windows[1], *list_provider.GetWindowList().rbegin());
+  EXPECT_EQ(windows[1], *list_provider->GetWindowList().rbegin());
 
   controller.ActivateSplitMode(windows[4], windows[5]);
   EXPECT_EQ(windows[4], controller.left_window());
   EXPECT_EQ(windows[5], controller.right_window());
-  EXPECT_EQ(windows[4], *list_provider.GetWindowList().rbegin());
-  EXPECT_EQ(windows[5], *(list_provider.GetWindowList().rbegin() + 1));
+  EXPECT_EQ(windows[4], *list_provider->GetWindowList().rbegin());
+  EXPECT_EQ(windows[5], *(list_provider->GetWindowList().rbegin() + 1));
 }
 
 }  // namespace athena
diff --git a/athena/wm/window_list_provider_impl.cc b/athena/wm/window_list_provider_impl.cc
new file mode 100644
index 0000000..8b4cba5
--- /dev/null
+++ b/athena/wm/window_list_provider_impl.cc
@@ -0,0 +1,31 @@
+// 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/wm/window_list_provider_impl.h"
+
+#include "ui/aura/window.h"
+
+namespace athena {
+
+WindowListProviderImpl::WindowListProviderImpl(aura::Window* container)
+    : container_(container) {
+  CHECK(container_);
+}
+
+WindowListProviderImpl::~WindowListProviderImpl() {
+}
+
+aura::Window::Windows WindowListProviderImpl::GetWindowList() const {
+  aura::Window::Windows list;
+  const aura::Window::Windows& container_children = container_->children();
+  for (aura::Window::Windows::const_iterator iter = container_children.begin();
+       iter != container_children.end();
+       ++iter) {
+    if ((*iter)->type() == ui::wm::WINDOW_TYPE_NORMAL)
+      list.push_back(*iter);
+  }
+  return list;
+}
+
+}  // namespace athena
diff --git a/athena/wm/window_list_provider_impl.h b/athena/wm/window_list_provider_impl.h
new file mode 100644
index 0000000..a62507e
--- /dev/null
+++ b/athena/wm/window_list_provider_impl.h
@@ -0,0 +1,30 @@
+// 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.
+
+#ifndef ATHENA_WM_WINDOW_LIST_PROVIDER_IMPL_H_
+#define ATHENA_WM_WINDOW_LIST_PROVIDER_IMPL_H_
+
+#include "athena/wm/public/window_list_provider.h"
+
+namespace athena {
+
+// This implementation of the WindowListProviderImpl uses the same order as in
+// the container window's stacking order.
+class ATHENA_EXPORT WindowListProviderImpl : public WindowListProvider {
+ public:
+  explicit WindowListProviderImpl(aura::Window* container);
+  virtual ~WindowListProviderImpl();
+
+ private:
+  // WindowListProvider:
+  virtual aura::Window::Windows GetWindowList() const OVERRIDE;
+
+  aura::Window* container_;
+
+  DISALLOW_COPY_AND_ASSIGN(WindowListProviderImpl);
+};
+
+}  // namespace athena
+
+#endif  // ATHENA_WM_WINDOW_LIST_PROVIDER_IMPL_H_
diff --git a/athena/wm/window_list_provider_impl_unittest.cc b/athena/wm/window_list_provider_impl_unittest.cc
new file mode 100644
index 0000000..eba6b7a
--- /dev/null
+++ b/athena/wm/window_list_provider_impl_unittest.cc
@@ -0,0 +1,86 @@
+// 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/wm/window_list_provider_impl.h"
+
+#include <algorithm>
+
+#include "athena/test/athena_test_base.h"
+#include "ui/aura/test/test_window_delegate.h"
+#include "ui/aura/window.h"
+
+namespace athena {
+
+namespace {
+
+bool AreWindowListsEqual(const aura::Window::Windows& one,
+                         const aura::Window::Windows& two) {
+  return one.size() == two.size() &&
+         std::equal(one.begin(), one.end(), two.begin());
+}
+
+scoped_ptr<aura::Window> CreateWindow(aura::WindowDelegate* delegate,
+                                      ui::wm::WindowType window_type) {
+  scoped_ptr<aura::Window> window(new aura::Window(delegate));
+  window->SetType(window_type);
+  window->Init(aura::WINDOW_LAYER_SOLID_COLOR);
+  return window.Pass();
+}
+
+}  // namespace
+
+typedef test::AthenaTestBase WindowListProviderImplTest;
+
+// Tests that the order of windows match the stacking order of the windows in
+// the container, even after the order is changed through the aura Window API.
+TEST_F(WindowListProviderImplTest, StackingOrder) {
+  aura::test::TestWindowDelegate delegate;
+  scoped_ptr<aura::Window> container(new aura::Window(&delegate));
+  scoped_ptr<aura::Window> first =
+      CreateWindow(&delegate, ui::wm::WINDOW_TYPE_NORMAL);
+  scoped_ptr<aura::Window> second =
+      CreateWindow(&delegate, ui::wm::WINDOW_TYPE_NORMAL);
+  scoped_ptr<aura::Window> third =
+      CreateWindow(&delegate, ui::wm::WINDOW_TYPE_NORMAL);
+  container->AddChild(first.get());
+  container->AddChild(second.get());
+  container->AddChild(third.get());
+
+  scoped_ptr<WindowListProvider> list_provider(
+      new WindowListProviderImpl(container.get()));
+  EXPECT_TRUE(AreWindowListsEqual(container->children(),
+                                  list_provider->GetWindowList()));
+
+  container->StackChildAtTop(first.get());
+  EXPECT_TRUE(AreWindowListsEqual(container->children(),
+                                  list_provider->GetWindowList()));
+  EXPECT_EQ(first.get(), container->children().back());
+}
+
+TEST_F(WindowListProviderImplTest, ListContainsOnlyNormalWindows) {
+  aura::test::TestWindowDelegate delegate;
+  scoped_ptr<aura::Window> container(new aura::Window(&delegate));
+  scoped_ptr<aura::Window> first =
+      CreateWindow(&delegate, ui::wm::WINDOW_TYPE_NORMAL);
+  scoped_ptr<aura::Window> second =
+      CreateWindow(&delegate, ui::wm::WINDOW_TYPE_POPUP);
+  scoped_ptr<aura::Window> third =
+      CreateWindow(&delegate, ui::wm::WINDOW_TYPE_NORMAL);
+  scoped_ptr<aura::Window> fourth =
+      CreateWindow(&delegate, ui::wm::WINDOW_TYPE_MENU);
+  container->AddChild(first.get());
+  container->AddChild(second.get());
+  container->AddChild(third.get());
+  container->AddChild(fourth.get());
+
+  scoped_ptr<WindowListProvider> list_provider(
+      new WindowListProviderImpl(container.get()));
+  const aura::Window::Windows list = list_provider->GetWindowList();
+  EXPECT_EQ(list.end(), std::find(list.begin(), list.end(), second.get()));
+  EXPECT_EQ(list.end(), std::find(list.begin(), list.end(), fourth.get()));
+  EXPECT_NE(list.end(), std::find(list.begin(), list.end(), first.get()));
+  EXPECT_NE(list.end(), std::find(list.begin(), list.end(), third.get()));
+}
+
+}  // namespace athena
diff --git a/athena/wm/window_manager_impl.cc b/athena/wm/window_manager_impl.cc
index f124311..eaaa0cd 100644
--- a/athena/wm/window_manager_impl.cc
+++ b/athena/wm/window_manager_impl.cc
@@ -10,10 +10,10 @@
 #include "athena/input/public/accelerator_manager.h"
 #include "athena/screen/public/screen_manager.h"
 #include "athena/wm/bezel_controller.h"
-#include "athena/wm/mru_window_tracker.h"
 #include "athena/wm/public/window_manager_observer.h"
 #include "athena/wm/split_view_controller.h"
 #include "athena/wm/title_drag_controller.h"
+#include "athena/wm/window_list_provider_impl.h"
 #include "athena/wm/window_overview_mode.h"
 #include "base/logging.h"
 #include "base/observer_list.h"
@@ -79,7 +79,7 @@ class WindowManagerImpl : public WindowManager,
   virtual void OnTitleDragCanceled(aura::Window* window) OVERRIDE;
 
   scoped_ptr<aura::Window> container_;
-  scoped_ptr<MruWindowTracker> mru_window_tracker_;
+  scoped_ptr<WindowListProvider> window_list_provider_;
   scoped_ptr<WindowOverviewMode> overview_;
   scoped_ptr<BezelController> bezel_controller_;
   scoped_ptr<SplitViewController> split_view_controller_;
@@ -118,10 +118,10 @@ WindowManagerImpl::WindowManagerImpl() {
   container_.reset(ScreenManager::Get()->CreateDefaultContainer(params));
   container_->SetLayoutManager(new AthenaContainerLayoutManager);
   container_->AddObserver(this);
-  mru_window_tracker_.reset(new MruWindowTracker(container_.get()));
+  window_list_provider_.reset(new WindowListProviderImpl(container_.get()));
   bezel_controller_.reset(new BezelController(container_.get()));
-  split_view_controller_.reset(new SplitViewController(
-      container_.get(), mru_window_tracker_.get(), this));
+  split_view_controller_.reset(
+      new SplitViewController(container_.get(), window_list_provider_.get()));
   bezel_controller_->set_left_right_delegate(split_view_controller_.get());
   container_->AddPreTargetHandler(bezel_controller_.get());
   title_drag_controller_.reset(new TitleDragController(container_.get(), this));
@@ -136,7 +136,7 @@ WindowManagerImpl::WindowManagerImpl() {
 WindowManagerImpl::~WindowManagerImpl() {
   overview_.reset();
   split_view_controller_.reset();
-  mru_window_tracker_.reset();
+  window_list_provider_.reset();
   if (container_) {
     container_->RemoveObserver(this);
     container_->RemovePreTargetHandler(bezel_controller_.get());
@@ -173,18 +173,21 @@ void WindowManagerImpl::SetInOverview(bool active) {
   if (active == in_overview)
     return;
 
+  bezel_controller_->set_left_right_delegate(
+      active ? NULL : split_view_controller_.get());
   if (active) {
+    split_view_controller_->DeactivateSplitMode();
     FOR_EACH_OBSERVER(WindowManagerObserver, observers_,
                       OnOverviewModeEnter());
-    // Re-stack all windows in the order defined by mru_window_tracker_.
-    aura::Window::Windows window_list = mru_window_tracker_->GetWindowList();
+    // Re-stack all windows in the order defined by window_list_provider_.
+    aura::Window::Windows window_list = window_list_provider_->GetWindowList();
     aura::Window::Windows::iterator it;
     for (it = window_list.begin(); it != window_list.end(); ++it)
       container_->StackChildAtTop(*it);
-    overview_ = WindowOverviewMode::Create(container_.get(),
-                                           mru_window_tracker_.get(),
-                                           this);
+    overview_ = WindowOverviewMode::Create(
+        container_.get(), window_list_provider_.get(), this);
   } else {
+    CHECK(!split_view_controller_->IsSplitViewModeActive());
     overview_.reset();
     FOR_EACH_OBSERVER(WindowManagerObserver, observers_,
                       OnOverviewModeExit());
@@ -209,7 +212,6 @@ void WindowManagerImpl::RemoveObserver(WindowManagerObserver* observer) {
 }
 
 void WindowManagerImpl::OnSelectWindow(aura::Window* window) {
-  mru_window_tracker_->MoveToFront(window);
   wm::ActivateWindow(window);
   SetInOverview(false);
 }