Keep the split view activities topmost in z-order in Athena

athena/wm/split_view_controller_unittest.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/wm/split_view_controller.h"
 
 #include "athena/screen/public/screen_manager.h"
 #include "athena/test/athena_test_base.h"
 #include "athena/wm/public/window_list_provider.h"
 #include "athena/wm/test/window_manager_impl_test_api.h"
@@ skipping 14 matching lines @@
   virtual void SetUp() OVERRIDE {
     test::AthenaTestBase::SetUp();
     api_.reset(new test::WindowManagerImplTestApi);
   }
 
   virtual void TearDown() OVERRIDE {
     api_.reset();
     test::AthenaTestBase::TearDown();
   }
 
+  // Returns whether the split view windows are topmost.
+  bool SplitViewWindowsTopmost() const {
+    SplitViewController* controller = api_->GetSplitViewController();
+    DCHECK(controller->IsSplitViewModeActive());
+    aura::Window::Windows list =
+        api_->GetWindowListProvider()->GetWindowList();
+    aura::Window* topmost = *list.rbegin();
+    aura::Window* second_topmost = *(list.rbegin() + 1);
+    return (topmost == controller->left_window() ||
+            topmost == controller->right_window()) &&
+           (second_topmost == controller->left_window() ||
+            second_topmost == controller->right_window());
+  }
+
   bool IsSplitViewAllowed() const {
     return api_->GetSplitViewController()->CanScroll();
   }
 
   test::WindowManagerImplTestApi* api() {
     return api_.get();
   }
 
  private:
   scoped_ptr<test::WindowManagerImplTestApi> api_;
 
   DISALLOW_COPY_AND_ASSIGN(SplitViewControllerTest);
 };
 
 // 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) {
     scoped_ptr<aura::Window> window = CreateTestWindow(NULL, gfx::Rect());
     windows.push_back(window.release());
   }
 
   SplitViewController* controller = api()->GetSplitViewController();
-  WindowListProvider* list_provider = api()->GetWindowListProvider();
   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());
+  EXPECT_TRUE(SplitViewWindowsTopmost());
 
   // 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());
+  EXPECT_TRUE(SplitViewWindowsTopmost());
 
   controller->ActivateSplitMode(windows[kNumWindows - 1], NULL);
   EXPECT_EQ(windows[kNumWindows - 1], controller->left_window());
   EXPECT_EQ(windows[kNumWindows - 2], controller->right_window());
+  EXPECT_TRUE(SplitViewWindowsTopmost());
 
   // 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());
+  EXPECT_TRUE(SplitViewWindowsTopmost());
 
   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_TRUE(SplitViewWindowsTopmost());
 
   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_TRUE(SplitViewWindowsTopmost());

[pkotwicz, 2014/09/11 17:26:15]

The tests happen to pass without the changes in this CL in
split_view_controller.cc
However, SplitViewController::ActivateSplitMode() did not guarantee that the
split view windows were the topmost windows.

e.g. Calling controller->ActivateSplitMode(windows[0], NULL) after line 111
would have not resulted in the split view windows being topmost.

[sadrul, 2014/09/12 04:32:29]

Can you add that test-case here?

[oshima, 2014/09/12 18:48:41]

You probably missed this?

 }
 
 TEST_F(SplitViewControllerTest, LandscapeOnly) {
   aura::test::TestWindowDelegate delegate;
   ScopedVector<aura::Window> windows;
   const int kNumWindows = 2;
   for (size_t i = 0; i < kNumWindows; ++i) {
     scoped_ptr<aura::Window> window = CreateTestWindow(NULL, gfx::Rect());
     windows.push_back(window.release());
   }
@@ skipping 20 matching lines @@
   // Entering splitview should now be disabled now that the screen is in a
   // portrait orientation.
   EXPECT_FALSE(IsSplitViewAllowed());
 
   // Rotating back to 0 allows splitview again.
   ScreenManager::Get()->SetRotation(gfx::Display::ROTATE_0);
   EXPECT_TRUE(IsSplitViewAllowed());
 }
 
 }  // namespace athena