Fix resize issues when using threaded compositing

content/renderer/render_widget.cc

Index: content/renderer/render_widget.cc
diff --git a/content/renderer/render_widget.cc b/content/renderer/render_widget.cc
index 1a5038fd8988908a76e30d4f57f16ee5d222bd6b..1729aced25563227bfab9b38eb6a34f773c91d1e 100644
--- a/content/renderer/render_widget.cc
+++ b/content/renderer/render_widget.cc
@@ -388,8 +388,10 @@ 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();
@@ -404,6 +406,9 @@ void RenderWidget::OnSwapBuffersAborted()
 }
 
 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_) {
@@ -418,6 +423,9 @@ void RenderWidget::OnSwapBuffersPosted() {
 }
 
 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.
@@ -990,6 +998,54 @@ void RenderWidget::didDeactivateCompositor() {
 
   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() {