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/common/container_priorities.h"
 #include "athena/screen/public/screen_manager.h"
@@ skipping 83 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->ExitOverview(child, WindowOverviewModeDelegate::SPLIT_NONE);
+  }
 }
 
 void AthenaContainerLayoutManager::OnWillRemoveWindowFromLayout(
     aura::Window* child) {
 }
 
 void AthenaContainerLayoutManager::OnWindowRemovedFromLayout(
     aura::Window* child) {
 }
 
@@ skipping 38 matching lines @@
     container_->RemoveObserver(this);
     container_->RemovePreTargetHandler(bezel_controller_.get());
   }
   // |title_drag_controller_| needs to be reset before |container_|.
   title_drag_controller_.reset();
   container_.reset();
   instance = NULL;
 }
 
 void WindowManagerImpl::ToggleOverview() {
-  SetInOverview(overview_.get() == NULL);
+  if (IsOverviewModeActive())
+    ExitOverview();
+  else
+    EnterOverview();
 }
 
 bool WindowManagerImpl::IsOverviewModeActive() {
   return overview_;
 }
 
-void WindowManagerImpl::SetInOverview(bool active) {
-  bool in_overview = !!overview_;
-  if (active == in_overview)
+void WindowManagerImpl::EnterOverview() {
+  if (overview_)
     return;
 
-  bezel_controller_->set_left_right_delegate(
-      active ? NULL : split_view_controller_.get());
-  if (active) {
-    FOR_EACH_OBSERVER(WindowManagerObserver, observers_, OnOverviewModeEnter());
+  FOR_EACH_OBSERVER(WindowManagerObserver, observers_, OnOverviewModeEnter());
 
-    // Re-stack all windows in the order defined by window_list_provider_.
-    aura::Window::Windows window_list = window_list_provider_->GetWindowList();
-    aura::Window::Windows::iterator it;
-    for (it = window_list.begin(); it != window_list.end(); ++it)
-      container_->StackChildAtTop(*it);
-    overview_ = WindowOverviewMode::Create(
-        container_.get(), window_list_provider_.get(),
-        split_view_controller_.get(), this);
-  } else {
-    overview_.reset();
-    FOR_EACH_OBSERVER(WindowManagerObserver, observers_, OnOverviewModeExit());
-  }
+  bezel_controller_->set_left_right_delegate(NULL);
+
+  // Re-stack all windows in the order defined by window_list_provider_.
+  aura::Window::Windows window_list = window_list_provider_->GetWindowList();
+  aura::Window::Windows::iterator it;
+  for (it = window_list.begin(); it != window_list.end(); ++it)
+    container_->StackChildAtTop(*it);
+  overview_ = WindowOverviewMode::Create(
+      container_.get(), window_list_provider_.get(),
+      split_view_controller_.get(), this);
 }
 
-void WindowManagerImpl::InstallAccelerators() {
-  const AcceleratorData accelerator_data[] = {
-      {TRIGGER_ON_PRESS, ui::VKEY_F6, ui::EF_NONE, CMD_TOGGLE_OVERVIEW,
-       AF_NONE},
-      {TRIGGER_ON_PRESS, ui::VKEY_F6, ui::EF_CONTROL_DOWN,
-       CMD_TOGGLE_SPLIT_VIEW, AF_NONE},
-  };
-  AcceleratorManager::Get()->RegisterAccelerators(
-      accelerator_data, arraysize(accelerator_data), this);
-}
+void WindowManagerImpl::ExitOverview(aura::Window* window,
+                                     SplitType split_type) {
+  if (!overview_)
+    return;
 
-void WindowManagerImpl::AddObserver(WindowManagerObserver* observer) {
-  observers_.AddObserver(observer);
-}
+  overview_.reset();
+  FOR_EACH_OBSERVER(WindowManagerObserver, observers_, OnOverviewModeExit());
 
-void WindowManagerImpl::RemoveObserver(WindowManagerObserver* observer) {
-  observers_.RemoveObserver(observer);
-}
+  bezel_controller_->set_left_right_delegate(split_view_controller_.get());
 
-void WindowManagerImpl::ToggleSplitViewForTest() {
-  ToggleSplitview();
-}
+  if (!window)
+    return;
 
-void WindowManagerImpl::OnSelectWindow(aura::Window* window) {
+  window->layer()->SetOpacity(1.0f);
+  window->Show();
+  wm::ActivateWindow(window);
+
+  if (split_type != SPLIT_NONE) {
+    FOR_EACH_OBSERVER(WindowManagerObserver,
+                      observers_,
+                      OnSplitViewModeEnter());
+    if (split_type == SPLIT_LEFT)
+      split_view_controller_->ActivateSplitMode(window, NULL);
+    else
+      split_view_controller_->ActivateSplitMode(NULL, window);
+    return;
+  }
+
   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) {
-  SetInOverview(false);
-  FOR_EACH_OBSERVER(WindowManagerObserver, observers_, OnSplitViewModeEnter());
-  split_view_controller_->ActivateSplitMode(left, right);
+void WindowManagerImpl::ExitOverview() {
+  if (overview_)
+    overview_->SelectDefaultWindow();

[sadrul, 2014/09/07 05:26:49]

If the WOM did not explicitly request a selection change (or split-view mode
change), then the WMI itself should make the selection, and not ask the WOM to
do it.

[pkotwicz, 2014/09/08 19:39:23]

WOM is best positioned to select the default window, especially once the
algorithm for picking the default window becomes more complex.

Eventually, only a subset of windows will be visible in overview mode.
SelectDefaultWindow() should pick a window from that subset. (as opposed to
selecting the topmost, possibly hidden, window)

I have also changed SelectDefaultWindow() such that it is no-op if there a no
windows in overview mode. This prevents exiting overview mode when no windows
are open

[sadrul, 2014/09/11 05:43:37]

If the user dismisses the overview mode without actually selecting a window,
then we should restore the window that was active before getting into overview
mode, even if it is currently out of view in overview mode. That's how the
tab-selector in chrome-android also works.

 }
 
-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::InstallAccelerators() {
+  const AcceleratorData accelerator_data[] = {
+      {TRIGGER_ON_PRESS, ui::VKEY_F6, ui::EF_NONE, CMD_TOGGLE_OVERVIEW,
+       AF_NONE},
+      {TRIGGER_ON_PRESS, ui::VKEY_F6, ui::EF_CONTROL_DOWN,
+       CMD_TOGGLE_SPLIT_VIEW, AF_NONE},
+  };
+  AcceleratorManager::Get()->RegisterAccelerators(
+      accelerator_data, arraysize(accelerator_data), this);
+}
+
+void WindowManagerImpl::AddObserver(WindowManagerObserver* observer) {
+  observers_.AddObserver(observer);
+}
+
+void WindowManagerImpl::RemoveObserver(WindowManagerObserver* observer) {
+  observers_.RemoveObserver(observer);
+}
+
+void WindowManagerImpl::ToggleSplitViewForTest() {
+  ToggleSplitview();
+}
+
+void WindowManagerImpl::OnSelectWindow(aura::Window* window,
+                                       SplitType split_type) {
+  ExitOverview(window, split_type);
 }
 
 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