athena: Add a test for split-view controller.

The coverage is for ActivateSplitMode() to make sure that it selects the correct
windows when at least one of the params is NULL.

BUG=383421, 403945
R=oshima@chromium.org

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

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

5 files changed, 122 insertions, 11 deletions

diff --git a/athena/athena.gyp b/athena/athena.gyp
index 2286399..343a6e8 100644
--- a/athena/athena.gyp
+++ b/athena/athena.gyp
@@ -175,6 +175,7 @@
         'home/home_card_unittest.cc',
         'input/accelerator_manager_unittest.cc',
         'screen/screen_manager_unittest.cc',
+        'wm/split_view_controller_unittest.cc',
         'wm/window_manager_unittest.cc',
       ],
     }
diff --git a/athena/wm/DEPS b/athena/wm/DEPS
index 2777ab4..aa13df1 100644
--- a/athena/wm/DEPS
+++ b/athena/wm/DEPS
@@ -1,4 +1,5 @@
 include_rules = [
+  "+athena/athena_export.h",
   "+athena/common",
   "+athena/input/public",
   "+athena/resources",
diff --git a/athena/wm/split_view_controller.cc b/athena/wm/split_view_controller.cc
index 9e8984a..997c107 100644
--- a/athena/wm/split_view_controller.cc
+++ b/athena/wm/split_view_controller.cc
@@ -32,11 +32,13 @@ SplitViewController::SplitViewController(
       right_window_(NULL),
       separator_position_(0),
       weak_factory_(this) {
-  window_manager->AddObserver(this);
+  if (window_manager_)
+    window_manager_->AddObserver(this);
 }
 
 SplitViewController::~SplitViewController() {
-  window_manager_->RemoveObserver(this);
+  if (window_manager_)
+    window_manager_->RemoveObserver(this);
 }
 
 bool SplitViewController::IsSplitViewModeActive() const {
@@ -48,6 +50,11 @@ void SplitViewController::ActivateSplitMode(aura::Window* left,
   aura::Window::Windows windows = window_list_provider_->GetWindowList();
   aura::Window::Windows::reverse_iterator iter = windows.rbegin();
   if (state_ == ACTIVE) {
+    if (left_window_ == right)
+      left_window_ = left;
+    if (right_window_ == left)
+      right_window_ = right;
+
     if (!left)
       left = left_window_;
     if (!right)
@@ -73,10 +80,14 @@ void SplitViewController::ActivateSplitMode(aura::Window* left,
   }
 
   state_ = ACTIVE;
-  left_window_ = left;
-  right_window_ = right;
-  container_->StackChildAtTop(right_window_);
-  container_->StackChildAtTop(left_window_);
+  if (right_window_ != right) {
+    right_window_ = right;
+    container_->StackChildAtTop(right_window_);
+  }
+  if (left_window_ != left) {
+    left_window_ = left;
+    container_->StackChildAtTop(left_window_);
+  }
   UpdateLayout(true);
 }
 
@@ -256,7 +267,7 @@ void SplitViewController::ScrollUpdate(float delta) {
 
 bool SplitViewController::CanScroll() {
   // TODO(mfomitchev): return false in vertical orientation, in full screen.
-  bool result = (!window_manager_->IsOverviewModeActive() &&
+  bool result = (window_manager_ && !window_manager_->IsOverviewModeActive() &&
                  !IsSplitViewModeActive() &&
                  window_list_provider_->GetWindowList().size() >= 2);
   return result;
diff --git a/athena/wm/split_view_controller.h b/athena/wm/split_view_controller.h
index d7dc20c..2e5d0ce0 100644
--- a/athena/wm/split_view_controller.h
+++ b/athena/wm/split_view_controller.h
@@ -5,6 +5,7 @@
 #ifndef ATHENA_WM_SPLIT_VIEW_CONTROLLER_H_
 #define ATHENA_WM_SPLIT_VIEW_CONTROLLER_H_
 
+#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"
@@ -22,8 +23,9 @@ class WindowOverviewModeDelegate;
 
 // Responsible for entering split view mode, exiting from split view mode, and
 // laying out the windows in split view mode.
-class SplitViewController : public BezelController::ScrollDelegate,
-                            public WindowManagerObserver {
+class ATHENA_EXPORT SplitViewController
+    : public BezelController::ScrollDelegate,
+    public WindowManagerObserver {
  public:
   SplitViewController(aura::Window* container,
                       WindowListProvider* window_list_provider,
@@ -38,6 +40,9 @@ class SplitViewController : public BezelController::ScrollDelegate,
   // |left| nor |right|) is selected instead.
   void ActivateSplitMode(aura::Window* left, aura::Window* right);
 
+  aura::Window* left_window() { return left_window_; }
+  aura::Window* right_window() { return right_window_; }
+
  private:
   enum State {
     // Split View mode is not active. |left_window_| and |right_window| are
@@ -81,8 +86,9 @@ class SplitViewController : public BezelController::ScrollDelegate,
 
   aura::Window* container_;
 
-  // Window Manager which owns this SplitViewController.
-  // Must be non NULL for the duration of the lifetime.
+  // 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.
diff --git a/athena/wm/split_view_controller_unittest.cc b/athena/wm/split_view_controller_unittest.cc
new file mode 100644
index 0000000..36b244c
--- /dev/null
+++ b/athena/wm/split_view_controller_unittest.cc
@@ -0,0 +1,92 @@
+// 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/split_view_controller.h"
+
+#include "athena/common/fill_layout_manager.h"
+#include "athena/test/athena_test_base.h"
+#include "athena/wm/public/window_list_provider.h"
+#include "base/memory/scoped_vector.h"
+#include "ui/aura/test/test_window_delegate.h"
+#include "ui/aura/window.h"
+
+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) {
+  aura::test::TestWindowDelegate delegate;
+  ScopedVector<aura::Window> windows;
+  const int kNumWindows = 6;
+  for (size_t i = 0; i < kNumWindows; ++i) {
+    aura::Window* window = new aura::Window(&delegate);
+    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);
+  ASSERT_FALSE(controller.IsSplitViewModeActive());
+
+  controller.ActivateSplitMode(NULL, NULL);
+  ASSERT_TRUE(controller.IsSplitViewModeActive());
+  // The last two windows should be on the left and right, respectively.
+  EXPECT_EQ(windows[kNumWindows - 1], controller.left_window());
+  EXPECT_EQ(windows[kNumWindows - 2], controller.right_window());
+
+  // Select the window that is currently on the left for the right panel. The
+  // windows should switch.
+  controller.ActivateSplitMode(NULL, windows[kNumWindows - 1]);
+  EXPECT_EQ(windows[kNumWindows - 2], controller.left_window());
+  EXPECT_EQ(windows[kNumWindows - 1], controller.right_window());
+
+  controller.ActivateSplitMode(windows[kNumWindows - 1], NULL);
+  EXPECT_EQ(windows[kNumWindows - 1], controller.left_window());
+  EXPECT_EQ(windows[kNumWindows - 2], controller.right_window());
+
+  // Select one of the windows behind the stacks for the right panel. The window
+  // on the left should remain unchanged.
+  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());
+
+  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());
+
+  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));
+}
+
+}  // namespace athena