Fix resize issues when using threaded compositing

content/renderer/render_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 "content/renderer/render_widget.h"
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 370 matching lines @@
 
   // Continue painting if necessary...
   DoDeferredUpdateAndSendInputAck();
 }
 
 bool RenderWidget::SupportsAsynchronousSwapBuffers()
 {
   return false;
 }
 
-void RenderWidget::OnSwapBuffersAborted()
-{
+void RenderWidget::OnSwapBuffersAborted() {
+  if (WebWidgetHandlesCompositorScheduling())
+    return;
+
   TRACE_EVENT0("renderer", "RenderWidget::OnSwapBuffersAborted");
   while (!updates_pending_swap_.empty()) {
     ViewHostMsg_UpdateRect* msg = updates_pending_swap_.front();
     updates_pending_swap_.pop();
     if (msg)
       Send(msg);
   }
   num_swapbuffers_complete_pending_ = 0;
   using_asynchronous_swapbuffers_ = false;
   // Schedule another frame so the compositor learns about it.
   scheduleComposite();
 }
 
 void RenderWidget::OnSwapBuffersPosted() {

[nduca, 2011/11/11 06:01:08]

Can we get rid of this completely? E.g. never use the swapbuffers posted
interface.

I'd really like to remove the web_view_ pointer on
WebGraphcsContext3DCommandBufferImpl, which is the route via which these are
traditionally called.

+  if (WebWidgetHandlesCompositorScheduling())
+    return;
+
   TRACE_EVENT0("renderer", "RenderWidget::OnSwapBuffersPosted");
 
   if (using_asynchronous_swapbuffers_) {
     ViewHostMsg_UpdateRect* msg = NULL;
     if (pending_update_params_.get()) {
       msg = new ViewHostMsg_UpdateRect(routing_id_, *pending_update_params_);
       pending_update_params_.reset();
     }
     updates_pending_swap_.push(msg);
     num_swapbuffers_complete_pending_++;
   }
 }
 
 void RenderWidget::OnSwapBuffersComplete() {
+  if (WebWidgetHandlesCompositorScheduling())
+    return;
+
   TRACE_EVENT0("renderer", "RenderWidget::OnSwapBuffersComplete");
   // When compositing deactivates, we reset the swapbuffers pending count.  The
   // swapbuffers acks may still arrive, however.
   if (num_swapbuffers_complete_pending_ == 0) {
     TRACE_EVENT0("renderer", "EarlyOut_ZeroSwapbuffersPending");
     return;
   }
   DCHECK(!updates_pending_swap_.empty());
   ViewHostMsg_UpdateRect* msg = updates_pending_swap_.front();
   updates_pending_swap_.pop();
@@ skipping 552 matching lines @@
 
 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_)
     using_asynchronous_swapbuffers_ = false;
+
+  // Clear out pending updates.
+  while (!updates_pending_swap_.empty()) {
+    ViewHostMsg_UpdateRect* msg = updates_pending_swap_.front();
+    updates_pending_swap_.pop();
+    if (msg)
+      Send(msg);
+  }
+}
+
+void RenderWidget::didBeginFrame()
+{
+  if (!WebWidgetHandlesCompositorScheduling())
+    return;
+
+  ViewHostMsg_UpdateRect* msg = NULL;
+  if (next_paint_flags_ || plugin_window_moves_.size()) {
+    DCHECK(!pending_update_params_.get());
+    pending_update_params_.reset(new ViewHostMsg_UpdateRect_Params);
+    pending_update_params_->view_size = size_;
+    pending_update_params_->resizer_rect = resizer_rect_;
+    pending_update_params_->plugin_window_moves.swap(plugin_window_moves_);
+    pending_update_params_->flags = next_paint_flags_;
+    pending_update_params_->scroll_offset = GetScrollOffset();
+    pending_update_params_->flags = next_paint_flags_;
+    next_paint_flags_ = 0;
+  }
+
+  if (pending_update_params_.get()) {
+    msg = new ViewHostMsg_UpdateRect(routing_id_, *pending_update_params_);
+    pending_update_params_.reset();
+  }
+  updates_pending_swap_.push(msg);
+}
+
+void RenderWidget::didFinishFrame()

[nduca, 2011/11/11 06:01:08]

One thing that nags me here is that Antoine's patch sends udpates on the swap
callback, which is the GPU process finishing the frame.

This does so when the compositor thread has submitted the frame to the gpu
process.

Which are we trying to do? Both? One? The other? I'm a bit confused.

+{
+  if (!WebWidgetHandlesCompositorScheduling())
+    return;
+
+  if (updates_pending_swap_.empty())
+    return;
+
+  ViewHostMsg_UpdateRect* msg = updates_pending_swap_.front();
+  updates_pending_swap_.pop();
+  if (msg) {
+    Send(msg);
+  }
 }
 
 void RenderWidget::scheduleComposite() {
   if (WebWidgetHandlesCompositorScheduling())
     webwidget_->composite(false);
   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
@@ skipping 496 matching lines @@
   }
 }
 
 bool RenderWidget::WillHandleMouseEvent(const WebKit::WebMouseEvent& event) {
   return false;
 }
 
 bool RenderWidget::WebWidgetHandlesCompositorScheduling() const {
   return false;
 }