[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"
@@ skipping 77 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_);
 
-  SetState(ACTIVE);
   right_window_ = right;
   left_window_ = left;
+
+  window_list_provider_->MoveToFront(right_window_);
+  window_list_provider_->MoveToFront(left_window_);
+  SetState(ACTIVE);
   UpdateLayout(true);
 }
 
 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_);
 #if !defined(NDEBUG)
   aura::Window::Windows windows = window_list_provider_->GetWindowList();
   DCHECK(std::find(windows.begin(), windows.end(), replace_with) !=
          windows.end());
 #endif
 
   if (window == left_window_)
     left_window_ = replace_with;
   else
     right_window_ = replace_with;
   wm::ActivateWindow(replace_with);
+  window_list_provider_->MoveToFront(right_window_);
+  window_list_provider_->MoveToFront(left_window_);

[mfomitchev, 2014/09/18 02:36:29]

ActivateWindow already moves the window to front with our window list provider
implementation, so this seems a bit excessive. We should be able to get rid of
one of the MoveToFront calls. Also, |replace_with| should probably be on top of
the other split view window, since |replace_with| is the active one. So the
Activate call should be after the MoveToFront call.

[pkotwicz, 2014/09/18 13:54:45]

I have removed the call to wm::ActivateWindow(). This is consistent with the
remainder of SplitViewController which does not do anything with activation.

We do not explicitly call wm::ActivateWindow() prior to calling ReplaceWindow()
in WindowManagerImpl::OnWindowAddedToLayout(). In practice, |child|, being a
views::Widget is activated when views::Widget::Show() is called. Ideally we
would wait till the new window is activated prior to replacing the split view
window.

w.r.t. to the relative z-order of the left and right windows, we do not care
about it in the case of ActivateSplitMode() so I do not think that we should
care about it in the ReplaceWindow() case either. In patch set #1 of
https://codereview.chromium.org/550043002/#ps1 I attempted to change
ActivateSplitMode() such that one of the passed in windows had to be active but
sadrul@ did not like that.

[mfomitchev, 2014/09/18 18:11:52]

We still use ActivateWindow in ScrollEnd - that's how we ensure that the window
that ends up displayed when is on top in the window list.

I think making sure the invariant "active window is the top one in the stack"
always holds would be a good thing.

In this particular case, the call is typically done when you swipe on the header
of one of the visible windows. If I do this on the left window, I'd expect the
left window to remain active. E.g. if I start typing, I'd expect keyboard input
to go to that window.

Maybe Sadrul, you, and I could have a quick chat on this.

   UpdateLayout(false);
   window->SetTransform(gfx::Transform());
   window->Hide();
 }
 
 void SplitViewController::DeactivateSplitMode() {
   CHECK_EQ(ACTIVE, state_);
   SetState(INACTIVE);
   UpdateLayout(false);
   left_window_ = right_window_ = NULL;
@@ skipping 32 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 129 matching lines @@
 bool SplitViewController::CanScroll() {
   // TODO(mfomitchev): return false in full screen.
   bool result = (!IsSplitViewModeActive() &&
                  window_list_provider_->GetWindowList().size() >= 2 &&
                  IsLandscapeOrientation(gfx::Screen::GetNativeScreen()->
                      GetDisplayNearestWindow(container_).rotation()));
   return result;
 }
 
 }  // namespace athena