ContextProvider in OutputSurface

content/browser/aura/gpu_process_transport_factory.cc

 // Copyright (c) 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/aura/gpu_process_transport_factory.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 201 matching lines @@
   NOTREACHED();
   return scoped_ptr<cc::SoftwareOutputDevice>();
 }
 
 scoped_ptr<cc::OutputSurface> GpuProcessTransportFactory::CreateOutputSurface(
     ui::Compositor* compositor) {
   PerCompositorData* data = per_compositor_data_[compositor];
   if (!data)
     data = CreatePerCompositorData(compositor);
 
-  scoped_ptr<WebGraphicsContext3DCommandBufferImpl> context;
+  scoped_refptr<ContextProviderCommandBuffer> context_provider;
+
   CommandLine* command_line = CommandLine::ForCurrentProcess();
   if (!command_line->HasSwitch(switches::kUIEnableSoftwareCompositing)) {
-    context =
-        CreateContextCommon(data->swap_client->AsWeakPtr(), data->surface_id);
+    context_provider = ContextProviderCommandBuffer::Create(
+        base::Bind(&GpuProcessTransportFactory::CreateContextCommon,
+                   base::Unretained(this),
+                   data->swap_client->AsWeakPtr(),
+                   data->surface_id));
   }
-  if (!context) {
+  if (!context_provider.get()) {
     if (ui::Compositor::WasInitializedWithThread()) {
       LOG(FATAL) << "Failed to create UI context, but can't use software "
                  " compositing with browser threaded compositing. Aborting.";
     }
 
     scoped_ptr<SoftwareBrowserCompositorOutputSurface> surface =
         SoftwareBrowserCompositorOutputSurface::Create(
             CreateSoftwareOutputDevice(compositor));
     return surface.PassAs<cc::OutputSurface>();
   }
 
   scoped_refptr<base::SingleThreadTaskRunner> compositor_thread_task_runner =
       ui::Compositor::GetCompositorMessageLoop();
   if (!compositor_thread_task_runner.get())
     compositor_thread_task_runner = base::MessageLoopProxy::current();
 
   // Here we know the GpuProcessHost has been set up, because we created a
   // context.
   output_surface_proxy_->ConnectToGpuProcessHost(
       compositor_thread_task_runner.get());
 
   scoped_ptr<BrowserCompositorOutputSurface> surface(
       new BrowserCompositorOutputSurface(
-          context.PassAs<WebKit::WebGraphicsContext3D>(),
+          context_provider,
           per_compositor_data_[compositor]->surface_id,
           &output_surface_map_,
           base::MessageLoopProxy::current().get(),
           compositor->AsWeakPtr()));
   if (data->reflector.get()) {
     data->reflector->CreateSharedTexture();
     data->reflector->AttachToOutputSurface(surface.get());
   }
 
   return surface.PassAs<cc::OutputSurface>();
@@ skipping 239 matching lines @@
   shared_contexts_main_thread_ = NULL;
 
   scoped_ptr<GLHelper> old_helper(gl_helper_.release());
 
   FOR_EACH_OBSERVER(ImageTransportFactoryObserver,
                     observer_list_,
                     OnLostResources());
 }
 
 }  // namespace content