Pass the size to the RenderView on creation.

content/browser/renderer_host/render_widget_host_impl.cc

 // Copyright (c) 2012 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 "content/browser/renderer_host/render_widget_host_impl.h"
 
 #include <math.h>
 #include <set>
 #include <utility>
 
@@ skipping 149 matching lines @@
                                            bool hidden)
     : view_(NULL),
       renderer_initialized_(false),
       hung_renderer_delay_ms_(kHungRendererDelayMs),
       delegate_(delegate),
       process_(process),
       routing_id_(routing_id),
       surface_id_(0),
       is_loading_(false),
       is_hidden_(hidden),
-      is_fullscreen_(false),
       repaint_ack_pending_(false),
       resize_ack_pending_(false),
       screen_info_out_of_date_(false),
-      top_controls_layout_height_(0.f),
       should_auto_resize_(false),
       waiting_for_screen_rects_ack_(false),
       needs_repainting_on_restore_(false),
       is_unresponsive_(false),
       in_flight_event_count_(0),
       in_get_backing_store_(false),
       ignore_input_events_(false),
       input_method_active_(false),
       text_direction_updated_(false),
       text_direction_(blink::WebTextDirectionLeftToRight),
@@ skipping 372 matching lines @@
   // By invoking WasResized the renderer is updated as necessary. WasResized
   // does nothing if the sizes are already in sync.
   //
   // TODO: ideally ViewMsg_WasShown would take a size. This way, the renderer
   // could handle both the restore and resize at once. This isn't that big a
   // deal as RenderWidget::WasShown delays updating, so that the resize from
   // WasResized is usually processed before the renderer is painted.
   WasResized();
 }
 
+void RenderWidgetHostImpl::GetResizeParams(
+    ViewMsg_Resize_Params* resize_params) {
+  if (!screen_info_) {
+    screen_info_.reset(new blink::WebScreenInfo);
+    GetWebScreenInfo(screen_info_.get());
+  }
+  resize_params->screen_info = *screen_info_;
+  resize_params->new_size =
+      (view_) ? view_->GetRequestedRendererSize() : gfx::Size();

[piman, 2014/10/29 18:42:57]

nit: no need for () around view_.

It might be more readable to write:
if (view_) {
  resize_params->new_size = view_->GetRequestedRendererSize();
  resize_params->physical_backing_size = view_->GetPhysicalBackingSize();
  [...]
} else {
  resize_params->new_size = gfx::Size();
  resize_params->physical_backing_size = gfx::Size();
  [...]
}

Or even better, start the method with *resize_params = ViewMsg_Resize_Params();
and drop the else part.
Or maybe even, rely on the fact that the passed resize_params was initialized by
the caller.

[mkosiba (inactive), 2014/10/31 14:35:06]

All are great suggestions! I think I'll go with this one. It's less typing and
having a "fill this struct in please" method that may leave the struct
half-initialized sounds like asking for heizenbugs.

+  resize_params->resizer_rect = GetRootWindowResizerRect();
+  resize_params->physical_backing_size =
+      (view_) ? view_->GetPhysicalBackingSize() : gfx::Size();
+  resize_params->top_controls_layout_height =
+      (view_) ? view_->GetTopControlsLayoutHeight() : 0.f;
+  resize_params->visible_viewport_size =
+      (view_) ? view_->GetVisibleViewportSize() : gfx::Size();
+  resize_params->is_fullscreen = IsFullscreen();
+}
+
+void RenderWidgetHostImpl::GetNewViewResizeParams(
+    ViewMsg_Resize_Params* resize_params) {
+  GetResizeParams(resize_params);
+
+  // We don't expect to receive an ACK when the requested size or the physical
+  // backing size is empty, or when the main viewport size didn't change.
+  if (!resize_params->new_size.IsEmpty() &&
+      !resize_params->physical_backing_size.IsEmpty()) {
+    resize_ack_pending_ = g_check_for_pending_resize_ack;

[piman, 2014/10/29 18:42:57]

MMh, I certainly would not expect GetNewViewResizeParams to have a side effect.
I would prefer if this was done via an explicit call, e.g.
SetInitialResizeParams(const ViewMsg_Resize_Params& resize_params) that would be
called after sending the initial message (and RVHI can call GetResizeParams
directly).

[mkosiba (inactive), 2014/10/31 14:35:06]

that does indeed sound better. I guess I was trying too hard to roll it up into
one method.

+  }
+
+  DCHECK(!old_resize_params_);
+  old_resize_params_ =
+      make_scoped_ptr(new ViewMsg_Resize_Params(*resize_params));
+}
+
 void RenderWidgetHostImpl::WasResized() {
   // Skip if the |delegate_| has already been detached because
   // it's web contents is being deleted.
   if (resize_ack_pending_ || !process_->HasConnection() || !view_ ||
       !renderer_initialized_ || should_auto_resize_ || !delegate_) {
     return;
   }
 
-  gfx::Size new_size(view_->GetRequestedRendererSize());
+  bool size_changed = false;
+  bool side_payload_changed = screen_info_out_of_date_;
+  scoped_ptr<ViewMsg_Resize_Params> params(new ViewMsg_Resize_Params);
 
-  gfx::Size old_physical_backing_size = physical_backing_size_;
-  physical_backing_size_ = view_->GetPhysicalBackingSize();
-  bool was_fullscreen = is_fullscreen_;
-  is_fullscreen_ = IsFullscreen();
-  float old_top_controls_layout_height =
-      top_controls_layout_height_;
-  top_controls_layout_height_ =
-      view_->GetTopControlsLayoutHeight();
-  gfx::Size old_visible_viewport_size = visible_viewport_size_;
-  visible_viewport_size_ = view_->GetVisibleViewportSize();
-
-  bool size_changed = new_size != last_requested_size_;
-  bool side_payload_changed =
-      screen_info_out_of_date_ ||
-      old_physical_backing_size != physical_backing_size_ ||
-      was_fullscreen != is_fullscreen_ ||
-      old_top_controls_layout_height !=
-          top_controls_layout_height_ ||
-      old_visible_viewport_size != visible_viewport_size_;
+  GetResizeParams(params.get());
+  if (old_resize_params_) {
+    size_changed = old_resize_params_->new_size != params->new_size;
+    side_payload_changed =
+        side_payload_changed ||
+        old_resize_params_->physical_backing_size !=
+            params->physical_backing_size ||
+        old_resize_params_->is_fullscreen != params->is_fullscreen ||
+        old_resize_params_->top_controls_layout_height !=
+            params->top_controls_layout_height ||
+        old_resize_params_->visible_viewport_size !=
+            params->visible_viewport_size;
+  }
 
   if (!size_changed && !side_payload_changed)
     return;
 
-  if (!screen_info_) {
-    screen_info_.reset(new blink::WebScreenInfo);
-    GetWebScreenInfo(screen_info_.get());
+  // We don't expect to receive an ACK when the requested size or the physical
+  // backing size is empty, or when the main viewport size didn't change.
+  if (!params->new_size.IsEmpty() && !params->physical_backing_size.IsEmpty() &&
+      size_changed) {
+    resize_ack_pending_ = g_check_for_pending_resize_ack;
   }
 
-  // We don't expect to receive an ACK when the requested size or the physical
-  // backing size is empty, or when the main viewport size didn't change.
-  if (!new_size.IsEmpty() && !physical_backing_size_.IsEmpty() && size_changed)
-    resize_ack_pending_ = g_check_for_pending_resize_ack;
-
-  ViewMsg_Resize_Params params;
-  params.screen_info = *screen_info_;
-  params.new_size = new_size;
-  params.physical_backing_size = physical_backing_size_;
-  params.top_controls_layout_height = top_controls_layout_height_;
-  params.visible_viewport_size = visible_viewport_size_;
-  params.resizer_rect = GetRootWindowResizerRect();
-  params.is_fullscreen = is_fullscreen_;
-  if (!Send(new ViewMsg_Resize(routing_id_, params))) {
+  if (!Send(new ViewMsg_Resize(routing_id_, *params))) {
     resize_ack_pending_ = false;
   } else {
-    last_requested_size_ = new_size;
+    old_resize_params_.swap(params);
   }
 }
 
 void RenderWidgetHostImpl::ResizeRectChanged(const gfx::Rect& new_rect) {
   Send(new ViewMsg_ChangeResizeRect(routing_id_, new_rect));
 }
 
 void RenderWidgetHostImpl::GotFocus() {
   Focus();
   if (delegate_)
@@ skipping 1767 matching lines @@
 }
 #endif
 
 SkColorType RenderWidgetHostImpl::PreferredReadbackFormat() {
   if (view_)
     return view_->PreferredReadbackFormat();
   return kN32_SkColorType;
 }
 
 }  // namespace content