src/athena/wm/split_view_controller_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "athena/wm/split_view_controller.h"
   6
   7 #include "athena/screen/public/screen_manager.h"
   8 #include "athena/test/athena_test_base.h"
   9 #include "athena/wm/public/window_list_provider.h"
  10 #include "athena/wm/test/window_manager_impl_test_api.h"
  11 #include "base/memory/scoped_vector.h"
  12 #include "ui/aura/test/test_window_delegate.h"
  13 #include "ui/aura/window.h"
  14 #include "ui/gfx/display.h"
  15 #include "ui/gfx/screen.h"
  16 #include "ui/wm/core/window_util.h"
  17
  18 namespace athena {
  19
  20 class SplitViewControllerTest : public test::AthenaTestBase {
  21  public:
  22   SplitViewControllerTest() {}
  23   virtual ~SplitViewControllerTest() {}
  24
  25   // test::AthenaTestBase:
  26   virtual void SetUp() OVERRIDE {
  27     test::AthenaTestBase::SetUp();
  28     api_.reset(new test::WindowManagerImplTestApi);
  29   }
  30
  31   virtual void TearDown() OVERRIDE {
  32     api_.reset();
  33     test::AthenaTestBase::TearDown();
  34   }
  35
  36   // Returns the topmost window in z-order.
  37   const aura::Window* GetTopmostWindow() const {
  38     return *api_->GetWindowListProvider()->GetWindowList().rbegin();
  39   }
  40
  41   // Returns the second topmost window in z-order.
  42   const aura::Window* GetSecondTopmostWindow() const {
  43     const aura::Window::Windows& list =
  44         api_->GetWindowListProvider()->GetWindowList();
  45     return *(list.rbegin() + 1);
  46   }
  47
  48   // Returns whether only the split view windows are visible.
  49   bool OnlySplitViewWindowsVisible() const {
  50     SplitViewController* controller = api_->GetSplitViewController();
  51     DCHECK(controller->IsSplitViewModeActive());
  52     aura::Window::Windows list =
  53         api_->GetWindowListProvider()->GetWindowList();
  54     for (aura::Window::Windows::const_iterator it = list.begin();
  55          it != list.end(); ++it) {
  56       bool in_split_view = (*it == controller->left_window() ||
  57                             *it == controller->right_window());
  58       if (in_split_view != (*it)->IsVisible())
  59         return false;
  60     }
  61     return true;
  62   }
  63
  64   bool IsSplitViewAllowed() const {
  65     return api_->GetSplitViewController()->CanActivateSplitViewMode();
  66   }
  67
  68   test::WindowManagerImplTestApi* api() {
  69     return api_.get();
  70   }
  71
  72  private:
  73   scoped_ptr<test::WindowManagerImplTestApi> api_;
  74
  75   DISALLOW_COPY_AND_ASSIGN(SplitViewControllerTest);
  76 };
  77
  78 // Tests that when split mode is activated, the windows on the left and right
  79 // are selected correctly.
  80 TEST_F(SplitViewControllerTest, SplitModeActivation) {
  81   aura::test::TestWindowDelegate delegate;
  82   ScopedVector<aura::Window> windows;
  83   const int kNumWindows = 6;
  84   for (size_t i = 0; i < kNumWindows; ++i) {
  85     scoped_ptr<aura::Window> window = CreateTestWindow(NULL, gfx::Rect());
  86     windows.push_back(window.release());
  87     windows[i]->Hide();
  88   }
  89
  90   windows[kNumWindows - 1]->Show();
  91   wm::ActivateWindow(windows[kNumWindows - 1]);
  92
  93   SplitViewController* controller = api()->GetSplitViewController();
  94   ASSERT_FALSE(controller->IsSplitViewModeActive());
  95
  96   controller->ActivateSplitMode(NULL, NULL, NULL);
  97   ASSERT_TRUE(controller->IsSplitViewModeActive());
  98   // The last two windows should be on the left and right, respectively.
  99   EXPECT_EQ(windows[kNumWindows - 1], controller->left_window());
 100   EXPECT_EQ(windows[kNumWindows - 2], controller->right_window());
 101   EXPECT_EQ(windows[kNumWindows - 1], GetTopmostWindow());
 102   EXPECT_EQ(windows[kNumWindows - 2], GetSecondTopmostWindow());
 103   EXPECT_TRUE(OnlySplitViewWindowsVisible());
 104
 105   // Select the window that is currently on the left for the right panel. The
 106   // windows should switch.
 107   controller->ActivateSplitMode(
 108       NULL, windows[kNumWindows - 1], windows[kNumWindows - 1]);
 109   EXPECT_EQ(windows[kNumWindows - 2], controller->left_window());
 110   EXPECT_EQ(windows[kNumWindows - 1], controller->right_window());
 111   EXPECT_EQ(windows[kNumWindows - 1], GetTopmostWindow());
 112   EXPECT_EQ(windows[kNumWindows - 2], GetSecondTopmostWindow());
 113   EXPECT_TRUE(OnlySplitViewWindowsVisible());
 114
 115   controller->ActivateSplitMode(
 116       windows[kNumWindows - 1], NULL, windows[kNumWindows - 1]);
 117   EXPECT_EQ(windows[kNumWindows - 1], controller->left_window());
 118   EXPECT_EQ(windows[kNumWindows - 2], controller->right_window());
 119   EXPECT_EQ(windows[kNumWindows - 1], GetTopmostWindow());
 120   EXPECT_EQ(windows[kNumWindows - 2], GetSecondTopmostWindow());
 121   EXPECT_TRUE(OnlySplitViewWindowsVisible());
 122
 123   // Select the same windows, but pass in a different window to activate.
 124   controller->ActivateSplitMode(windows[kNumWindows - 1],
 125                                 windows[kNumWindows - 2],
 126                                 windows[kNumWindows - 2]);
 127   EXPECT_EQ(windows[kNumWindows - 1], controller->left_window());
 128   EXPECT_EQ(windows[kNumWindows - 2], controller->right_window());
 129   EXPECT_EQ(windows[kNumWindows - 2], GetTopmostWindow());
 130   EXPECT_EQ(windows[kNumWindows - 1], GetSecondTopmostWindow());
 131   EXPECT_TRUE(OnlySplitViewWindowsVisible());
 132
 133   // Select one of the windows behind the stacks for the right panel. The window
 134   // on the left should remain unchanged.
 135   controller->ActivateSplitMode(NULL, windows[0], windows[0]);
 136   EXPECT_EQ(windows[kNumWindows - 1], controller->left_window());
 137   EXPECT_EQ(windows[0], controller->right_window());
 138   EXPECT_EQ(windows[0], GetTopmostWindow());
 139   EXPECT_EQ(windows[kNumWindows - 1], GetSecondTopmostWindow());
 140   EXPECT_TRUE(OnlySplitViewWindowsVisible());
 141
 142   controller->ActivateSplitMode(windows[1], NULL, NULL);
 143   EXPECT_EQ(windows[1], controller->left_window());
 144   EXPECT_EQ(windows[0], controller->right_window());
 145   EXPECT_EQ(windows[0], GetTopmostWindow());
 146   EXPECT_EQ(windows[1], GetSecondTopmostWindow());
 147   EXPECT_TRUE(OnlySplitViewWindowsVisible());
 148
 149   controller->ActivateSplitMode(windows[4], windows[5], windows[5]);
 150   EXPECT_EQ(windows[4], controller->left_window());
 151   EXPECT_EQ(windows[5], controller->right_window());
 152   EXPECT_EQ(windows[5], GetTopmostWindow());
 153   EXPECT_EQ(windows[4], GetSecondTopmostWindow());
 154   EXPECT_TRUE(OnlySplitViewWindowsVisible());
 155
 156   controller->ActivateSplitMode(windows[0], NULL, windows[0]);
 157   EXPECT_EQ(windows[0], controller->left_window());
 158   EXPECT_EQ(windows[5], controller->right_window());
 159   EXPECT_EQ(windows[0], GetTopmostWindow());
 160   EXPECT_EQ(windows[5], GetSecondTopmostWindow());
 161   EXPECT_TRUE(OnlySplitViewWindowsVisible());
 162 }
 163
 164 TEST_F(SplitViewControllerTest, LandscapeOnly) {
 165   aura::test::TestWindowDelegate delegate;
 166   ScopedVector<aura::Window> windows;
 167   const int kNumWindows = 2;
 168   for (size_t i = 0; i < kNumWindows; ++i) {
 169     scoped_ptr<aura::Window> window = CreateTestWindow(NULL, gfx::Rect());
 170     window->Hide();
 171     windows.push_back(window.release());
 172   }
 173   windows[kNumWindows - 1]->Show();
 174   wm::ActivateWindow(windows[kNumWindows - 1]);
 175
 176   ASSERT_EQ(gfx::Display::ROTATE_0,
 177             gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().rotation());
 178
 179   SplitViewController* controller = api()->GetSplitViewController();
 180   ASSERT_TRUE(IsSplitViewAllowed());
 181   ASSERT_FALSE(controller->IsSplitViewModeActive());
 182
 183   controller->ActivateSplitMode(NULL, NULL, NULL);
 184   ASSERT_TRUE(controller->IsSplitViewModeActive());
 185
 186   // Screen rotation should be locked while in splitview.
 187   ScreenManager::Get()->SetRotation(gfx::Display::ROTATE_90);
 188   EXPECT_EQ(gfx::Display::ROTATE_0,
 189             gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().rotation());
 190
 191   // Screen is rotated on exiting splitview.
 192   controller->DeactivateSplitMode();
 193   ASSERT_EQ(gfx::Display::ROTATE_90,
 194             gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().rotation());
 195
 196   // Entering splitview should now be disabled now that the screen is in a
 197   // portrait orientation.
 198   EXPECT_FALSE(IsSplitViewAllowed());
 199
 200   // Rotating back to 0 allows splitview again.
 201   ScreenManager::Get()->SetRotation(gfx::Display::ROTATE_0);
 202   EXPECT_TRUE(IsSplitViewAllowed());
 203 }
 204
 205 }  // namespace athena