Turning the threaded compositor into a runtime option. This CL

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 308 matching lines @@
   needs_repainting_on_restore_ = false;
 
   // Tag the next paint as a restore ack, which is picked up by
   // DoDeferredUpdate when it sends out the next PaintRect message.
   set_next_paint_is_restore_ack();
 
   // Generate a full repaint.
   if (!is_accelerated_compositing_active_) {
     didInvalidateRect(gfx::Rect(size_.width(), size_.height()));
   } else {
-#ifdef WTF_USE_THREADED_COMPOSITING
-    webwidget_->composite(false);
-#else
     scheduleComposite();
-#endif
   }
 }
 
 void RenderWidget::OnWasSwappedOut() {
   // If we have been swapped out and no one else is using this process,
   // it's safe to exit now.  If we get swapped back in, we will call
   // AddRefProcess in SetSwappedOut.
   if (is_swapped_out_)
     RenderProcess::current()->ReleaseProcess();
 }
@@ skipping 578 matching lines @@
       this, &RenderWidget::InvalidationCallback));
 }
 
 void RenderWidget::didActivateCompositor(int compositorIdentifier) {
   TRACE_EVENT0("gpu", "RenderWidget::didActivateCompositor");
 
   is_accelerated_compositing_active_ = true;
   Send(new ViewHostMsg_DidActivateAcceleratedCompositing(
       routing_id_, is_accelerated_compositing_active_));
 
-#ifndef WTF_USE_THREADED_COMPOSITING
+  // Note: asynchronous swapbuffer support currently only matters if
+  // compositing scheduling happens on the RenderWidget.
   using_asynchronous_swapbuffers_ = SupportsAsynchronousSwapBuffers();
-#endif
 }
 
 void RenderWidget::didDeactivateCompositor() {
   TRACE_EVENT0("gpu", "RenderWidget::didDeactivateCompositor");
 
   is_accelerated_compositing_active_ = false;
   Send(new ViewHostMsg_DidActivateAcceleratedCompositing(
       routing_id_, is_accelerated_compositing_active_));
 
-#ifndef WTF_USE_THREADED_COMPOSITING
   if (using_asynchronous_swapbuffers_)
     using_asynchronous_swapbuffers_ = false;
-#endif
 }
 
 void RenderWidget::scheduleComposite() {
-#if WTF_USE_THREADED_COMPOSITING
-  NOTREACHED();
-#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));
-#endif
+  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
+    // duplicating all that code is less desirable than "faking out" the
+    // invalidation path using a magical damage rect.
+    didInvalidateRect(WebRect(0, 0, 1, 1));
+  }
 }
 
 void RenderWidget::scheduleAnimation() {
   TRACE_EVENT0("gpu", "RenderWidget::scheduleAnimation");
   if (!animation_update_pending_) {
     animation_update_pending_ = true;
     if (!animation_task_posted_) {
       animation_task_posted_ = true;
       MessageLoop::current()->PostTask(FROM_HERE, NewRunnableMethod(
           this, &RenderWidget::AnimationCallback));
@@ skipping 248 matching lines @@
   Send(new ViewHostMsg_PaintAtSize_ACK(routing_id_, tag, bounds.size()));
 }
 
 void RenderWidget::OnMsgRepaint(const gfx::Size& size_to_paint) {
   // During shutdown we can just ignore this message.
   if (!webwidget_)
     return;
 
   set_next_paint_is_repaint_ack();
   if (is_accelerated_compositing_active_) {
-#ifndef WTF_USE_THREADED_COMPOSITING
     scheduleComposite();
-#else
-#ifdef WEBWIDGET_HAS_THREADED_COMPOSITING_CHANGES
-    webwidget_->composite(false);
-#endif
-#endif
   } else {
     gfx::Rect repaint_rect(size_to_paint.width(), size_to_paint.height());
     didInvalidateRect(repaint_rect);
   }
 }
 
 void RenderWidget::OnSetTextDirection(WebTextDirection direction) {
   if (!webwidget_)
     return;
   webwidget_->setTextDirection(direction);
@@ skipping 160 matching lines @@
     if (i->window == window) {
       plugin_window_moves_.erase(i);
       break;
     }
   }
 }
 
 bool RenderWidget::WillHandleMouseEvent(const WebKit::WebMouseEvent& event) {
   return false;
 }
+
+bool RenderWidget::WebWidgetHandlesCompositorScheduling() const {
+  return false;
+}