Fix crash when dragging a half width window to split view from overview mode

BUG=405957
TEST=SplitViewControllerTest.SplitModeActivation

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

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

7 files changed, 182 insertions, 105 deletions

diff --git a/athena/wm/split_view_controller.cc b/athena/wm/split_view_controller.cc
index 6e4a1c3..e36b7a9 100644
--- a/athena/wm/split_view_controller.cc
+++ b/athena/wm/split_view_controller.cc
@@ -20,6 +20,21 @@
 
 namespace athena {
 
+namespace {
+
+// Returns a target transform which is suitable for animating a windows's
+// bounds.
+gfx::Transform GetTargetTransformForBoundsAnimation(const gfx::Rect& from,
+                                                    const gfx::Rect& to) {
+  gfx::Transform transform;
+  transform.Translate(to.x() - from.x(), to.y() - from.y());
+  transform.Scale(to.width() / static_cast<float>(from.width()),
+                  to.height() / static_cast<float>(from.height()));
+  return transform;
+}
+
+}  // namespace
+
 SplitViewController::SplitViewController(
     aura::Window* container,
     WindowListProvider* window_list_provider)
@@ -113,6 +128,20 @@ void SplitViewController::DeactivateSplitMode() {
   left_window_ = right_window_ = NULL;
 }
 
+gfx::Rect SplitViewController::GetLeftTargetBounds() {
+  gfx::Rect work_area =
+      gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().work_area();
+  return gfx::Rect(0, 0, container_->bounds().width() / 2, work_area.height());
+}
+
+gfx::Rect SplitViewController::GetRightTargetBounds() {
+  gfx::Rect work_area =
+      gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().work_area();
+  int container_width = container_->bounds().width();
+  return gfx::Rect(
+      container_width / 2, 0, container_width / 2, work_area.height());
+}
+
 void SplitViewController::UpdateLayout(bool animate) {
   if  (!left_window_)
     return;
@@ -121,19 +150,16 @@ void SplitViewController::UpdateLayout(bool animate) {
   gfx::Transform right_transform;
   int container_width = container_->GetBoundsInScreen().width();
   if (state_ == ACTIVE) {
-    // This method should only be called once in ACTIVE state when
-    // the left and rightwindows are still full screen and need to be resized.
-    CHECK_EQ(left_window_->bounds().width(), container_width);
-    CHECK_EQ(right_window_->bounds().width(), container_width);
     // Windows should be resized via an animation when entering the ACTIVE
     // state.
     CHECK(animate);
     // We scale the windows here, but when the animation finishes, we reset
     // the scaling and update the window bounds to the proper size - see
     // OnAnimationCompleted().
-    left_transform.Scale(.5, 1);
-    right_transform.Scale(.5, 1);
-    right_transform.Translate(container_width, 0);
+    left_transform = GetTargetTransformForBoundsAnimation(
+        left_window_->bounds(), GetLeftTargetBounds());
+    right_transform = GetTargetTransformForBoundsAnimation(
+        right_window_->bounds(), GetRightTargetBounds());
   } else {
     left_transform.Translate(separator_position_ - container_width, 0);
     right_transform.Translate(separator_position_, 0);
@@ -168,16 +194,11 @@ void SplitViewController::OnAnimationCompleted(aura::Window* window) {
     return;
   DCHECK(window == left_window_ || window == right_window_);
   if (state_ == ACTIVE) {
-    int container_width = container_->bounds().width();
-    gfx::Display display = gfx::Screen::GetNativeScreen()->GetPrimaryDisplay();
-    gfx::Rect window_bounds(container_width / 2, display.work_area().height());
     window->SetTransform(gfx::Transform());
-    if (window == left_window_) {
-      left_window_->SetBounds(window_bounds);
-    } else {
-      window_bounds.set_x(container_width / 2);
-      right_window_->SetBounds(window_bounds);
-    }
+    if (window == left_window_)
+      left_window_->SetBounds(GetLeftTargetBounds());
+    else
+      right_window_->SetBounds(GetRightTargetBounds());
   } else {
     int container_width = container_->bounds().width();
     window->SetTransform(gfx::Transform());
diff --git a/athena/wm/split_view_controller.h b/athena/wm/split_view_controller.h
index 8d8db77..d0e7073 100644
--- a/athena/wm/split_view_controller.h
+++ b/athena/wm/split_view_controller.h
@@ -11,6 +11,7 @@
 #include "base/memory/weak_ptr.h"
 
 namespace gfx {
+class Rect;
 class Transform;
 }
 
@@ -42,6 +43,13 @@ class ATHENA_EXPORT SplitViewController
   void ReplaceWindow(aura::Window* window,
                      aura::Window* replace_with);
 
+  // Returns the bounds that the left and right windows will have once split
+  // view is active and they are done animating. If |left_window_| and
+  // |right_window_| are still animating this may be different than their
+  // current bounds.
+  gfx::Rect GetLeftTargetBounds();
+  gfx::Rect GetRightTargetBounds();
+
   aura::Window* left_window() { return left_window_; }
   aura::Window* right_window() { return right_window_; }
 
diff --git a/athena/wm/split_view_controller_unittest.cc b/athena/wm/split_view_controller_unittest.cc
index 268a3ac..04eddc5 100644
--- a/athena/wm/split_view_controller_unittest.cc
+++ b/athena/wm/split_view_controller_unittest.cc
@@ -4,9 +4,9 @@
 
 #include "athena/wm/split_view_controller.h"
 
-#include "athena/common/fill_layout_manager.h"
 #include "athena/test/athena_test_base.h"
-#include "athena/wm/window_list_provider_impl.h"
+#include "athena/wm/public/window_list_provider.h"
+#include "athena/wm/test/window_manager_impl_test_api.h"
 #include "base/memory/scoped_vector.h"
 #include "ui/aura/test/test_window_delegate.h"
 #include "ui/aura/window.h"
@@ -22,49 +22,46 @@ TEST_F(SplitViewControllerTest, SplitModeActivation) {
   ScopedVector<aura::Window> windows;
   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);
+    scoped_ptr<aura::Window> window = CreateTestWindow(NULL, gfx::Rect());
+    windows.push_back(window.release());
   }
 
-  scoped_ptr<WindowListProvider> list_provider(
-      new WindowListProviderImpl(root_window()));
-  SplitViewController controller(root_window(), list_provider.get());
-  ASSERT_FALSE(controller.IsSplitViewModeActive());
+  test::WindowManagerImplTestApi api;
+  SplitViewController* controller = api.GetSplitViewController();
+  WindowListProvider* list_provider = api.GetWindowListProvider();
+  ASSERT_FALSE(controller->IsSplitViewModeActive());
 
-  controller.ActivateSplitMode(NULL, NULL);
-  ASSERT_TRUE(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_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(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());
+  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());
+  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());
+  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());
+  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));
 }
diff --git a/athena/wm/test/window_manager_impl_test_api.cc b/athena/wm/test/window_manager_impl_test_api.cc
new file mode 100644
index 0000000..51296c4
--- /dev/null
+++ b/athena/wm/test/window_manager_impl_test_api.cc
@@ -0,0 +1,29 @@
+// 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/test/window_manager_impl_test_api.h"
+
+#include "athena/wm/window_manager_impl.h"
+
+namespace athena {
+namespace test {
+
+WindowManagerImplTestApi::WindowManagerImplTestApi()
+    : wm_(static_cast<WindowManagerImpl*>(WindowManager::GetInstance())) {
+}
+
+WindowManagerImplTestApi::~WindowManagerImplTestApi() {
+}
+
+athena::WindowListProvider* WindowManagerImplTestApi::GetWindowListProvider() {
+  return wm_->window_list_provider_.get();
+}
+
+athena::SplitViewController*
+WindowManagerImplTestApi::GetSplitViewController() {
+  return wm_->split_view_controller_.get();
+}
+
+}  // namespace test
+}  // namespace athena
diff --git a/athena/wm/test/window_manager_impl_test_api.h b/athena/wm/test/window_manager_impl_test_api.h
new file mode 100644
index 0000000..1876df3
--- /dev/null
+++ b/athena/wm/test/window_manager_impl_test_api.h
@@ -0,0 +1,34 @@
+// 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_TEST_WINDOW_MANAGER_IMPL_TEST_API_H_
+#define ATHENA_WM_TEST_WINDOW_MANAGER_IMPL_TEST_API_H_
+
+#include "base/macros.h"
+
+namespace athena {
+class SplitViewController;
+class WindowListProvider;
+class WindowManagerImpl;
+
+namespace test {
+
+class WindowManagerImplTestApi {
+ public:
+  WindowManagerImplTestApi();
+  ~WindowManagerImplTestApi();
+
+  athena::WindowListProvider* GetWindowListProvider();
+  athena::SplitViewController* GetSplitViewController();
+
+ private:
+  athena::WindowManagerImpl* wm_;
+
+  DISALLOW_COPY_AND_ASSIGN(WindowManagerImplTestApi);
+};
+
+}  // namespace test
+}  // namespace athena
+
+#endif  // ATHENA_WM_TEST_WINDOW_MANAGER_IMPL_TEST_API_H_
diff --git a/athena/wm/window_manager_impl.h b/athena/wm/window_manager_impl.h
index c8e9038..f5d0ae9a 100644
--- a/athena/wm/window_manager_impl.h
+++ b/athena/wm/window_manager_impl.h
@@ -20,6 +20,10 @@ class WMState;
 
 namespace athena {
 
+namespace test {
+class WindowManagerImplTestApi;
+}
+
 class BezelController;
 class SplitViewController;
 class WindowListProvider;
@@ -39,7 +43,7 @@ class WindowManagerImpl : public WindowManager,
   virtual bool IsOverviewModeActive() OVERRIDE;
 
  private:
-  friend class WindowManagerImplTestApi;
+  friend class test::WindowManagerImplTestApi;
   friend class AthenaContainerLayoutManager;
 
   enum Command {
diff --git a/athena/wm/window_manager_unittest.cc b/athena/wm/window_manager_unittest.cc
index b4cddf3..8a331ca 100644
--- a/athena/wm/window_manager_unittest.cc
+++ b/athena/wm/window_manager_unittest.cc
@@ -8,6 +8,7 @@
 #include "athena/test/athena_test_base.h"
 #include "athena/wm/public/window_list_provider.h"
 #include "athena/wm/split_view_controller.h"
+#include "athena/wm/test/window_manager_impl_test_api.h"
 #include "athena/wm/window_manager_impl.h"
 #include "ui/aura/client/window_tree_client.h"
 #include "ui/aura/test/test_window_delegate.h"
@@ -32,28 +33,6 @@ scoped_ptr<aura::Window> CreateWindow(aura::WindowDelegate* delegate) {
 
 namespace athena {
 
-class WindowManagerImplTestApi {
- public:
-  WindowManagerImplTestApi()
-      : wm_(static_cast<WindowManagerImpl*>(WindowManager::GetInstance())) {}
-  ~WindowManagerImplTestApi() {}
-
-  WindowManager* wm() { return wm_; }
-
-  WindowListProvider* window_list_provider() {
-    return wm_->window_list_provider_.get();
-  }
-
-  SplitViewController* split_view_controller() {
-    return wm_->split_view_controller_.get();
-  }
-
- private:
-  WindowManagerImpl* wm_;
-
-  DISALLOW_COPY_AND_ASSIGN(WindowManagerImplTestApi);
-};
-
 typedef test::AthenaTestBase WindowManagerTest;
 
 TEST_F(WindowManagerTest, Empty) {
@@ -64,13 +43,13 @@ TEST_F(WindowManagerTest, OverviewModeBasics) {
   scoped_ptr<aura::Window> first(CreateWindow(&delegate));
   scoped_ptr<aura::Window> second(CreateWindow(&delegate));
 
-  WindowManagerImplTestApi wm_api;
+  test::WindowManagerImplTestApi wm_api;
   aura::client::ParentWindowWithContext(
       first.get(), ScreenManager::Get()->GetContext(), gfx::Rect());
   aura::client::ParentWindowWithContext(
       second.get(), ScreenManager::Get()->GetContext(), gfx::Rect());
 
-  ASSERT_FALSE(wm_api.wm()->IsOverviewModeActive());
+  ASSERT_FALSE(WindowManager::GetInstance()->IsOverviewModeActive());
   EXPECT_EQ(first->bounds().ToString(), second->bounds().ToString());
   EXPECT_EQ(gfx::Screen::GetNativeScreen()
                 ->GetPrimaryDisplay()
@@ -78,11 +57,11 @@ TEST_F(WindowManagerTest, OverviewModeBasics) {
                 .size()
                 .ToString(),
             first->bounds().size().ToString());
-  EXPECT_FALSE(wm_api.wm()->IsOverviewModeActive());
+  EXPECT_FALSE(WindowManager::GetInstance()->IsOverviewModeActive());
 
   // Tests that going into overview mode does not change the window bounds.
-  wm_api.wm()->ToggleOverview();
-  ASSERT_TRUE(wm_api.wm()->IsOverviewModeActive());
+  WindowManager::GetInstance()->ToggleOverview();
+  ASSERT_TRUE(WindowManager::GetInstance()->IsOverviewModeActive());
   EXPECT_EQ(first->bounds().ToString(), second->bounds().ToString());
   EXPECT_EQ(gfx::Screen::GetNativeScreen()
                 ->GetPrimaryDisplay()
@@ -98,7 +77,7 @@ TEST_F(WindowManagerTest, BezelGestureToSplitViewMode) {
   scoped_ptr<aura::Window> second(CreateWindow(&delegate));
   scoped_ptr<aura::Window> third(CreateWindow(&delegate));
 
-  WindowManagerImplTestApi wm_api;
+  test::WindowManagerImplTestApi wm_api;
   aura::client::ParentWindowWithContext(
       first.get(), ScreenManager::Get()->GetContext(), gfx::Rect());
   aura::client::ParentWindowWithContext(
@@ -116,9 +95,9 @@ TEST_F(WindowManagerTest, BezelGestureToSplitViewMode) {
   int x_middle = root_window()->bounds().width() / 2;
   generator.GestureMultiFingerScroll(
       2, start_points, kEventTimeSepration, 1, x_middle, 0);
-  ASSERT_TRUE(wm_api.split_view_controller()->IsSplitViewModeActive());
-  EXPECT_EQ(second.get(), wm_api.split_view_controller()->left_window());
-  EXPECT_EQ(third.get(), wm_api.split_view_controller()->right_window());
+  ASSERT_TRUE(wm_api.GetSplitViewController()->IsSplitViewModeActive());
+  EXPECT_EQ(second.get(), wm_api.GetSplitViewController()->left_window());
+  EXPECT_EQ(third.get(), wm_api.GetSplitViewController()->right_window());
   EXPECT_EQ(second->bounds().size().ToString(),
             third->bounds().size().ToString());
 }
@@ -129,7 +108,7 @@ TEST_F(WindowManagerTest, BezelGestureToSwitchBetweenWindows) {
   scoped_ptr<aura::Window> second(CreateWindow(&delegate));
   scoped_ptr<aura::Window> third(CreateWindow(&delegate));
 
-  WindowManagerImplTestApi wm_api;
+  test::WindowManagerImplTestApi wm_api;
   aura::client::ParentWindowWithContext(
       first.get(), ScreenManager::Get()->GetContext(), gfx::Rect());
   aura::client::ParentWindowWithContext(
@@ -137,7 +116,8 @@ TEST_F(WindowManagerTest, BezelGestureToSwitchBetweenWindows) {
   aura::client::ParentWindowWithContext(
       third.get(), ScreenManager::Get()->GetContext(), gfx::Rect());
 
-  EXPECT_EQ(third.get(), wm_api.window_list_provider()->GetWindowList().back());
+  EXPECT_EQ(third.get(),
+            wm_api.GetWindowListProvider()->GetWindowList().back());
 
   // Do a two-finger swipe from the left bezel.
   ui::test::EventGenerator generator(root_window());
@@ -150,7 +130,7 @@ TEST_F(WindowManagerTest, BezelGestureToSwitchBetweenWindows) {
       2, left_bezel_points, kEventTimeSepration, 1, width, 0);
   EXPECT_TRUE(wm::IsActiveWindow(second.get()));
   EXPECT_EQ(second.get(),
-            wm_api.window_list_provider()->GetWindowList().back());
+            wm_api.GetWindowListProvider()->GetWindowList().back());
 }
 
 TEST_F(WindowManagerTest, TitleDragSwitchBetweenWindows) {
@@ -160,7 +140,7 @@ TEST_F(WindowManagerTest, TitleDragSwitchBetweenWindows) {
   scoped_ptr<aura::Window> second(CreateWindow(&delegate));
   scoped_ptr<aura::Window> third(CreateWindow(&delegate));
 
-  WindowManagerImplTestApi wm_api;
+  test::WindowManagerImplTestApi wm_api;
   aura::client::ParentWindowWithContext(
       first.get(), ScreenManager::Get()->GetContext(), gfx::Rect());
   aura::client::ParentWindowWithContext(
@@ -168,7 +148,8 @@ TEST_F(WindowManagerTest, TitleDragSwitchBetweenWindows) {
   aura::client::ParentWindowWithContext(
       third.get(), ScreenManager::Get()->GetContext(), gfx::Rect());
 
-  EXPECT_EQ(third.get(), wm_api.window_list_provider()->GetWindowList().back());
+  EXPECT_EQ(third.get(),
+            wm_api.GetWindowListProvider()->GetWindowList().back());
 
   // Do a title-swipe from the top to switch to the previous window.
   ui::test::EventGenerator generator(root_window());
@@ -178,7 +159,7 @@ TEST_F(WindowManagerTest, TitleDragSwitchBetweenWindows) {
                                   5);
   EXPECT_TRUE(wm::IsActiveWindow(second.get()));
   EXPECT_EQ(second.get(),
-            wm_api.window_list_provider()->GetWindowList().back());
+            wm_api.GetWindowListProvider()->GetWindowList().back());
   EXPECT_TRUE(second->IsVisible());
   EXPECT_FALSE(third->IsVisible());
 
@@ -188,7 +169,8 @@ TEST_F(WindowManagerTest, TitleDragSwitchBetweenWindows) {
                                   base::TimeDelta::FromMilliseconds(20),
                                   5);
   EXPECT_TRUE(wm::IsActiveWindow(third.get()));
-  EXPECT_EQ(third.get(), wm_api.window_list_provider()->GetWindowList().back());
+  EXPECT_EQ(third.get(),
+            wm_api.GetWindowListProvider()->GetWindowList().back());
   EXPECT_FALSE(second->IsVisible());
   EXPECT_TRUE(third->IsVisible());
 
@@ -198,7 +180,8 @@ TEST_F(WindowManagerTest, TitleDragSwitchBetweenWindows) {
                                   base::TimeDelta::FromMilliseconds(20),
                                   5);
   EXPECT_TRUE(wm::IsActiveWindow(third.get()));
-  EXPECT_EQ(third.get(), wm_api.window_list_provider()->GetWindowList().back());
+  EXPECT_EQ(third.get(),
+            wm_api.GetWindowListProvider()->GetWindowList().back());
   EXPECT_FALSE(second->IsVisible());
   EXPECT_TRUE(third->IsVisible());
 }
@@ -211,7 +194,7 @@ TEST_F(WindowManagerTest, TitleDragSwitchBetweenWindowsInSplitViewMode) {
   scoped_ptr<aura::Window> third(CreateWindow(&delegate));
   scoped_ptr<aura::Window> fourth(CreateWindow(&delegate));
 
-  WindowManagerImplTestApi wm_api;
+  test::WindowManagerImplTestApi wm_api;
   aura::client::ParentWindowWithContext(
       first.get(), ScreenManager::Get()->GetContext(), gfx::Rect());
   aura::client::ParentWindowWithContext(
@@ -231,19 +214,19 @@ TEST_F(WindowManagerTest, TitleDragSwitchBetweenWindowsInSplitViewMode) {
   int x_middle = root_window()->bounds().width() / 2;
   generator.GestureMultiFingerScroll(
       2, start_points, kEventTimeSepration, 1, x_middle, 0);
-  ASSERT_TRUE(wm_api.split_view_controller()->IsSplitViewModeActive());
-  EXPECT_EQ(third.get(), wm_api.split_view_controller()->left_window());
-  EXPECT_EQ(fourth.get(), wm_api.split_view_controller()->right_window());
+  ASSERT_TRUE(wm_api.GetSplitViewController()->IsSplitViewModeActive());
+  EXPECT_EQ(third.get(), wm_api.GetSplitViewController()->left_window());
+  EXPECT_EQ(fourth.get(), wm_api.GetSplitViewController()->right_window());
 
   // Swipe the title of the left window. It should switch to |second|.
   generator.GestureScrollSequence(gfx::Point(20, 10),
                                   gfx::Point(20, 400),
                                   base::TimeDelta::FromMilliseconds(20),
                                   5);
-  EXPECT_EQ(second.get(), wm_api.split_view_controller()->left_window());
-  EXPECT_EQ(fourth.get(), wm_api.split_view_controller()->right_window());
+  EXPECT_EQ(second.get(), wm_api.GetSplitViewController()->left_window());
+  EXPECT_EQ(fourth.get(), wm_api.GetSplitViewController()->right_window());
   aura::Window::Windows windows =
-      wm_api.window_list_provider()->GetWindowList();
+      wm_api.GetWindowListProvider()->GetWindowList();
   ASSERT_EQ(4u, windows.size());
   EXPECT_EQ(second.get(), windows[3]);
   EXPECT_EQ(third.get(), windows[2]);
@@ -254,15 +237,15 @@ TEST_F(WindowManagerTest, TitleDragSwitchBetweenWindowsInSplitViewMode) {
                                   gfx::Point(x_middle + 20, 400),
                                   base::TimeDelta::FromMilliseconds(20),
                                   5);
-  EXPECT_EQ(second.get(), wm_api.split_view_controller()->left_window());
-  EXPECT_EQ(third.get(), wm_api.split_view_controller()->right_window());
+  EXPECT_EQ(second.get(), wm_api.GetSplitViewController()->left_window());
+  EXPECT_EQ(third.get(), wm_api.GetSplitViewController()->right_window());
 }
 
 TEST_F(WindowManagerTest, NewWindowBounds) {
   aura::test::TestWindowDelegate delegate;
   scoped_ptr<aura::Window> first(CreateWindow(&delegate));
 
-  WindowManagerImplTestApi wm_api;
+  test::WindowManagerImplTestApi wm_api;
   aura::client::ParentWindowWithContext(
       first.get(), ScreenManager::Get()->GetContext(), gfx::Rect());
   // The window should have the same size as the container.
@@ -279,25 +262,26 @@ TEST_F(WindowManagerTest, NewWindowBounds) {
   EXPECT_EQ(first->bounds().ToString(), second->bounds().ToString());
 
   // Get into split view.
-  wm_api.split_view_controller()->ActivateSplitMode(NULL, NULL);
+  wm_api.GetSplitViewController()->ActivateSplitMode(NULL, NULL);
   const gfx::Rect left_bounds =
-      wm_api.split_view_controller()->left_window()->bounds();
+      wm_api.GetSplitViewController()->left_window()->bounds();
   EXPECT_NE(work_area.ToString(),
             left_bounds.size().ToString());
 
   scoped_ptr<aura::Window> third(CreateWindow(&delegate));
   aura::client::ParentWindowWithContext(
       third.get(), ScreenManager::Get()->GetContext(), gfx::Rect());
-  EXPECT_NE(wm_api.split_view_controller()->left_window(), third.get());
+  EXPECT_NE(wm_api.GetSplitViewController()->left_window(), third.get());
   EXPECT_EQ(left_bounds.ToString(), third->bounds().ToString());
 
   third->Hide();
-  EXPECT_EQ(left_bounds.ToString(),
-            wm_api.split_view_controller()->left_window()->bounds().ToString());
+  EXPECT_EQ(
+      left_bounds.ToString(),
+      wm_api.GetSplitViewController()->left_window()->bounds().ToString());
 }
 
 TEST_F(WindowManagerTest, SplitModeActivationByShortcut) {
-  WindowManagerImplTestApi wm_api;
+  test::WindowManagerImplTestApi wm_api;
 
   aura::test::TestWindowDelegate delegate;
   scoped_ptr<aura::Window> w1(CreateTestWindow(&delegate, gfx::Rect()));
@@ -308,14 +292,14 @@ TEST_F(WindowManagerTest, SplitModeActivationByShortcut) {
   // Splitview mode needs at least two windows.
   generator.PressKey(ui::VKEY_F6, ui::EF_CONTROL_DOWN);
   generator.ReleaseKey(ui::VKEY_F6, ui::EF_CONTROL_DOWN);
-  EXPECT_FALSE(wm_api.split_view_controller()->IsSplitViewModeActive());
+  EXPECT_FALSE(wm_api.GetSplitViewController()->IsSplitViewModeActive());
 
   scoped_ptr<aura::Window> w2(CreateTestWindow(&delegate, gfx::Rect()));
   w2->Show();
 
   generator.PressKey(ui::VKEY_F6, ui::EF_CONTROL_DOWN);
   generator.ReleaseKey(ui::VKEY_F6, ui::EF_CONTROL_DOWN);
-  EXPECT_TRUE(wm_api.split_view_controller()->IsSplitViewModeActive());
+  EXPECT_TRUE(wm_api.GetSplitViewController()->IsSplitViewModeActive());
   int width =
       gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().work_area().width();
 
@@ -325,7 +309,7 @@ TEST_F(WindowManagerTest, SplitModeActivationByShortcut) {
   // Toggle back to normal mode.
   generator.PressKey(ui::VKEY_F6, ui::EF_CONTROL_DOWN);
   generator.ReleaseKey(ui::VKEY_F6, ui::EF_CONTROL_DOWN);
-  EXPECT_FALSE(wm_api.split_view_controller()->IsSplitViewModeActive());
+  EXPECT_FALSE(wm_api.GetSplitViewController()->IsSplitViewModeActive());
 
   EXPECT_EQ(width, w1->bounds().width());
   EXPECT_EQ(width, w2->bounds().width());