[Athena] Fix switching activities by swiping from the right bezel

BUG=414936
TEST=WindowManagertest.BezelGestureToSwitchBetweenWindows

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

Cr-Commit-Position: refs/heads/master@{#296548}

athena/wm/bezel_controller.cc

@@ -83,15 +83,21 @@ void BezelController::SetState(BezelController::State state,
   if (!left_right_delegate_ || state == state_)
     return;
 
-  if (state == BEZEL_SCROLLING_TWO_FINGERS)
-    left_right_delegate_->BezelScrollBegin(scroll_bezel_, scroll_delta);
-  else if (state_ == BEZEL_SCROLLING_TWO_FINGERS)
-    left_right_delegate_->BezelScrollEnd();
+  State old_state = state_;
   state_ = state;
+
   if (state == NONE) {
     scroll_bezel_ = BEZEL_NONE;
     scroll_target_ = NULL;
   }
+
+  if (state == BEZEL_SCROLLING_TWO_FINGERS) {
+    left_right_delegate_->BezelScrollBegin(scroll_bezel_, scroll_delta);
+  } else if (old_state == BEZEL_SCROLLING_TWO_FINGERS) {
+    // If BezelScrollEnd() hides |scroll_target_|, ET_GESTURE_END is dispatched
+    // and we get a reentrant call to SetState().
+    left_right_delegate_->BezelScrollEnd();
+  }
 }
 
 void BezelController::OnGestureEvent(ui::GestureEvent* event) {

athena/wm/public/window_list_provider.h

@@ -33,10 +33,6 @@ class ATHENA_EXPORT WindowListProvider {
   // WindowListProvider.
   virtual bool IsValidWindow(aura::Window* window) const = 0;
 
-  // Moves a given |window| to the front of all windows of the window list.
-  // Note: The window has to be in the list already.
-  virtual void MoveToFront(aura::Window* window) = 0;
-
   // Stacks a given |window| in direct front of a |reference_window|.
   // Note: The |window| and |reference_window| has to be in the list already.
   virtual void StackWindowFrontOf(aura::Window* window,

athena/wm/split_view_controller.cc

@@ -25,6 +25,7 @@
 #include "ui/views/widget/root_view_targeter.h"
 #include "ui/views/widget/widget.h"
 #include "ui/wm/core/window_util.h"
+#include "ui/wm/public/activation_client.h"
 
 namespace athena {
 
@@ -177,7 +178,8 @@ bool SplitViewController::IsSplitViewModeActive() const {
 }
 
 void SplitViewController::ActivateSplitMode(aura::Window* left,
-                                            aura::Window* right) {
+                                            aura::Window* right,
+                                            aura::Window* to_activate) {
   const aura::Window::Windows& windows = window_list_provider_->GetWindowList();
   aura::Window::Windows::const_reverse_iterator iter = windows.rbegin();
   if (state_ == ACTIVE) {
@@ -211,11 +213,30 @@ void SplitViewController::ActivateSplitMode(aura::Window* left,
   if (right_window_ && right_window_ != left && right_window_ != right)
     to_hide_.push_back(right_window_);
 
+  left_window_ = left;
+  right_window_ = right;
+
   divider_position_ = GetDefaultDividerPosition();
   SetState(ACTIVE);
-  right_window_ = right;
-  left_window_ = left;
   UpdateLayout(true);
+
+  aura::client::ActivationClient* activation_client =
+      aura::client::GetActivationClient(container_->GetRootWindow());
+  aura::Window* active_window = activation_client->GetActiveWindow();
+  if (to_activate) {
+    CHECK(to_activate == left_window_ || to_activate == right_window_);
+    wm::ActivateWindow(to_activate);
+  } else if (active_window != left_window_ &&
+             active_window != right_window_) {
+    // A window which does not belong to an activity could be active.
+    wm::ActivateWindow(left_window_);
+  }
+  active_window = activation_client->GetActiveWindow();
+
+  if (active_window == left_window_)
+    window_list_provider_->StackWindowBehindTo(right_window_, left_window_);
+  else
+    window_list_provider_->StackWindowBehindTo(left_window_, right_window_);
 }
 
 void SplitViewController::ReplaceWindow(aura::Window* window,
@@ -226,12 +247,19 @@ void SplitViewController::ReplaceWindow(aura::Window* window,
   CHECK(replace_with != left_window_ && replace_with != right_window_);
   DCHECK(window_list_provider_->IsWindowInList(replace_with));
 
-  if (window == left_window_)
+  aura::Window* not_replaced = NULL;
+  if (window == left_window_) {
     left_window_ = replace_with;
-  else
+    not_replaced = right_window_;
+  } else {
     right_window_ = replace_with;
-  wm::ActivateWindow(replace_with);
+    not_replaced = left_window_;
+  }
   UpdateLayout(false);
+
+  wm::ActivateWindow(replace_with);
+  window_list_provider_->StackWindowBehindTo(not_replaced, replace_with);
+
   window->SetTransform(gfx::Transform());
   window->Hide();
 }
@@ -367,8 +395,6 @@ void SplitViewController::UpdateLayout(bool animate) {
 
   left_window_->Show();
   right_window_->Show();
-  window_list_provider_->MoveToFront(right_window_);
-  window_list_provider_->MoveToFront(left_window_);
 
   gfx::Transform divider_transform;
   divider_transform.Translate(divider_position_, 0);

athena/wm/split_view_controller.h

@@ -48,8 +48,13 @@ class ATHENA_EXPORT SplitViewController
 
   // Activates split-view mode with |left| and |right| windows. If |left| and/or
   // |right| is NULL, then the first window in the window-list (which is neither
-  // |left| nor |right|) is selected instead.
-  void ActivateSplitMode(aura::Window* left, aura::Window* right);
+  // |left| nor |right|) is selected instead. |to_activate| indicates which of
+  // |left| or |right| should be activated. If |to_activate| is NULL, the
+  // currently active window is kept active if it is one of the split-view
+  // windows.
+  void ActivateSplitMode(aura::Window* left,
+                         aura::Window* right,
+                         aura::Window* to_activate);
 
   // Resets the internal state to an inactive state.
   void DeactivateSplitMode();

athena/wm/split_view_controller_unittest.cc

@@ -13,6 +13,7 @@
 #include "ui/aura/window.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/screen.h"
+#include "ui/wm/core/window_util.h"
 
 namespace athena {
 
@@ -32,18 +33,16 @@ class SplitViewControllerTest : public test::AthenaTestBase {
     test::AthenaTestBase::TearDown();
   }
 
-  // Returns whether the split view windows are topmost.
-  bool SplitViewWindowsTopmost() const {
-    SplitViewController* controller = api_->GetSplitViewController();
-    DCHECK(controller->IsSplitViewModeActive());
+  // Returns the topmost window in z-order.
+  const aura::Window* GetTopmostWindow() const {
+    return *api_->GetWindowListProvider()->GetWindowList().rbegin();
+  }
+
+  // Returns the second topmost window in z-order.
+  const aura::Window* GetSecondTopmostWindow() const {
     const 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());
+    return *(list.rbegin() + 1);
   }
 
   // Returns whether only the split view windows are visible.
@@ -89,56 +88,76 @@ TEST_F(SplitViewControllerTest, SplitModeActivation) {
   }
 
   windows[kNumWindows - 1]->Show();
+  wm::ActivateWindow(windows[kNumWindows - 1]);
 
   SplitViewController* controller = api()->GetSplitViewController();
   ASSERT_FALSE(controller->IsSplitViewModeActive());
 
-  controller->ActivateSplitMode(NULL, NULL);
+  controller->ActivateSplitMode(NULL, 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());
+  EXPECT_EQ(windows[kNumWindows - 1], GetTopmostWindow());
+  EXPECT_EQ(windows[kNumWindows - 2], GetSecondTopmostWindow());
   EXPECT_TRUE(OnlySplitViewWindowsVisible());
 
   // Select the window that is currently on the left for the right panel. The
   // windows should switch.
-  controller->ActivateSplitMode(NULL, windows[kNumWindows - 1]);
+  controller->ActivateSplitMode(
+      NULL, windows[kNumWindows - 1], windows[kNumWindows - 1]);
   EXPECT_EQ(windows[kNumWindows - 2], controller->left_window());
   EXPECT_EQ(windows[kNumWindows - 1], controller->right_window());
-  EXPECT_TRUE(SplitViewWindowsTopmost());
+  EXPECT_EQ(windows[kNumWindows - 1], GetTopmostWindow());
+  EXPECT_EQ(windows[kNumWindows - 2], GetSecondTopmostWindow());
+  EXPECT_TRUE(OnlySplitViewWindowsVisible());
+
+  controller->ActivateSplitMode(
+      windows[kNumWindows - 1], NULL, windows[kNumWindows - 1]);
+  EXPECT_EQ(windows[kNumWindows - 1], controller->left_window());
+  EXPECT_EQ(windows[kNumWindows - 2], controller->right_window());
+  EXPECT_EQ(windows[kNumWindows - 1], GetTopmostWindow());
+  EXPECT_EQ(windows[kNumWindows - 2], GetSecondTopmostWindow());
   EXPECT_TRUE(OnlySplitViewWindowsVisible());
 
-  controller->ActivateSplitMode(windows[kNumWindows - 1], NULL);
+  // Select the same windows, but pass in a different window to activate.
+  controller->ActivateSplitMode(windows[kNumWindows - 1],
+                                windows[kNumWindows - 2],
+                                windows[kNumWindows - 2]);
   EXPECT_EQ(windows[kNumWindows - 1], controller->left_window());
   EXPECT_EQ(windows[kNumWindows - 2], controller->right_window());
-  EXPECT_TRUE(SplitViewWindowsTopmost());
+  EXPECT_EQ(windows[kNumWindows - 2], GetTopmostWindow());
+  EXPECT_EQ(windows[kNumWindows - 1], GetSecondTopmostWindow());
   EXPECT_TRUE(OnlySplitViewWindowsVisible());
 
   // 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]);
+  controller->ActivateSplitMode(NULL, windows[0], windows[0]);
   EXPECT_EQ(windows[kNumWindows - 1], controller->left_window());
   EXPECT_EQ(windows[0], controller->right_window());
-  EXPECT_TRUE(SplitViewWindowsTopmost());
+  EXPECT_EQ(windows[0], GetTopmostWindow());
+  EXPECT_EQ(windows[kNumWindows - 1], GetSecondTopmostWindow());
   EXPECT_TRUE(OnlySplitViewWindowsVisible());
 
-  controller->ActivateSplitMode(windows[1], NULL);
+  controller->ActivateSplitMode(windows[1], NULL, NULL);
   EXPECT_EQ(windows[1], controller->left_window());
   EXPECT_EQ(windows[0], controller->right_window());
-  EXPECT_TRUE(SplitViewWindowsTopmost());
+  EXPECT_EQ(windows[0], GetTopmostWindow());
+  EXPECT_EQ(windows[1], GetSecondTopmostWindow());
   EXPECT_TRUE(OnlySplitViewWindowsVisible());
 
-  controller->ActivateSplitMode(windows[4], windows[5]);
+  controller->ActivateSplitMode(windows[4], windows[5], windows[5]);
   EXPECT_EQ(windows[4], controller->left_window());
   EXPECT_EQ(windows[5], controller->right_window());
-  EXPECT_TRUE(SplitViewWindowsTopmost());
+  EXPECT_EQ(windows[5], GetTopmostWindow());
+  EXPECT_EQ(windows[4], GetSecondTopmostWindow());
   EXPECT_TRUE(OnlySplitViewWindowsVisible());
 
-  controller->ActivateSplitMode(windows[0], NULL);
+  controller->ActivateSplitMode(windows[0], NULL, windows[0]);
   EXPECT_EQ(windows[0], controller->left_window());
   EXPECT_EQ(windows[5], controller->right_window());
-  EXPECT_TRUE(SplitViewWindowsTopmost());
+  EXPECT_EQ(windows[0], GetTopmostWindow());
+  EXPECT_EQ(windows[5], GetSecondTopmostWindow());
   EXPECT_TRUE(OnlySplitViewWindowsVisible());
 }
 
@@ -148,8 +167,12 @@ TEST_F(SplitViewControllerTest, LandscapeOnly) {
   const int kNumWindows = 2;
   for (size_t i = 0; i < kNumWindows; ++i) {
     scoped_ptr<aura::Window> window = CreateTestWindow(NULL, gfx::Rect());
+    window->Hide();
     windows.push_back(window.release());
   }
+  windows[kNumWindows - 1]->Show();
+  wm::ActivateWindow(windows[kNumWindows - 1]);
+
   ASSERT_EQ(gfx::Display::ROTATE_0,
             gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().rotation());
 
@@ -157,7 +180,7 @@ TEST_F(SplitViewControllerTest, LandscapeOnly) {
   ASSERT_TRUE(IsSplitViewAllowed());
   ASSERT_FALSE(controller->IsSplitViewModeActive());
 
-  controller->ActivateSplitMode(NULL, NULL);
+  controller->ActivateSplitMode(NULL, NULL, NULL);
   ASSERT_TRUE(controller->IsSplitViewModeActive());
 
   // Screen rotation should be locked while in splitview.

athena/wm/window_list_provider_impl.cc

@@ -66,11 +66,6 @@ bool WindowListProviderImpl::IsValidWindow(aura::Window* window) const {
       window->type() == ui::wm::WINDOW_TYPE_PANEL;
 }
 
-void WindowListProviderImpl::MoveToFront(aura::Window* window) {
-  DCHECK(IsWindowInList(window));
-  container_->StackChildAtTop(window);
-}
-
 void WindowListProviderImpl::StackWindowFrontOf(
     aura::Window* window,
     aura::Window* reference_window) {

athena/wm/window_list_provider_impl.h

@@ -29,7 +29,6 @@ class ATHENA_EXPORT WindowListProviderImpl : public WindowListProvider,
   virtual const aura::Window::Windows& GetWindowList() const OVERRIDE;
   virtual bool IsWindowInList(aura::Window* window) const OVERRIDE;
   virtual bool IsValidWindow(aura::Window* window) const OVERRIDE;
-  virtual void MoveToFront(aura::Window* window) OVERRIDE;
   virtual void StackWindowFrontOf(aura::Window* window,
                                   aura::Window*reference_window) OVERRIDE;
   virtual void StackWindowBehindTo(aura::Window* window,

athena/wm/window_list_provider_impl_unittest.cc

@@ -206,51 +206,39 @@ TEST_F(WindowListProviderImplTest, TestWindowOrderingFunctions) {
 
   EXPECT_EQ(0, observer.get()->calls());
 
-  // Move 2 to the front.
-  list_provider->MoveToFront(window2.get());
-  EXPECT_EQ("1 3 2", GetWindowOrder(original_order,
+  // Move 1 (from the back) in front of 2.
+  list_provider->StackWindowFrontOf(window1.get(), window2.get());
+  EXPECT_EQ("2 1 3", GetWindowOrder(original_order,
                                     list_provider->GetWindowList()));
   EXPECT_EQ(1, observer->calls());
 
-  // Move 2 to the front again. Should not change anything.
-  list_provider->MoveToFront(window2.get());
-  EXPECT_EQ("1 3 2", GetWindowOrder(original_order,
-                                    list_provider->GetWindowList()));
-  EXPECT_EQ(1, observer->calls());
-
-  // Move 1 (from the back) in front of 3.
-  list_provider->StackWindowFrontOf(window1.get(), window3.get());
-  EXPECT_EQ("3 1 2", GetWindowOrder(original_order,
+  // Move 3 (from the front) in front of 2.
+  list_provider->StackWindowFrontOf(window3.get(), window2.get());
+  EXPECT_EQ("2 3 1", GetWindowOrder(original_order,
                                     list_provider->GetWindowList()));
   EXPECT_EQ(2, observer->calls());
 
-  // Move 2 (from the front) in front of 3.
-  list_provider->StackWindowFrontOf(window2.get(), window3.get());
-  EXPECT_EQ("3 2 1", GetWindowOrder(original_order,
+  // Move 1 (from the front) behind 2.
+  list_provider->StackWindowBehindTo(window1.get(), window2.get());
+  EXPECT_EQ("1 2 3", GetWindowOrder(original_order,
                                     list_provider->GetWindowList()));
   EXPECT_EQ(3, observer->calls());
 
-  // Move 1 (from the front) behind 3.
-  list_provider->StackWindowBehindTo(window1.get(), window3.get());
-  EXPECT_EQ("1 3 2", GetWindowOrder(original_order,
+  // Move 1 (from the back) in front of 3.
+  list_provider->StackWindowFrontOf(window1.get(), window3.get());
+  EXPECT_EQ("2 3 1", GetWindowOrder(original_order,
                                     list_provider->GetWindowList()));
   EXPECT_EQ(4, observer->calls());
 
-  // Move 1 (from the back) in front of 2.
-  list_provider->StackWindowFrontOf(window1.get(), window2.get());
-  EXPECT_EQ("3 2 1", GetWindowOrder(original_order,
-                                    list_provider->GetWindowList()));
-  EXPECT_EQ(5, observer->calls());
-
   // Test that no change should also report no call.
-  list_provider->StackWindowFrontOf(window1.get(), window2.get());
-  EXPECT_EQ("3 2 1", GetWindowOrder(original_order,
+  list_provider->StackWindowFrontOf(window1.get(), window3.get());
+  EXPECT_EQ("2 3 1", GetWindowOrder(original_order,
                                     list_provider->GetWindowList()));
-  EXPECT_EQ(5, observer->calls());
-  list_provider->StackWindowBehindTo(window2.get(), window1.get());
-  EXPECT_EQ("3 2 1", GetWindowOrder(original_order,
+  EXPECT_EQ(4, observer->calls());
+  list_provider->StackWindowBehindTo(window3.get(), window1.get());
+  EXPECT_EQ("2 3 1", GetWindowOrder(original_order,
                                     list_provider->GetWindowList()));
-  EXPECT_EQ(5, observer->calls());
+  EXPECT_EQ(4, observer->calls());
 }
 
 TEST_F(WindowListProviderImplTest, TestWindowRemovalNotification) {

athena/wm/window_manager_impl.cc

@@ -176,6 +176,23 @@ WindowManagerImpl::~WindowManagerImpl() {
   instance = NULL;
 }
 
+void WindowManagerImpl::ToggleSplitView() {
+  if (IsOverviewModeActive())
+    return;
+
+  if (split_view_controller_->IsSplitViewModeActive()) {
+    split_view_controller_->DeactivateSplitMode();
+    FOR_EACH_OBSERVER(WindowManagerObserver, observers_, OnSplitViewModeExit());
+    // Relayout so that windows are maximzied.
+    container_->layout_manager()->OnWindowResized();
+  } else if (split_view_controller_->CanActivateSplitViewMode()) {
+    FOR_EACH_OBSERVER(WindowManagerObserver,
+                      observers_,
+                      OnSplitViewModeEnter());
+    split_view_controller_->ActivateSplitMode(NULL, NULL, NULL);
+  }
+}
+
 void WindowManagerImpl::ToggleOverview() {
   if (IsOverviewModeActive()) {
     SetInOverview(false);
@@ -241,7 +258,7 @@ void WindowManagerImpl::RemoveObserver(WindowManagerObserver* observer) {
 }
 
 void WindowManagerImpl::ToggleSplitViewForTest() {
-  ToggleSplitview();
+  ToggleSplitView();
 }
 
 WindowListProvider* WindowManagerImpl::GetWindowListProvider() {
@@ -290,8 +307,7 @@ void WindowManagerImpl::OnSelectSplitViewWindow(aura::Window* left,
                                                 aura::Window* to_activate) {
   SetInOverview(false);
   FOR_EACH_OBSERVER(WindowManagerObserver, observers_, OnSplitViewModeEnter());
-  split_view_controller_->ActivateSplitMode(left, right);
-  wm::ActivateWindow(to_activate);
+  split_view_controller_->ActivateSplitMode(left, right, to_activate);
 }
 
 void WindowManagerImpl::OnWindowDestroying(aura::Window* window) {
@@ -310,29 +326,12 @@ bool WindowManagerImpl::OnAcceleratorFired(int command_id,
       ToggleOverview();
       break;
     case CMD_TOGGLE_SPLIT_VIEW:
-      ToggleSplitview();
+      ToggleSplitView();
       break;
   }
   return true;
 }
 
-void WindowManagerImpl::ToggleSplitview() {
-  if (IsOverviewModeActive())
-    return;
-
-  if (split_view_controller_->IsSplitViewModeActive()) {
-    split_view_controller_->DeactivateSplitMode();
-    FOR_EACH_OBSERVER(WindowManagerObserver, observers_, OnSplitViewModeExit());
-    // Relayout so that windows are maximzied.
-    container_->layout_manager()->OnWindowResized();
-  } else if (split_view_controller_->CanActivateSplitViewMode()) {
-    FOR_EACH_OBSERVER(WindowManagerObserver,
-                      observers_,
-                      OnSplitViewModeEnter());
-    split_view_controller_->ActivateSplitMode(NULL, NULL);
-  }
-}
-
 aura::Window* WindowManagerImpl::GetWindowBehind(aura::Window* window) {
   const aura::Window::Windows& windows = window_list_provider_->GetWindowList();
   aura::Window::Windows::const_reverse_iterator iter =
@@ -383,7 +382,6 @@ void WindowManagerImpl::OnTitleDragCompleted(aura::Window* window) {
     return;
   if (split_view_controller_->IsSplitViewModeActive()) {
     split_view_controller_->ReplaceWindow(window, next_window);
-    wm::ActivateWindow(next_window);
   } else {
     ui::ScopedLayerAnimationSettings
         settings(next_window->layer()->GetAnimator());

athena/wm/window_manager_impl.h

@@ -5,6 +5,7 @@
 #ifndef ATHENA_WM_WINDOW_MANAGER_IMPL_H_
 #define ATHENA_WM_WINDOW_MANAGER_IMPL_H_
 
+#include "athena/athena_export.h"
 #include "athena/input/public/accelerator_manager.h"
 #include "athena/wm/public/window_manager.h"
 #include "athena/wm/title_drag_controller.h"
@@ -29,15 +30,17 @@ class SplitViewController;
 class WindowListProvider;
 class WindowManagerObserver;
 
-class WindowManagerImpl : public WindowManager,
-                          public WindowOverviewModeDelegate,
-                          public aura::WindowObserver,
-                          public AcceleratorHandler,
-                          public TitleDragControllerDelegate {
+class ATHENA_EXPORT WindowManagerImpl : public WindowManager,
+                                        public WindowOverviewModeDelegate,
+                                        public aura::WindowObserver,
+                                        public AcceleratorHandler,
+                                        public TitleDragControllerDelegate {
  public:
   WindowManagerImpl();
   virtual ~WindowManagerImpl();
 
+  void ToggleSplitView();
+
   // WindowManager:
   virtual void ToggleOverview() OVERRIDE;
   virtual bool IsOverviewModeActive() OVERRIDE;
@@ -54,8 +57,6 @@ class WindowManagerImpl : public WindowManager,
   // Sets whether overview mode is active.
   void SetInOverview(bool active);
 
-  void ToggleSplitview();
-
   void InstallAccelerators();
 
   // WindowManager: