Makes sure widget is created at right size before showing

views/widget/widget.cc

 // Copyright (c) 2011 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 "views/widget/widget.h"
 
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/utf_string_conversions.h"
 #include "ui/base/l10n/l10n_font_util.h"
@@ skipping 78 matching lines @@
       delegate(NULL),
       child(false),
       transient(false),
       transparent(false),
       accept_events(true),
       can_activate(true),
       keep_on_top(false),
       ownership(NATIVE_WIDGET_OWNS_WIDGET),
       mirror_origin_in_rtl(false),
       has_dropshadow(false),
+      maximize(false),
       double_buffer(false),
       parent(NULL),
       parent_widget(NULL),
       native_widget(NULL) {
 }
 
 Widget::InitParams::InitParams(Type type)
     : type(type),
       delegate(NULL),
       child(type == TYPE_CONTROL),
       transient(type == TYPE_POPUP || type == TYPE_MENU),
       transparent(false),
       accept_events(true),
       can_activate(type != TYPE_POPUP && type != TYPE_MENU),
       keep_on_top(type == TYPE_MENU),
       ownership(NATIVE_WIDGET_OWNS_WIDGET),
       mirror_origin_in_rtl(false),
       has_dropshadow(false),
+      maximize(false),
       double_buffer(false),
       parent(NULL),
       parent_widget(NULL),
       native_widget(NULL) {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Widget, public:
 
 // static
@@ skipping 136 matching lines @@
   ownership_ = params.ownership;
   native_widget_ = params.native_widget ?
       params.native_widget->AsNativeWidgetPrivate() :
       internal::NativeWidgetPrivate::CreateNativeWidget(this);
   GetRootView();
   default_theme_provider_.reset(new DefaultThemeProvider);
   if (params.type == InitParams::TYPE_MENU) {
     is_mouse_button_pressed_ =
         internal::NativeWidgetPrivate::IsMouseButtonDown();
   }
-  native_widget_->InitNativeWidget(params);
+  InitParams params_copy(params);
   if (params.type == InitParams::TYPE_WINDOW) {
+    // If we're creating a window see if the delegate wants us to use a size
+    // different than that supplied to the constructor.
+    gfx::Rect saved_bounds;
+    bool saved_maximized_state;
+    if (GetSavedBounds(&saved_bounds, &saved_maximized_state)) {
+      params_copy.maximize = saved_maximized_state;
+      params_copy.bounds = saved_bounds;
+    }
+  }
+  native_widget_->InitNativeWidget(params_copy);
+  if (params.type == InitParams::TYPE_WINDOW) {
+    // Create the ClientView, add it to the NonClientView and add the
+    // NonClientView to the RootView. This will cause everything to be parented.
     non_client_view_ = new NonClientView;
     non_client_view_->SetFrameView(CreateNonClientFrameView());
-    // Create the ClientView, add it to the NonClientView and add the
-    // NonClientView to the RootView. This will cause everything to be parented.
     non_client_view_->set_client_view(widget_delegate_->CreateClientView(this));
     SetContentsView(non_client_view_);
     SetInitialBounds(params.bounds);
     UpdateWindowTitle();
   }
 }
 
 // Unconverted methods (see header) --------------------------------------------
 
 gfx::NativeView Widget::GetNativeView() const {
@@ skipping 116 matching lines @@
 }
 
 void Widget::EnableClose(bool enable) {
   if (non_client_view_)
     non_client_view_->EnableClose(enable);
   native_widget_->EnableClose(enable);
 }
 
 void Widget::Show() {
   if (non_client_view_) {
-    native_widget_->ShowNativeWidget(
-        saved_maximized_state_ ? internal::NativeWidgetPrivate::SHOW_MAXIMIZED
-                               : internal::NativeWidgetPrivate::SHOW_RESTORED);
+    if (saved_maximized_state_ && !initial_restored_bounds_.IsEmpty()) {
+      native_widget_->ShowMaximized(initial_restored_bounds_);
+    } else {
+      native_widget_->ShowNativeWidget(saved_maximized_state_ ?
+          internal::NativeWidgetPrivate::SHOW_MAXIMIZED :
+          internal::NativeWidgetPrivate::SHOW_RESTORED);
+    }
     // |saved_maximized_state_| only applies the first time the window is shown.
     // If we don't reset the value the window will be shown maximized every time
     // it is subsequently shown after being hidden.
     saved_maximized_state_ = false;
   } else {
     native_widget_->Show();
   }
 }
 
 void Widget::Hide() {
@@ skipping 537 matching lines @@
   bool maximized;
   gfx::Rect bounds;
   native_widget_->GetWindowBoundsAndMaximizedState(&bounds, &maximized);
   widget_delegate_->SaveWindowPlacement(bounds, maximized);
 }
 
 void Widget::SetInitialBounds(const gfx::Rect& bounds) {
   if (!non_client_view_)
     return;
 
-  // First we obtain the window's saved show-style and store it. We need to do
-  // this here, rather than in Show() because by the time Show() is called,
-  // the window's size will have been reset (below) and the saved maximized
-  // state will have been lost. Sadly there's no way to tell on Windows when
-  // a window is restored from maximized state, so we can't more accurately
-  // track maximized state independently of sizing information.
-  widget_delegate_->GetSavedMaximizedState(
-      &saved_maximized_state_);
-
-  // Restore the window's placement from the controller.
-  gfx::Rect saved_bounds = bounds;
-  if (widget_delegate_->GetSavedWindowBounds(&saved_bounds)) {
-    if (!widget_delegate_->ShouldRestoreWindowSize()) {
-      saved_bounds.set_size(non_client_view_->GetPreferredSize());
+  gfx::Rect saved_bounds;
+  if (GetSavedBounds(&saved_bounds, &saved_maximized_state_)) {
+    if (saved_maximized_state_) {
+      // If we're going to maximize, wait until Show is invoked to set the
+      // bounds. That way we avoid a noticable resize.
+      initial_restored_bounds_ = saved_bounds;
     } else {
-      // Make sure the bounds are at least the minimum size.
-      if (saved_bounds.width() < minimum_size_.width()) {
-        saved_bounds.SetRect(saved_bounds.x(), saved_bounds.y(),
-                             saved_bounds.right() + minimum_size_.width() -
-                                 saved_bounds.width(),
-                             saved_bounds.bottom());
-      }
-
-      if (saved_bounds.height() < minimum_size_.height()) {
-        saved_bounds.SetRect(saved_bounds.x(), saved_bounds.y(),
-                             saved_bounds.right(),
-                             saved_bounds.bottom() + minimum_size_.height() -
-                                 saved_bounds.height());
-      }
+      SetBounds(saved_bounds);
     }
-
-    // Widget's SetBounds method does not further modify the bounds that are
-    // passed to it.
-    SetBounds(saved_bounds);
   } else {
     if (bounds.IsEmpty()) {
       // No initial bounds supplied, so size the window to its content and
       // center over its parent.
       native_widget_->CenterWindow(non_client_view_->GetPreferredSize());
     } else {
       // Use the supplied initial bounds.
       SetBoundsConstrained(bounds, NULL);
     }
   }
 }
 
+bool Widget::GetSavedBounds(gfx::Rect* bounds, bool* maximize) {
+  // First we obtain the window's saved show-style and store it. We need to do
+  // this here, rather than in Show() because by the time Show() is called,
+  // the window's size will have been reset (below) and the saved maximized
+  // state will have been lost. Sadly there's no way to tell on Windows when
+  // a window is restored from maximized state, so we can't more accurately
+  // track maximized state independently of sizing information.
+  widget_delegate_->GetSavedMaximizedState(maximize);
+
+  // Restore the window's placement from the controller.
+  if (widget_delegate_->GetSavedWindowBounds(bounds)) {
+    if (!widget_delegate_->ShouldRestoreWindowSize()) {
+      if (!non_client_view_) {
+        // This may be invoked before the non_client_view_ is created.
+        return false;
+      }
+      bounds->set_size(non_client_view_->GetPreferredSize());
+    } else {
+      // Make sure the bounds are at least the minimum size.
+      if (bounds->width() < minimum_size_.width())
+        bounds->set_width(minimum_size_.width());
+
+      if (bounds->height() < minimum_size_.height())
+        bounds->set_height(minimum_size_.height());
+    }
+    return true;
+  }
+  return false;
+}
+
 namespace internal {
 
 ////////////////////////////////////////////////////////////////////////////////
 // internal::NativeWidgetPrivate, NativeWidget implementation:
 
 internal::NativeWidgetPrivate* NativeWidgetPrivate::AsNativeWidgetPrivate() {
   return this;
 }
 
 }  // namespace internal
 }  // namespace views