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

athena/wm/split_view_controller.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 <cmath>
 
 #include "athena/screen/public/screen_manager.h"
 #include "athena/wm/public/window_list_provider.h"
 #include "athena/wm/public/window_manager.h"
 #include "base/bind.h"
 #include "ui/aura/window.h"
 #include "ui/compositor/closure_animation_observer.h"
 #include "ui/compositor/layer_animation_observer.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/events/event_handler.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/screen.h"
 #include "ui/wm/core/window_util.h"
+#include "ui/wm/public/activation_client.h"
 
 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;
@@ skipping 31 matching lines @@
               window_list_provider_->GetWindowList().size() >= 2 &&
               IsLandscapeOrientation(gfx::Screen::GetNativeScreen()->
                   GetDisplayNearestWindow(container_).rotation()));
 }
 
 bool SplitViewController::IsSplitViewModeActive() const {
   return state_ == ACTIVE;
 }
 
 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) {
     if (!left && left_window_ != right)
       left = left_window_;
     if (!right && right_window_ != left)
       right = right_window_;
   }
 
   if (!left && iter != windows.rend()) {
@@ skipping 13 matching lines @@
       iter++;
     }
   }
 
   to_hide_.clear();
   if (left_window_ && left_window_ != left && left_window_ != right)
     to_hide_.push_back(left_window_);
   if (right_window_ && right_window_ != left && right_window_ != right)
     to_hide_.push_back(right_window_);
 
+  left_window_ = left;
+  right_window_ = right;
+
   SetState(ACTIVE);
-  right_window_ = right;
-  left_window_ = left;
   UpdateLayout(true);
+
+  if (to_activate)
+    wm::ActivateWindow(to_activate);

[sadrul, 2014/09/23 16:18:32]

Add a CHECK here that to_activate is one of left or right (you have an
equivalent check below in lines 121:125, but having the CHECK here would make it
more obvious when reading the code)

I think you should also have an else block here, so the rest of the function
could look like:

  if (to_activate) {
    CHECK(to_activate == left_window_ || to_active == right_window_);
    stack_behind = to_activate == left_window_ ? right_window_ : left_window_;
  } else {
    // If either of the left/right windows is active, then keep it active, and
    // stack the other window behind it. Otherwise, activate the left window,
    // and stack the window on the right behind it.
    aura::Window* active = GetActiveWindow();
    if (active == left_window_) {
      stack_behind = right_window_;
    } else if (active == right_window_) {
      stack_behind = left_window_;
    } else {
      to_activate = left_window_;
      stack_behind = right_window_;
    }
  }

  if (to_activate)
    wm::ActivateWindow(to_activate);
  CHECK(stack_behind);
  window_list_provider_->StackWindowBehindTo(stack_behind, GetActiveWindow());

[pkotwicz, 2014/09/24 14:59:23]

I have changed things around to make them clearer. I have kept initializing
|stack_behind| out of the if/else block though.

+
+  aura::client::ActivationClient* activation_client =
+      aura::client::GetActivationClient(container_->GetRootWindow());
+  aura::Window* active_window = activation_client->GetActiveWindow();
+
+  if (active_window == left_window_) {
+    window_list_provider_->StackWindowBehindTo(right_window_, left_window_);
+  } else {
+    CHECK_EQ(active_window, right_window_);
+    window_list_provider_->StackWindowBehindTo(left_window_, right_window_);
+  }
 }
 
 void SplitViewController::ReplaceWindow(aura::Window* window,
                                         aura::Window* replace_with) {
   CHECK(IsSplitViewModeActive());
   CHECK(replace_with);
   CHECK(window == left_window_ || window == right_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;
+    not_replaced = left_window_;
+  }
+  UpdateLayout(false);
+
   wm::ActivateWindow(replace_with);
-  UpdateLayout(false);
+  window_list_provider_->StackWindowBehindTo(not_replaced, replace_with);
+
   window->SetTransform(gfx::Transform());
   window->Hide();
 }
 
 void SplitViewController::DeactivateSplitMode() {
   CHECK_EQ(ACTIVE, state_);
   SetState(INACTIVE);
   UpdateLayout(false);
   left_window_ = right_window_ = NULL;
 }
@@ skipping 31 matching lines @@
     if (!wm::IsActiveWindow(left_window_))
       left_window_->Hide();
     if (!wm::IsActiveWindow(right_window_))
       right_window_->Hide();
     SetWindowTransforms(gfx::Transform(), gfx::Transform(), false);
     return;
   }
 
   left_window_->Show();
   right_window_->Show();
-  window_list_provider_->MoveToFront(right_window_);
-  window_list_provider_->MoveToFront(left_window_);
 
   if (state_ == ACTIVE) {
     if (animate) {
       gfx::Transform left_transform = GetTargetTransformForBoundsAnimation(
           left_window_->bounds(), GetLeftTargetBounds());
       gfx::Transform right_transform = GetTargetTransformForBoundsAnimation(
           right_window_->bounds(), GetRightTargetBounds());
       SetWindowTransforms(left_transform, right_transform, true);
     } else {
       left_window_->SetBounds(GetLeftTargetBounds());
@@ skipping 124 matching lines @@
     return;
   UpdateSeparatorPositionFromScrollDelta(delta);
   UpdateLayout(false);
 }
 
 bool SplitViewController::CanScroll() {
   return CanActivateSplitViewMode();
 }
 
 }  // namespace athena