cc: Add threaded GPU rasterization.

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/auto_reset.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
@@ skipping 974 matching lines @@
   }
 #endif
 
   const base::CommandLine& command_line =
       *base::CommandLine::ForCurrentProcess();
   bool use_software = fallback;
   if (command_line.HasSwitch(switches::kDisableGpuCompositing))
     use_software = true;
 
   scoped_refptr<ContextProviderCommandBuffer> context_provider;
+  scoped_refptr<ContextProviderCommandBuffer> worker_context_provider;
   if (!use_software) {
     context_provider = ContextProviderCommandBuffer::Create(
         CreateGraphicsContext3D(), "RenderCompositor");
     if (!context_provider.get()) {
       // Cause the compositor to wait and try again.
       return scoped_ptr<cc::OutputSurface>();
     }
+
+    worker_context_provider = ContextProviderCommandBuffer::Create(
+        CreateGraphicsContext3D(), "RenderWorker");
+    if (!worker_context_provider.get()) {
+      // Cause the compositor to wait and try again.
+      return scoped_ptr<cc::OutputSurface>();
+    }
   }
 
   uint32 output_surface_id = next_output_surface_id_++;
   if (command_line.HasSwitch(switches::kEnableDelegatedRenderer)) {
     DCHECK(compositor_deps_->GetCompositorImplThreadTaskRunner());
     return scoped_ptr<cc::OutputSurface>(new DelegatedCompositorOutputSurface(
-        routing_id(), output_surface_id, context_provider, nullptr,
-        frame_swap_message_queue_));
+        routing_id(), output_surface_id, context_provider,
+        worker_context_provider, frame_swap_message_queue_));
   }
   if (!context_provider.get()) {
     scoped_ptr<cc::SoftwareOutputDevice> software_device(
         new CompositorSoftwareOutputDevice());
 
     return scoped_ptr<cc::OutputSurface>(new CompositorOutputSurface(
         routing_id(), output_surface_id, nullptr, nullptr,
         software_device.Pass(), frame_swap_message_queue_, true));
   }
 
   if (command_line.HasSwitch(cc::switches::kCompositeToMailbox)) {
     // Composite-to-mailbox is currently used for layout tests in order to cause
     // them to draw inside in the renderer to do the readback there. This should
     // no longer be the case when crbug.com/311404 is fixed.
     DCHECK(RenderThreadImpl::current()->layout_test_mode());
     cc::ResourceFormat format = cc::RGBA_8888;
     if (base::SysInfo::IsLowEndDevice())
       format = cc::RGB_565;
     return scoped_ptr<cc::OutputSurface>(new MailboxOutputSurface(
-        routing_id(), output_surface_id, context_provider, nullptr,
-        scoped_ptr<cc::SoftwareOutputDevice>(), frame_swap_message_queue_,
-        format));
+        routing_id(), output_surface_id, context_provider,
+        worker_context_provider, scoped_ptr<cc::SoftwareOutputDevice>(),
+        frame_swap_message_queue_, format));
   }
   bool use_swap_compositor_frame_message = false;
   return scoped_ptr<cc::OutputSurface>(new CompositorOutputSurface(
-      routing_id(), output_surface_id, context_provider, nullptr,
-      scoped_ptr<cc::SoftwareOutputDevice>(), frame_swap_message_queue_,
-      use_swap_compositor_frame_message));
+      routing_id(), output_surface_id, context_provider,
+      worker_context_provider, scoped_ptr<cc::SoftwareOutputDevice>(),
+      frame_swap_message_queue_, use_swap_compositor_frame_message));
 }
 
 void RenderWidget::OnSwapBuffersAborted() {
   TRACE_EVENT0("renderer", "RenderWidget::OnSwapBuffersAborted");
   // Schedule another frame so the compositor learns about it.
   scheduleComposite();
 }
 
 void RenderWidget::OnSwapBuffersPosted() {
   TRACE_EVENT0("renderer", "RenderWidget::OnSwapBuffersPosted");
@@ skipping 1367 matching lines @@
 void RenderWidget::RegisterVideoHoleFrame(RenderFrameImpl* frame) {
   video_hole_frames_.AddObserver(frame);
 }
 
 void RenderWidget::UnregisterVideoHoleFrame(RenderFrameImpl* frame) {
   video_hole_frames_.RemoveObserver(frame);
 }
 #endif  // defined(VIDEO_HOLE)
 
 }  // namespace content