athena: Fix overview mode for split-view mode.

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 164 matching lines @@
 }
 
 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) {
-    split_view_controller_->DeactivateSplitMode();
     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(), this);
+        container_.get(), window_list_provider_.get(),
+        split_view_controller_.get(), this);
   } else {
-    CHECK(!split_view_controller_->IsSplitViewModeActive());
     overview_.reset();
     FOR_EACH_OBSERVER(WindowManagerObserver, observers_, OnOverviewModeExit());
   }
 }
 
 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::OnSelectWindow(aura::Window* window) {
+  if (split_view_controller_->IsSplitViewModeActive())
+    split_view_controller_->DeactivateSplitMode();
   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);
   split_view_controller_->ActivateSplitMode(left, right);
 }
 
 void WindowManagerImpl::OnWindowAdded(aura::Window* new_window) {
   // TODO(oshima): Creating a new window should updates the ovewview mode
@@ skipping 106 matching lines @@
                    base::Unretained(next_window),
                    window->bounds(),
                    gfx::Transform())));
 
     gfx::Transform transform;
     transform.Scale(window->bounds().width() / next_window->bounds().width(),
                     window->bounds().height() / next_window->bounds().height());
     transform.Translate(window->bounds().x() - next_window->bounds().x(), 0);
     next_window->SetTransform(transform);
 
-    OnSelectWindow(next_window);
+    wm::ActivateWindow(next_window);
   }
   window->Hide();
 }
 
 void WindowManagerImpl::OnTitleDragCanceled(aura::Window* window) {
   aura::Window* next_window = GetWindowBehind(window);
   if (!next_window)
     return;
   next_window->SetTransform(gfx::Transform());
   next_window->Hide();
@@ skipping 14 matching lines @@
   DCHECK(!instance);
 }
 
 // static
 WindowManager* WindowManager::GetInstance() {
   DCHECK(instance);
   return instance;
 }
 
 }  // namespace athena