cc: Add threaded GPU rasterization.

content/browser/android/in_process/synchronous_compositor_factory_impl.cc

 // Copyright 2014 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/browser/android/in_process/synchronous_compositor_factory_impl.h"
 
 #include "base/command_line.h"
 #include "base/observer_list.h"
 #include "content/browser/android/in_process/synchronous_compositor_external_begin_frame_source.h"
 #include "content/browser/android/in_process/synchronous_compositor_impl.h"
@@ skipping 49 matching lines @@
       gpu_preference,
       gpu::GLInProcessContextSharedMemoryLimits(),
       nullptr,
       nullptr));
   return context.Pass();
 }
 
 scoped_ptr<gpu::GLInProcessContext> CreateContext(
     scoped_refptr<gpu::InProcessCommandBuffer::Service> service,
     const gpu::GLInProcessContextSharedMemoryLimits& mem_limits,
-    bool is_offscreen) {
+    bool is_offscreen,
+    bool share_resources) {
   const gfx::GpuPreference gpu_preference = gfx::PreferDiscreteGpu;
   gpu::gles2::ContextCreationAttribHelper in_process_attribs;
   WebGraphicsContext3DImpl::ConvertAttributes(
       GetDefaultAttribs(), &in_process_attribs);
   in_process_attribs.lose_context_when_out_of_memory = true;
 
   scoped_ptr<gpu::GLInProcessContext> context(gpu::GLInProcessContext::Create(
       service,
       NULL /* surface */,
       is_offscreen,
       gfx::kNullAcceleratedWidget,
       gfx::Size(1, 1),
       NULL /* share_context */,
-      false /* share_resources */,
+      share_resources /* share_resources */,
       in_process_attribs,
       gpu_preference,
       mem_limits,
       nullptr,
       nullptr));
   return context.Pass();
 }
 
 scoped_ptr<WebGraphicsContext3DInProcessCommandBufferImpl> WrapContext(
     scoped_ptr<gpu::GLInProcessContext> context) {
@@ skipping 110 matching lines @@
 scoped_refptr<ContextProviderWebContext>
 SynchronousCompositorFactoryImpl::CreateOffscreenContextProvider(
     const blink::WebGraphicsContext3D::Attributes& attributes,
     const std::string& debug_name) {
   scoped_ptr<gpu::GLInProcessContext> context =
       CreateOffscreenContext(attributes);
   return webkit::gpu::ContextProviderInProcess::Create(
       WrapContext(context.Pass()), debug_name);
 }
 
-scoped_refptr<cc::ContextProvider> SynchronousCompositorFactoryImpl::
-    CreateOnscreenContextProviderForCompositorThread() {
+scoped_refptr<cc::ContextProvider>
+SynchronousCompositorFactoryImpl::CreateContextProviderForCompositor() {
   DCHECK(service_.get());
 
   gpu::GLInProcessContextSharedMemoryLimits mem_limits;
   // This is half of what RenderWidget uses because synchronous compositor
   // pipeline is only one frame deep.
   mem_limits.mapped_memory_reclaim_limit = 6 * 1024 * 1024;
   return webkit::gpu::ContextProviderInProcess::Create(
-      WrapContext(CreateContext(nullptr, mem_limits, true)),
+      WrapContext(CreateContext(nullptr, mem_limits, true, true)),
       "Child-Compositor");
 }
 
 scoped_refptr<StreamTextureFactory>
 SynchronousCompositorFactoryImpl::CreateStreamTextureFactory(int frame_id) {
   scoped_refptr<StreamTextureFactorySynchronousImpl> factory(
       StreamTextureFactorySynchronousImpl::Create(
           base::Bind(
               &SynchronousCompositorFactoryImpl::TryCreateStreamTextureFactory,
               base::Unretained(this)),
@@ skipping 51 matching lines @@
     return
         scoped_refptr<StreamTextureFactorySynchronousImpl::ContextProvider>();
   }
 
   if (!video_context_provider_.get()) {
     DCHECK(service_.get());
 
     // This needs to run in on-screen |service_| context due to SurfaceTexture
     // limitations.
     video_context_provider_ = new VideoContextProvider(CreateContext(
-        service_, gpu::GLInProcessContextSharedMemoryLimits(), false));
+        service_, gpu::GLInProcessContextSharedMemoryLimits(), false, false));
   }
   return video_context_provider_;
 }
 
 void SynchronousCompositorFactoryImpl::SetDeferredGpuService(
     scoped_refptr<gpu::InProcessCommandBuffer::Service> service) {
   DCHECK(!service_.get());
   service_ = service;
 }
 
 void SynchronousCompositorFactoryImpl::SetRecordFullDocument(
     bool record_full_document) {
   record_full_layer_ = record_full_document;
 }
 
 }  // namespace content