Ensure that an activity is activated when overview mode is exited

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/screen/public/screen_manager.h"
 #include "athena/util/container_priorities.h"
 #include "athena/wm/bezel_controller.h"
 #include "athena/wm/public/window_manager_observer.h"
 #include "athena/wm/split_view_controller.h"
 #include "athena/wm/title_drag_controller.h"
 #include "athena/wm/window_list_provider_impl.h"
 #include "athena/wm/window_overview_mode.h"
+#include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #include "ui/aura/layout_manager.h"
 #include "ui/aura/window.h"
 #include "ui/compositor/closure_animation_observer.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/screen.h"
 #include "ui/wm/core/shadow_controller.h"
 #include "ui/wm/core/window_util.h"
@@ skipping 67 matching lines @@
     } else {
       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()) {
+
+  if (instance->split_view_controller_->IsSplitViewModeActive() &&
+      !instance->IsOverviewModeActive()) {
     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));
   }
+
+  if (instance->IsOverviewModeActive()) {
+    // TODO(pkotwicz|oshima). Creating a new window should only exit overview
+    // mode if the new window is activated.
+    instance->OnSelectWindow(child);
+  }
 }
 
 void AthenaContainerLayoutManager::OnWillRemoveWindowFromLayout(
     aura::Window* child) {
 }
 
 void AthenaContainerLayoutManager::OnWindowRemovedFromLayout(
     aura::Window* child) {
 }
 
 void AthenaContainerLayoutManager::OnChildWindowVisibilityChanged(
     aura::Window* child,
     bool visible) {
 }
 
 void AthenaContainerLayoutManager::SetChildBounds(
     aura::Window* child,
     const gfx::Rect& requested_bounds) {
   if (!requested_bounds.IsEmpty())
     SetChildBoundsDirect(child, requested_bounds);
 }
 
-WindowManagerImpl::WindowManagerImpl() {
+WindowManagerImpl::WindowManagerImpl() : selecting_window_(false) {
   ScreenManager::ContainerParams params("DefaultContainer", CP_DEFAULT);
   params.can_activate_children = true;
   container_.reset(ScreenManager::Get()->CreateDefaultContainer(params));
   container_->SetLayoutManager(new AthenaContainerLayoutManager);
   container_->AddObserver(this);
   window_list_provider_.reset(new WindowListProviderImpl(container_.get()));
   bezel_controller_.reset(new BezelController(container_.get()));
   split_view_controller_.reset(
       new SplitViewController(container_.get(), window_list_provider_.get()));
   bezel_controller_->set_left_right_delegate(split_view_controller_.get());
@@ skipping 27 matching lines @@
 
 bool WindowManagerImpl::IsOverviewModeActive() {
   return overview_;
 }
 
 void WindowManagerImpl::SetInOverview(bool active) {
   bool in_overview = !!overview_;
   if (active == in_overview)
     return;
 
+  if (!active && !selecting_window_) {
+    const aura::Window::Windows& windows =
+        window_list_provider_->GetWindowList();

[sadrul, 2014/09/12 04:42:06]

Just const Windows windows = ...;

+    if (!windows.empty()) {
+      if (split_view_controller_->IsSplitViewModeActive()) {
+        DCHECK(windows.back() == split_view_controller_->left_window() ||
+               windows.back() == split_view_controller_->right_window());
+        OnSelectSplitViewWindow(split_view_controller_->left_window(),
+                                split_view_controller_->right_window(),
+                                windows.back());
+      } else {
+        OnSelectWindow(windows.back());
+      }
+      return;

[sadrul, 2014/09/12 04:42:06]

I think |overview_|, bezel-controller's delegate etc. gets updated indirectly
through calls to SetInOverview() from
OnSelectSplitViewWindow()/OnSelectWindow()? But that's not obvious from reading
the code. And it doesn't sound like a great thing to depend on indirectly
recursing into SetInOverview() for all this. Can this move into ToggleOverview()
instead?

+    }
+  }
+
   bezel_controller_->set_left_right_delegate(
       active ? NULL : split_view_controller_.get());
   if (active) {
     FOR_EACH_OBSERVER(WindowManagerObserver, observers_, OnOverviewModeEnter());
 
     // Note: The window_list_provider_ resembles the exact window list of the
     // container, so no re-stacking is required before showing the OverviewMode.
     overview_ = WindowOverviewMode::Create(
         container_.get(), window_list_provider_.get(),
         split_view_controller_.get(), this);
@@ skipping 24 matching lines @@
 
 void WindowManagerImpl::ToggleSplitViewForTest() {
   ToggleSplitview();
 }
 
 WindowListProvider* WindowManagerImpl::GetWindowListProvider() {
   return window_list_provider_.get();
 }
 
 void WindowManagerImpl::OnSelectWindow(aura::Window* window) {
+  base::AutoReset<bool> selecting_window(&selecting_window_, true);
+  SetInOverview(false);
+
+  window->Show();
+  wm::ActivateWindow(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
   // resized.
   const gfx::Size work_area =
       gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().work_area().size();
   if (window->GetTargetBounds().size() != work_area) {
     const gfx::Rect& window_bounds = window->bounds();
     const gfx::Rect desired_bounds(work_area);
     gfx::Transform transform;
     transform.Translate(desired_bounds.x() - window_bounds.x(),
                         desired_bounds.y() - window_bounds.y());
     transform.Scale(desired_bounds.width() / window_bounds.width(),
                     desired_bounds.height() / window_bounds.height());
-    window->layer()->GetAnimator()->AbortAllAnimations();
     ui::ScopedLayerAnimationSettings settings(window->layer()->GetAnimator());
     settings.SetPreemptionStrategy(
         ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
     settings.AddObserver(
         new ui::ClosureAnimationObserver(base::Bind(&SetWindowState,
                                                     base::Unretained(window),
                                                     desired_bounds,
                                                     gfx::Transform())));
     window->SetTransform(transform);
   }
 }
 
-void WindowManagerImpl::OnSplitViewMode(aura::Window* left,
-                                        aura::Window* right) {
+void WindowManagerImpl::OnSelectSplitViewWindow(aura::Window* left,
+                                                aura::Window* right,
+                                                aura::Window* to_activate) {
+  base::AutoReset<bool> selecting_window(&selecting_window_, true);
   SetInOverview(false);
   FOR_EACH_OBSERVER(WindowManagerObserver, observers_, OnSplitViewModeEnter());
   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);
+  wm::ActivateWindow(to_activate);
 }
 
 void WindowManagerImpl::OnWindowDestroying(aura::Window* window) {
   if (window == container_)
     container_.reset();
 }
 
 bool WindowManagerImpl::IsCommandEnabled(int command_id) const {
   return true;
 }
@@ skipping 123 matching lines @@
   DCHECK(!instance);
 }
 
 // static
 WindowManager* WindowManager::GetInstance() {
   DCHECK(instance);
   return instance;
 }
 
 }  // namespace athena