Defer render_widget draw until host window is available

content/renderer/render_widget.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/renderer/render_widget.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
@@ skipping 56 matching lines @@
 using WebKit::WebVector;
 using WebKit::WebWidget;
 using content::RenderThread;
 
 RenderWidget::RenderWidget(WebKit::WebPopupType popup_type)
     : routing_id_(MSG_ROUTING_NONE),
       surface_id_(0),
       webwidget_(NULL),
       opener_id_(MSG_ROUTING_NONE),
       host_window_(0),
+      host_window_set_(false),
       current_paint_buf_(NULL),
       next_paint_flags_(0),
       filtered_time_per_frame_(0.0f),
       update_reply_pending_(false),
       using_asynchronous_swapbuffers_(false),
       num_swapbuffers_complete_pending_(0),
       did_show_(false),
       is_hidden_(false),
       is_fullscreen_(false),
       needs_repainting_on_restore_(false),
@@ skipping 80 matching lines @@
   }
 }
 
 // This is used to complete pending inits and non-pending inits. For non-
 // pending cases, the parent will be the same as the current parent. This
 // indicates we do not need to reparent or anything.
 void RenderWidget::CompleteInit(gfx::NativeViewId parent_hwnd) {
   DCHECK(routing_id_ != MSG_ROUTING_NONE);
 
   host_window_ = parent_hwnd;
+  host_window_set_ = true;
+
+  DoDeferredUpdate();
 
   Send(new ViewHostMsg_RenderViewReady(routing_id_));
 }
 
 void RenderWidget::SetSwappedOut(bool is_swapped_out) {
   // We should only toggle between states.
   DCHECK(is_swapped_out_ != is_swapped_out);
   is_swapped_out_ = is_swapped_out;
 
   // If we are swapping out, we will call ReleaseProcess, allowing the process
@@ skipping 546 matching lines @@
 
   if (pending_input_event_ack_.get())
     Send(pending_input_event_ack_.release());
 }
 
 void RenderWidget::DoDeferredUpdate() {
   TRACE_EVENT0("renderer", "RenderWidget::DoDeferredUpdate");
 
   if (!webwidget_)
     return;
+
+  if (!host_window_set_) {
+    TRACE_EVENT0("renderer", "EarlyOut_NoHostWindow");
+    return;
+  }
   if (update_reply_pending_) {
     TRACE_EVENT0("renderer", "EarlyOut_UpdateReplyPending");
     return;
   }
   if (is_accelerated_compositing_active_ &&
       num_swapbuffers_complete_pending_ >= kMaxSwapBuffersPending) {
     TRACE_EVENT0("renderer", "EarlyOut_MaxSwapBuffersPending");
     return;
   }
 
   // Suppress updating when we are hidden.
   if (is_hidden_ || size_.IsEmpty()) {
     paint_aggregator_.ClearPendingUpdate();
     needs_repainting_on_restore_ = true;
     TRACE_EVENT0("renderer", "EarlyOut_NotVisible");
     return;
   }
 
+  if (is_accelerated_compositing_active_)
+    using_asynchronous_swapbuffers_ = SupportsAsynchronousSwapBuffers();
+
   // Tracking of frame rate jitter
   base::TimeTicks frame_begin_ticks = base::TimeTicks::Now();
   AnimateIfNeeded();
 
   // Layout may generate more invalidation.  It may also enable the
   // GPU acceleration, so make sure to run layout before we send the
   // GpuRenderingActivated message.
   webwidget_->layout();
 
   // Suppress painting if nothing is dirty.  This has to be done after updating
@@ skipping 239 matching lines @@
     // round-trips to the browser's UI thread before finishing the frame,
     // causing deadlocks if we delay the UpdateRect until we receive the
     // OnSwapBuffersComplete.  So send a dummy message that will unblock the
     // browser's UI thread.
     Send(new ViewHostMsg_UpdateIsDelayed(routing_id_));
   }
 
   is_accelerated_compositing_active_ = true;
   Send(new ViewHostMsg_DidActivateAcceleratedCompositing(
       routing_id_, is_accelerated_compositing_active_));
-
-  // Note: asynchronous swapbuffer support currently only matters if
-  // compositing scheduling happens on the RenderWidget.
-  using_asynchronous_swapbuffers_ = SupportsAsynchronousSwapBuffers();
 }
 
 void RenderWidget::didDeactivateCompositor() {
   TRACE_EVENT0("gpu", "RenderWidget::didDeactivateCompositor");
 
   is_accelerated_compositing_active_ = false;
   Send(new ViewHostMsg_DidActivateAcceleratedCompositing(
       routing_id_, is_accelerated_compositing_active_));
 
   if (using_asynchronous_swapbuffers_)
@@ skipping 470 matching lines @@
   }
   return ui::TEXT_INPUT_TYPE_NONE;
 }
 
 bool RenderWidget::CanComposeInline() {
   return true;
 }
 
 WebScreenInfo RenderWidget::screenInfo() {
   WebScreenInfo results;
-  if (host_window_)
+  if (host_window_set_)
     Send(new ViewHostMsg_GetScreenInfo(routing_id_, host_window_, &results));
   else {
     DLOG(WARNING) << "Unable to retrieve screen information, no host window";
 #if defined(USE_AURA)
     // TODO(backer): Remove this a temporary workaround for crbug.com/111929
     // once we get a proper fix.
     results.availableRect.width = 1000;
     results.availableRect.height = 1000;
 #endif
   }
@@ skipping 51 matching lines @@
   }
 }
 
 bool RenderWidget::WillHandleMouseEvent(const WebKit::WebMouseEvent& event) {
   return false;
 }
 
 bool RenderWidget::WebWidgetHandlesCompositorScheduling() const {
   return false;
 }