InProcessGL: Share MailboxManager per service

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 "content/browser/android/in_process/synchronous_compositor_output_surface.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/renderer/gpu/frame_swap_message_queue.h"
 #include "gpu/command_buffer/client/gl_in_process_context.h"
@@ skipping 42 matching lines @@
       NULL /* share_context */,
       false /* share_resources */,
       in_process_attribs,
       gpu_preference,
       gpu::GLInProcessContextSharedMemoryLimits()));
   return context.Pass();
 }
 
 scoped_ptr<gpu::GLInProcessContext> CreateContext(
     scoped_refptr<gpu::InProcessCommandBuffer::Service> service,
-    gpu::GLInProcessContext* share_context,
     const gpu::GLInProcessContextSharedMemoryLimits& mem_limits) {
   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 */,
       false /* is_offscreen */,
       gfx::kNullAcceleratedWidget,
       gfx::Size(1, 1),
-      share_context,
+      NULL /* share_context */,
       false /* share_resources */,
       in_process_attribs,
       gpu_preference,
       mem_limits));
   return context.Pass();
 }
 
 scoped_ptr<WebGraphicsContext3DInProcessCommandBufferImpl> WrapContext(
     scoped_ptr<gpu::GLInProcessContext> context) {
   if (!context.get())
@@ skipping 92 matching lines @@
   scoped_ptr<gpu::GLInProcessContext> context =
       CreateOffscreenContext(attributes);
   return webkit::gpu::ContextProviderInProcess::Create(
       WrapContext(context.Pass()), debug_name);
 }
 
 scoped_refptr<cc::ContextProvider> SynchronousCompositorFactoryImpl::
     CreateOnscreenContextProviderForCompositorThread() {
   DCHECK(service_);
 
-  if (!share_context_.get()) {
-    share_context_ = CreateContext(
-        service_, NULL, gpu::GLInProcessContextSharedMemoryLimits());
-  }
   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(service_, share_context_.get(), mem_limits)),
+      WrapContext(CreateContext(service_, mem_limits)),
       "Child-Compositor");
 }
 
-gpu::GLInProcessContext* SynchronousCompositorFactoryImpl::GetShareContext() {
-  DCHECK(share_context_.get());
-  return share_context_.get();
-}
-
 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;
 }
@@ skipping 27 matching lines @@
   // This is to avoid synchronous calls that may deadlock. Setting
   // |video_context_provider_| to null is also not safe since it makes
   // synchronous destruction uncontrolled and possibly deadlock.
   if (!CanCreateMainThreadContext()) {
     return
         scoped_refptr<StreamTextureFactorySynchronousImpl::ContextProvider>();
   }
 
   if (!video_context_provider_) {
     DCHECK(service_);
-    DCHECK(share_context_.get());
 
     video_context_provider_ = new VideoContextProvider(
         CreateContext(service_,
-                      share_context_.get(),
                       gpu::GLInProcessContextSharedMemoryLimits()));
   }
   return video_context_provider_;
 }
 
 void SynchronousCompositorFactoryImpl::SetDeferredGpuService(
     scoped_refptr<gpu::InProcessCommandBuffer::Service> service) {
   DCHECK(!service_);
   service_ = service;
 }
 
 void SynchronousCompositorFactoryImpl::SetRecordFullDocument(
     bool record_full_document) {
   record_full_layer_ = record_full_document;
 }
 
 }  // namespace content