Defer maximize mode bounds updates until after exiting overview.

ash/wm/maximize_mode/maximize_mode_window_state.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 "ash/wm/maximize_mode/maximize_mode_window_state.h"
 
 #include "ash/display/display_controller.h"
 #include "ash/screen_util.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/coordinate_conversion.h"
 #include "ash/wm/maximize_mode/maximize_mode_window_manager.h"
 #include "ash/wm/window_animations.h"
 #include "ash/wm/window_properties.h"
 #include "ash/wm/window_state_delegate.h"
 #include "ash/wm/window_state_util.h"
 #include "ash/wm/window_util.h"
 #include "ash/wm/wm_event.h"
 #include "ash/wm/workspace/workspace_window_resizer.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
+#include "ui/compositor/layer.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/rect.h"
 #include "ui/views/view_constants_aura.h"
 #include "ui/views/widget/widget.h"
 
 namespace ash {
 namespace {
 
 // Returns the biggest possible size for a window which is about to be
 // maximized.
@@ skipping 58 matching lines @@
   if (animated)
     window_state->SetBoundsDirect(bounds_in_parent);
   else
     window_state->SetBoundsDirectAnimated(bounds_in_parent);
 }
 
 MaximizeModeWindowState::MaximizeModeWindowState(
     aura::Window* window, MaximizeModeWindowManager* creator)
     : window_(window),
       creator_(creator),
-      current_state_type_(wm::GetWindowState(window)->GetStateType()) {
+      current_state_type_(wm::GetWindowState(window)->GetStateType()),
+      defer_bounds_updates_(false) {
   old_state_.reset(
       wm::GetWindowState(window)->SetStateObject(
           scoped_ptr<State>(this).Pass()).release());
 }
 
 MaximizeModeWindowState::~MaximizeModeWindowState() {
   creator_->WindowStateDestroyed(window_);
 }
 
 void MaximizeModeWindowState::LeaveMaximizeMode(wm::WindowState* window_state) {
   // Note: When we return we will destroy ourselves with the |our_reference|.
   scoped_ptr<wm::WindowState::State> our_reference =
       window_state->SetStateObject(old_state_.Pass());
 }
 
+void MaximizeModeWindowState::SetDeferBoundsUpdates(bool defer_bounds_updates) {
+  if (defer_bounds_updates_ == defer_bounds_updates)
+    return;
+
+  defer_bounds_updates_ = defer_bounds_updates;
+  if (!defer_bounds_updates_)
+    UpdateBounds(wm::GetWindowState(window_), true);
+}
+
 void MaximizeModeWindowState::OnWMEvent(wm::WindowState* window_state,
                                         const wm::WMEvent* event) {
   switch (event->type()) {
     case wm::WM_EVENT_TOGGLE_FULLSCREEN:
       ToggleFullScreen(window_state, window_state->delegate());
       break;
     case wm::WM_EVENT_FULLSCREEN:
       UpdateWindow(window_state, wm::WINDOW_STATE_TYPE_FULLSCREEN, true);
       break;
     case wm::WM_EVENT_TOGGLE_MAXIMIZE_CAPTION:
@@ skipping 146 matching lines @@
 }
 
 wm::WindowStateType MaximizeModeWindowState::GetMaximizedOrCenteredWindowType(
       wm::WindowState* window_state) {
   return window_state->CanMaximize() ? wm::WINDOW_STATE_TYPE_MAXIMIZED :
                                        wm::WINDOW_STATE_TYPE_NORMAL;
 }
 
 void MaximizeModeWindowState::UpdateBounds(wm::WindowState* window_state,
                                            bool animated) {
+  if (defer_bounds_updates_)

[Mr4D (OOO till 08-26), 2014/09/23 22:27:14]

Just checking - you don't want the window to change when the user rotates the
screen and / or attaches an external screen?

[flackr, 2014/09/30 16:42:29]

As long as the window is in overview, it should be fine to defer the bounds
update. I have tried a few things to do the bounds update immediately but it's
challenging to get it to work correctly as crossfade is called more than once.

+    return;
   gfx::Rect bounds_in_parent = GetBoundsInMaximizedMode(window_state);
   // If we have a target bounds rectangle, we center it and set it
   // accordingly.
   if (!bounds_in_parent.IsEmpty() &&
       bounds_in_parent != window_state->window()->bounds()) {
     if (current_state_type_ == wm::WINDOW_STATE_TYPE_MINIMIZED ||
         !window_state->window()->IsVisible() ||
         !animated) {
       window_state->SetBoundsDirect(bounds_in_parent);
     } else {
       // If we animate (to) maximized mode, we want to use the cross fade to
       // avoid flashing.
       if (window_state->IsMaximized())
         window_state->SetBoundsDirectCrossFade(bounds_in_parent);
       else
         window_state->SetBoundsDirectAnimated(bounds_in_parent);
     }
   }
 }
 
 }  // namespace ash