Support multiple service instances with GLInProcessContext

content/browser/android/in_process/synchronous_compositor_output_surface.cc

 // Copyright 2013 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_output_surface.h"
 
 #include "base/auto_reset.h"
 #include "base/logging.h"
 #include "cc/output/begin_frame_args.h"
 #include "cc/output/compositor_frame.h"
@@ skipping 12 matching lines @@
 #include "ui/gfx/transform.h"
 #include "ui/gl/gl_surface.h"
 #include "webkit/common/gpu/context_provider_in_process.h"
 #include "webkit/common/gpu/webgraphicscontext3d_in_process_command_buffer_impl.h"
 
 namespace content {
 
 namespace {
 
 scoped_ptr<webkit::gpu::WebGraphicsContext3DInProcessCommandBufferImpl>
-CreateWebGraphicsContext3D(scoped_refptr<gfx::GLSurface> surface) {
+CreateWebGraphicsContext3D(
+    scoped_refptr<gfx::GLSurface> surface,
+    scoped_refptr<gpu::InProcessCommandBuffer::Service> service,
+    GLInProcessContext* share_context) {
   using webkit::gpu::WebGraphicsContext3DInProcessCommandBufferImpl;
   const gfx::GpuPreference gpu_preference = gfx::PreferDiscreteGpu;
 
   blink::WebGraphicsContext3D::Attributes attributes;
   attributes.antialias = false;
   attributes.shareResources = true;
   attributes.noAutomaticFlushes = true;
 
   gpu::GLInProcessContextAttribs in_process_attribs;
   WebGraphicsContext3DInProcessCommandBufferImpl::ConvertAttributes(
       attributes, &in_process_attribs);
   scoped_ptr<gpu::GLInProcessContext> context(
       gpu::GLInProcessContext::CreateWithSurface(surface,
+                                                 service,
+                                                 share_context,
                                                  attributes.shareResources,
                                                  in_process_attribs,
                                                  gpu_preference));
 
   if (!context.get())
     return scoped_ptr<WebGraphicsContext3DInProcessCommandBufferImpl>();
 
   return WebGraphicsContext3DInProcessCommandBufferImpl::WrapContext(
       context.Pass(), attributes).Pass();
 }
@@ skipping 127 matching lines @@
 
 namespace {
 void AdjustTransform(gfx::Transform* transform, gfx::Rect viewport) {
   // CC's draw origin starts at the viewport.
   transform->matrix().postTranslate(-viewport.x(), -viewport.y(), 0);
 }
 } // namespace
 
 bool SynchronousCompositorOutputSurface::InitializeHwDraw(
     scoped_refptr<gfx::GLSurface> surface,
-    scoped_refptr<cc::ContextProvider> offscreen_context_provider) {
+    scoped_refptr<gpu::InProcessCommandBuffer::Service> service,
+    scoped_refptr<cc::ContextProvider> offscreen_context_provider,
+    gpu::GLInProcessContext* share_context) {
   DCHECK(CalledOnValidThread());
   DCHECK(HasClient());
   DCHECK(!context_provider_);
   DCHECK(surface);
 
   scoped_refptr<cc::ContextProvider> onscreen_context_provider =
       webkit::gpu::ContextProviderInProcess::Create(
-          CreateWebGraphicsContext3D(surface), "SynchronousCompositor");
+          CreateWebGraphicsContext3D(
+              surface, service, share_context),
+          "SynchronousCompositor");
   return InitializeAndSetContext3d(onscreen_context_provider,
                                    offscreen_context_provider);
 }
 
 void SynchronousCompositorOutputSurface::ReleaseHwDraw() {
   DCHECK(CalledOnValidThread());
   cc::OutputSurface::ReleaseGL();
 }
 
 bool SynchronousCompositorOutputSurface::DemandDrawHw(
@@ skipping 91 matching lines @@
 bool SynchronousCompositorOutputSurface::CalledOnValidThread() const {
   return BrowserThread::CurrentlyOn(BrowserThread::UI);
 }
 
 SynchronousCompositorOutputSurfaceDelegate*
 SynchronousCompositorOutputSurface::GetDelegate() {
   return SynchronousCompositorImpl::FromRoutingID(routing_id_);
 }
 
 }  // namespace content