Fix race conditions in window snapshot code.

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 350 matching lines @@
 }
 
 bool RenderWidget::UsingSynchronousRendererCompositor() const {
 #if defined(OS_ANDROID)
   return SynchronousCompositorFactory::GetInstance() != NULL;
 #else
   return false;
 #endif
 }
 
+void RenderWidget::ScheduleCompositeWithForcedRedraw() {
+  ScheduleCompositeImpl(true);
+}
+
+void RenderWidget::ScheduleCompositeImpl(bool force_redraw) {
+  if (compositor_ && force_redraw) {
+    // Regardless of whether threaded compositing is enabled, always
+    // use this mechanism to force the compositor to redraw. However,
+    // the invalidation code path below is still needed for the
+    // non-threaded case.
+    compositor_->SetNeedsForcedRedraw();
+  }
+
+  if (RenderThreadImpl::current()->compositor_message_loop_proxy().get() &&
+      compositor_) {
+    if (!force_redraw) {
+      compositor_->setNeedsRedraw();
+    }
+  } else {
+    // TODO(nduca): replace with something a little less hacky.  The reason this
+    // hack is still used is because the Invalidate-DoDeferredUpdate loop
+    // contains a lot of host-renderer synchronization logic that is still
+    // important for the accelerated compositing case. The option of simply
+    // duplicating all that code is less desirable than "faking out" the
+    // invalidation path using a magical damage rect.
+    didInvalidateRect(WebRect(0, 0, 1, 1));
+  }
+}
+
 bool RenderWidget::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(RenderWidget, message)
     IPC_MESSAGE_HANDLER(InputMsg_HandleInputEvent, OnHandleInputEvent)
     IPC_MESSAGE_HANDLER(InputMsg_CursorVisibilityChange,
                         OnCursorVisibilityChange)
     IPC_MESSAGE_HANDLER(InputMsg_MouseCaptureLost, OnMouseCaptureLost)
     IPC_MESSAGE_HANDLER(InputMsg_SetFocus, OnSetFocus)
     IPC_MESSAGE_HANDLER(ViewMsg_Close, OnClose)
     IPC_MESSAGE_HANDLER(ViewMsg_CreatingNew_ACK, OnCreatingNewAck)
@@ skipping 228 matching lines @@
   // If we sent an UpdateRect message with a zero-sized bitmap, then we should
   // have no current paint buffer.
   if (current_paint_buf_) {
     RenderProcess::current()->ReleaseTransportDIB(current_paint_buf_);
     current_paint_buf_ = NULL;
   }
 
   // If swapbuffers is still pending, then defer the update until the
   // swapbuffers occurs.
   if (num_swapbuffers_complete_pending_ >= kMaxSwapBuffersPending) {
+    LOG(INFO) << "EarlyOut_SwapStillPending";
     TRACE_EVENT0("renderer", "EarlyOut_SwapStillPending");
     return;
   }
 
   // Notify subclasses that software rendering was flushed to the screen.
   if (!is_accelerated_compositing_active_) {
     DidFlushPaint();
   }
 
   // Continue painting if necessary...
@@ skipping 132 matching lines @@
 
 void RenderWidget::OnViewContextSwapBuffersComplete() {
   TRACE_EVENT0("renderer", "RenderWidget::OnSwapBuffersComplete");
 
   // Notify subclasses that composited rendering was flushed to the screen.
   DidFlushPaint();
 
   // When compositing deactivates, we reset the swapbuffers pending count.  The
   // swapbuffers acks may still arrive, however.
   if (num_swapbuffers_complete_pending_ == 0) {
+    LOG(INFO) << "EarlyOut_ZeroSwapbuffersPending";
     TRACE_EVENT0("renderer", "EarlyOut_ZeroSwapbuffersPending");
     return;
   }
   DCHECK(!updates_pending_swap_.empty());
   ViewHostMsg_UpdateRect* msg = updates_pending_swap_.front();
   updates_pending_swap_.pop_front();
   // msg can be NULL if the swap doesn't correspond to an DoDeferredUpdate
   // compositing pass, hence doesn't require an UpdateRect message.
   if (msg)
     Send(msg);
   num_swapbuffers_complete_pending_--;
 
   // If update reply is still pending, then defer the update until that reply
   // occurs.
   if (update_reply_pending_) {
+    LOG(INFO) << "EarlyOut_UpdateReplyPending";
     TRACE_EVENT0("renderer", "EarlyOut_UpdateReplyPending");
     return;
   }
 
   // If we are not accelerated rendering, then this is a stale swapbuffers from
   // when we were previously rendering. However, if an invalidation task is not
   // posted, there may be software rendering work pending. In that case, don't
   // early out.
   if (!is_accelerated_compositing_active_ && invalidation_task_posted_) {
+    LOG(INFO) << "EarlyOut_AcceleratedCompositingOff";
     TRACE_EVENT0("renderer", "EarlyOut_AcceleratedCompositingOff");
     return;
   }
 
   // Do not call DoDeferredUpdate unless there's animation work to be done or
   // a real invalidation. This prevents rendering in response to a swapbuffers
   // callback coming back after we've navigated away from the page that
   // generated it.
   if (!animation_update_pending_ && !paint_aggregator_.HasPendingUpdate()) {
+    LOG(INFO) << "EarlyOut_NoPendingUpdate";
     TRACE_EVENT0("renderer", "EarlyOut_NoPendingUpdate");
     return;
   }
 
   // Continue painting if necessary...
   DoDeferredUpdateAndSendInputAck();
 }
 
 void RenderWidget::OnHandleInputEvent(const WebKit::WebInputEvent* input_event,
                                       const ui::LatencyInfo& latency_info,
@@ skipping 264 matching lines @@
   paint.setStrokeWidth(1);
 
   SkIRect irect;
   irect.set(rect.x(), rect.y(), rect.right() - 1, rect.bottom() - 1);
   canvas->drawIRect(irect, paint);
 }
 
 void RenderWidget::AnimationCallback() {
   TRACE_EVENT0("renderer", "RenderWidget::AnimationCallback");
   if (!animation_update_pending_) {
+    LOG(INFO) << "EarlyOut_NoAnimationUpdatePending";
     TRACE_EVENT0("renderer", "EarlyOut_NoAnimationUpdatePending");
     return;
   }
   if (!animation_floor_time_.is_null() && IsRenderingVSynced()) {
     // Record when we fired (according to base::Time::Now()) relative to when
     // we posted the task to quantify how much the base::Time/base::TimeTicks
     // skew is affecting animations.
     base::TimeDelta animation_callback_delay = base::Time::Now() -
         (animation_floor_time_ - base::TimeDelta::FromMilliseconds(16));
     UMA_HISTOGRAM_CUSTOM_TIMES("Renderer4.AnimationCallbackDelayTime",
@@ skipping 30 matching lines @@
     animation_update_pending_ = false;
     if (is_accelerated_compositing_active_ && compositor_) {
       compositor_->Animate(base::TimeTicks::Now());
     } else {
       double frame_begin_time =
         (base::TimeTicks::Now() - base::TimeTicks()).InSecondsF();
       webwidget_->animate(frame_begin_time);
     }
     return;
   }
+  LOG(INFO) << "EarlyOut_AnimatedTooRecently";
   TRACE_EVENT0("renderer", "EarlyOut_AnimatedTooRecently");
   if (!animation_timer_.IsRunning()) {
     // This code uses base::Time::Now() to calculate the floor and next fire
     // time because javascript's Date object uses base::Time::Now().  The
     // message loop uses base::TimeTicks, which on windows can have a
     // different granularity than base::Time.
     // The upshot of all this is that this function might be called before
     // base::Time::Now() has advanced past the animation_floor_time_.  To
     // avoid exposing this delay to javascript, we keep posting delayed
     // tasks until base::Time::Now() has advanced far enough.
@@ skipping 25 matching lines @@
 }
 
 void RenderWidget::DoDeferredUpdate() {
   TRACE_EVENT0("renderer", "RenderWidget::DoDeferredUpdate");
   TRACE_EVENT_SCOPED_SAMPLING_STATE("Chrome", "Paint");
 
   if (!webwidget_)
     return;
 
   if (!init_complete_) {
+    LOG(INFO) << "EarlyOut_InitNotComplete";
     TRACE_EVENT0("renderer", "EarlyOut_InitNotComplete");
     return;
   }
   if (update_reply_pending_) {
+    LOG(INFO) << "EarlyOut_UpdateReplyPending";
     TRACE_EVENT0("renderer", "EarlyOut_UpdateReplyPending");
     return;
   }
   if (is_accelerated_compositing_active_ &&
       num_swapbuffers_complete_pending_ >= kMaxSwapBuffersPending) {
+    LOG(INFO) << "EarlyOut_MaxSwapBuffersPending";
     TRACE_EVENT0("renderer", "EarlyOut_MaxSwapBuffersPending");
     return;
   }
 
   // Suppress updating when we are hidden.
   if (is_hidden_ || size_.IsEmpty() || is_swapped_out_) {
     paint_aggregator_.ClearPendingUpdate();
     needs_repainting_on_restore_ = true;
+    LOG(INFO) << "EarlyOut_NotVisible";
     TRACE_EVENT0("renderer", "EarlyOut_NotVisible");
     return;
   }
 
   // Tracking of frame rate jitter
   base::TimeTicks frame_begin_ticks = base::TimeTicks::Now();
   InstrumentWillBeginFrame();
   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();
 
   // Check for whether we need to track swap buffers. We need to do that after
   // layout() because it may have switched us to accelerated compositing.
   if (is_accelerated_compositing_active_)
     using_asynchronous_swapbuffers_ = SupportsAsynchronousSwapBuffers();
 
   // The following two can result in further layout and possibly
   // enable GPU acceleration so they need to be called before any painting
   // is done.
   UpdateTextInputType();
   UpdateSelectionBounds();
 
   // Suppress painting if nothing is dirty.  This has to be done after updating
   // animations running layout as these may generate further invalidations.
   if (!paint_aggregator_.HasPendingUpdate()) {
+    LOG(INFO) << "EarlyOut_NoPendingUpdate";
     TRACE_EVENT0("renderer", "EarlyOut_NoPendingUpdate");
     InstrumentDidCancelFrame();
     return;
   }
 
   if (!is_accelerated_compositing_active_ &&
       !is_threaded_compositing_enabled_ &&
       ForceCompositingModeEnabled()) {
     webwidget_->enterForceCompositingMode(true);
   }
@@ skipping 411 matching lines @@
   params.scroll_offset = GetScrollOffset();
   params.needs_ack = false;
   params.scale_factor = device_scale_factor_;
 
   Send(new ViewHostMsg_UpdateRect(routing_id_, params));
   next_paint_flags_ = 0;
   need_update_rect_for_auto_resize_ = false;
 }
 
 void RenderWidget::scheduleComposite() {
-  if (RenderThreadImpl::current()->compositor_message_loop_proxy().get() &&
-      compositor_) {
-    compositor_->setNeedsRedraw();
-  } else {
-    // TODO(nduca): replace with something a little less hacky.  The reason this
-    // hack is still used is because the Invalidate-DoDeferredUpdate loop
-    // contains a lot of host-renderer synchronization logic that is still
-    // important for the accelerated compositing case. The option of simply
-    // duplicating all that code is less desirable than "faking out" the
-    // invalidation path using a magical damage rect.
-    didInvalidateRect(WebRect(0, 0, 1, 1));
-  }
+  ScheduleCompositeImpl(false);
 }
 
 void RenderWidget::scheduleAnimation() {
   if (animation_update_pending_)
     return;
 
   TRACE_EVENT0("gpu", "RenderWidget::scheduleAnimation");
   animation_update_pending_ = true;
   if (!animation_timer_.IsRunning()) {
     animation_timer_.Start(FROM_HERE, base::TimeDelta::FromSeconds(0), this,
@@ skipping 844 matching lines @@
 
   if (!context->InitializeWithDefaultBufferSizes(
           attributes,
           false /* bind generates resources */,
           CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE))
     return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();
   return context.Pass();
 }
 
 }  // namespace content