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

athena/wm/window_manager_impl.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/window_manager_impl.h"
 
 #include <algorithm>
 
 #include "athena/common/container_priorities.h"
 #include "athena/screen/public/screen_manager.h"
@@ skipping 84 matching lines @@
       window->SetBounds(gfx::Rect(work_area));
     }
   }
 }
 
 void AthenaContainerLayoutManager::OnWindowAddedToLayout(aura::Window* child) {
   aura::Window::Windows list = instance->window_list_provider_->GetWindowList();
   if (std::find(list.begin(), list.end(), child) == list.end())
     return;
   if (instance->split_view_controller_->IsSplitViewModeActive()) {
+    child->Show();
+    wm::ActivateWindow(child);
     instance->split_view_controller_->ReplaceWindow(
         instance->split_view_controller_->left_window(), child);
   } else {
     gfx::Size size =
         gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().work_area().size();
     child->SetBounds(gfx::Rect(size));

[sadrul, 2014/09/09 14:27:28]

Where do we activate this new window in normal mode?

[pkotwicz, 2014/09/09 17:06:28]

In practice we activate this window in normal mode because we do not show any
activities with views::Widget::ShowInactive(). I do not think there are any
cases where we would want to (I do not think we want to support pop-under
popups)

I activate the window explicitly when in split view mode, because the window is
added to the container prior to it being shown or activated.
SplitViewController::ReplaceWindow() would yield the incorrect stack order if
|child| is not activated.

I have thought about replacing a window in split view only once a window is
activated. The problem is that we would need to figure out an algorithm for when
activating a window will replace the current window in split view. (i.e. what
will activating the window in WindowManagerImpl::OnSelectWindow() do?)

   }
 }
 
 void AthenaContainerLayoutManager::OnWillRemoveWindowFromLayout(
     aura::Window* child) {
 }
 
 void AthenaContainerLayoutManager::OnWindowRemovedFromLayout(
     aura::Window* child) {
 }
@@ skipping 46 matching lines @@
 }
 
 void WindowManagerImpl::ToggleOverview() {
   SetInOverview(overview_.get() == NULL);
 }
 
 bool WindowManagerImpl::IsOverviewModeActive() {
   return overview_;
 }
 
+void WindowManagerImpl::ToggleSplitView() {
+  // TODO(oshima): Figure out what to do.
+  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 (window_list_provider_->GetWindowList().size() > 1) {
+    FOR_EACH_OBSERVER(WindowManagerObserver,
+                      observers_,
+                      OnSplitViewModeEnter());
+    aura::Window* active_window =
+        window_list_provider_->GetWindowList().back();
+    wm::ActivateWindow(active_window);
+    split_view_controller_->ActivateSplitMode(active_window, NULL);
+  }
+}
+
 void WindowManagerImpl::SetInOverview(bool active) {
   bool in_overview = !!overview_;
   if (active == in_overview)
     return;
 
   bezel_controller_->set_left_right_delegate(
       active ? NULL : split_view_controller_.get());
   if (active) {
     FOR_EACH_OBSERVER(WindowManagerObserver, observers_, OnOverviewModeEnter());
 
@@ skipping 24 matching lines @@
 
 void WindowManagerImpl::AddObserver(WindowManagerObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void WindowManagerImpl::RemoveObserver(WindowManagerObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void WindowManagerImpl::ToggleSplitViewForTest() {
-  ToggleSplitview();
+  ToggleSplitView();
 }
 
 void WindowManagerImpl::OnSelectWindow(aura::Window* window) {
   if (split_view_controller_->IsSplitViewModeActive()) {
     split_view_controller_->DeactivateSplitMode();
     FOR_EACH_OBSERVER(WindowManagerObserver, observers_, OnSplitViewModeExit());
   }
   wm::ActivateWindow(window);
   SetInOverview(false);
   // If |window| does not have the size of the work-area, then make sure it is
@@ skipping 18 matching lines @@
                                                     desired_bounds,
                                                     gfx::Transform())));
     window->SetTransform(transform);
   }
 }
 
 void WindowManagerImpl::OnSplitViewMode(aura::Window* left,
                                         aura::Window* right) {
   SetInOverview(false);
   FOR_EACH_OBSERVER(WindowManagerObserver, observers_, OnSplitViewModeEnter());
+  if (right)
+    wm::ActivateWindow(right);
+  else
+    wm::ActivateWindow(left);

[sadrul, 2014/09/09 14:27:28]

Both left and right can be NULL here.

[pkotwicz, 2014/09/09 17:06:28]

In practice, either |left| or |right| must be activated.
We do not want to get into a state where split view is active but an activity
not in split view is active and has keyboard focus.

In https://codereview.chromium.org/546123002/ I have added a third argument to
this function which indicates whether |left| or |right| should be activated. I
can move that change to this CL

   split_view_controller_->ActivateSplitMode(left, right);
 }
 
 void WindowManagerImpl::OnWindowAdded(aura::Window* new_window) {
   // TODO(oshima): Creating a new window should updates the ovewview mode
   // instead of exitting.
   if (new_window->type() == ui::wm::WINDOW_TYPE_NORMAL)
     SetInOverview(false);
 }
 
 void WindowManagerImpl::OnWindowDestroying(aura::Window* window) {
   if (window == container_)
     container_.reset();
 }
 
 bool WindowManagerImpl::IsCommandEnabled(int command_id) const {
   return true;
 }
 
 bool WindowManagerImpl::OnAcceleratorFired(int command_id,
                                            const ui::Accelerator& accelerator) {
   switch (command_id) {
     case CMD_TOGGLE_OVERVIEW:
       ToggleOverview();
       break;
     case CMD_TOGGLE_SPLIT_VIEW:
-      ToggleSplitview();
+      ToggleSplitView();
       break;
   }
   return true;
 }
 
-void WindowManagerImpl::ToggleSplitview() {
-  // TODO(oshima): Figure out what to do.
-  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 (window_list_provider_->GetWindowList().size() > 1) {
-    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 =
       std::find(windows.rbegin(), windows.rend(), window);
   CHECK(iter != windows.rend());
   ++iter;
   aura::Window* behind = NULL;
   if (iter != windows.rend())
     behind = *iter++;
 
@@ skipping 29 matching lines @@
     transform.Translate(dx, 0);
     next_window->SetTransform(transform);
   }
 }
 
 void WindowManagerImpl::OnTitleDragCompleted(aura::Window* window) {
   aura::Window* next_window = GetWindowBehind(window);
   if (!next_window)
     return;
   if (split_view_controller_->IsSplitViewModeActive()) {
+    wm::ActivateWindow(next_window);
     split_view_controller_->ReplaceWindow(window, next_window);

[sadrul, 2014/09/09 14:27:28]

Can you explain why this order is important?

[pkotwicz, 2014/09/09 17:06:28]

Order is important because I changed SplitViewController::ReplaceWindow() to
require |replace_with| to be active. I should have updated the documentation in
split_view_controller.h as well.

-    wm::ActivateWindow(next_window);
   } else {
     ui::ScopedLayerAnimationSettings
         settings(next_window->layer()->GetAnimator());
     settings.AddObserver(new ui::ClosureAnimationObserver(
         base::Bind(&SetWindowState,
                    base::Unretained(next_window),
                    window->bounds(),
                    gfx::Transform())));
 
     gfx::Transform transform;
@@ skipping 30 matching lines @@
   DCHECK(!instance);
 }
 
 // static
 WindowManager* WindowManager::GetInstance() {
   DCHECK(instance);
   return instance;
 }
 
 }  // namespace athena