(not for commit) Create 2nd ContextProvider for Ganesh 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 975 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.
+      LOG(ERROR) << "Failed to create worker context provider!!!!!!!!!";
+      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,
-                                             frame_swap_message_queue_));
+    return scoped_ptr<cc::OutputSurface>(new DelegatedCompositorOutputSurface(
+        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,
-                                    NULL,
-                                    software_device.Pass(),
-                                    frame_swap_message_queue_,
-                                    true));
+    return scoped_ptr<cc::OutputSurface>(new CompositorOutputSurface(
+        routing_id(), output_surface_id, NULL, NULL, 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,
-                                 scoped_ptr<cc::SoftwareOutputDevice>(),
-                                 frame_swap_message_queue_,
-                                 format));
+    return scoped_ptr<cc::OutputSurface>(new MailboxOutputSurface(
+        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,
-                                  scoped_ptr<cc::SoftwareOutputDevice>(),
-                                  frame_swap_message_queue_,
-                                  use_swap_compositor_frame_message));
+  return scoped_ptr<cc::OutputSurface>(new CompositorOutputSurface(
+      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