android: Merge CreateOffscreenContext and CreateContext into one function.

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 21 matching lines @@
   blink::WebGraphicsContext3D::Attributes attributes;
   attributes.antialias = false;
   attributes.depth = false;
   attributes.stencil = false;
   attributes.shareResources = true;
   attributes.noAutomaticFlushes = true;
 
   return attributes;
 }
 
-scoped_ptr<gpu::GLInProcessContext> CreateOffscreenContext(
-    const blink::WebGraphicsContext3D::Attributes& attributes) {
+scoped_ptr<gpu::GLInProcessContext> CreateContextHolder(
+    const blink::WebGraphicsContext3D::Attributes& attributes,
+    scoped_refptr<gpu::InProcessCommandBuffer::Service> service,
+    const gpu::GLInProcessContextSharedMemoryLimits& mem_limits,
+    bool share_resources,
+    bool is_offscreen) {
   const gfx::GpuPreference gpu_preference = gfx::PreferDiscreteGpu;
 
   gpu::gles2::ContextCreationAttribHelper in_process_attribs;
-  WebGraphicsContext3DImpl::ConvertAttributes(
-      attributes, &in_process_attribs);
+  WebGraphicsContext3DImpl::ConvertAttributes(attributes, &in_process_attribs);
   in_process_attribs.lose_context_when_out_of_memory = true;
 
   scoped_ptr<gpu::GLInProcessContext> context(gpu::GLInProcessContext::Create(
-      NULL /* service */,
-      NULL /* surface */,
-      true /* is_offscreen */,
-      gfx::kNullAcceleratedWidget,
-      gfx::Size(1, 1),
-      NULL /* share_context */,
-      attributes.shareResources,
-      in_process_attribs,
-      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 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 */,
-      share_resources /* share_resources */,
+      is_offscreen ? attributes.shareResources : share_resources,

[boliu, 2015/04/07 02:23:26]

Can just make this attributes.shareResources? Anything that had
attributes.shareResources != share_resources should be fixed.

[tfarina, 2015/04/07 04:01:43]

Done.

       in_process_attribs,
       gpu_preference,
       mem_limits,
       nullptr,
       nullptr));
   return context.Pass();
 }
 
 scoped_ptr<WebGraphicsContext3DInProcessCommandBufferImpl> WrapContext(
     scoped_ptr<gpu::GLInProcessContext> context) {
@@ skipping 104 matching lines @@
 SynchronousCompositorFactoryImpl::CreateExternalBeginFrameSource(
     int routing_id) {
   return make_scoped_ptr(
              new SynchronousCompositorExternalBeginFrameSource(routing_id));
 }
 
 scoped_refptr<ContextProviderWebContext>
 SynchronousCompositorFactoryImpl::CreateOffscreenContextProvider(
     const blink::WebGraphicsContext3D::Attributes& attributes,
     const std::string& debug_name) {
-  scoped_ptr<gpu::GLInProcessContext> context =
-      CreateOffscreenContext(attributes);
+  scoped_ptr<gpu::GLInProcessContext> context = CreateContextHolder(
+      attributes, nullptr, gpu::GLInProcessContextSharedMemoryLimits(), true,
+      true);
   return webkit::gpu::ContextProviderInProcess::Create(
       WrapContext(context.Pass()), debug_name);
 }
 
 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, true)),
+      WrapContext(CreateContextHolder(GetDefaultAttribs(), 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)),
           frame_id));
   return factory;
 }
 
 WebGraphicsContext3DInProcessCommandBufferImpl*
 SynchronousCompositorFactoryImpl::CreateOffscreenGraphicsContext3D(
     const blink::WebGraphicsContext3D::Attributes& attributes) {
-  return WrapContextWithAttributes(CreateOffscreenContext(attributes),
-                                   attributes).release();
+  return WrapContextWithAttributes(
+             CreateContextHolder(attributes, nullptr,
+                                 gpu::GLInProcessContextSharedMemoryLimits(),
+                                 true, true),
+             attributes).release();
 }
 
 void SynchronousCompositorFactoryImpl::CompositorInitializedHardwareDraw() {
   base::AutoLock lock(num_hardware_compositor_lock_);
   num_hardware_compositors_++;
   if (num_hardware_compositors_ == 1 && main_thread_proxy_.get()) {
     main_thread_proxy_->PostTask(
         FROM_HERE,
         base::Bind(
             &SynchronousCompositorFactoryImpl::RestoreContextOnMainThread,
@@ skipping 31 matching lines @@
   if (!CanCreateMainThreadContext()) {
     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, false));
+    video_context_provider_ = new VideoContextProvider(CreateContextHolder(
+        GetDefaultAttribs(), 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