Change WGC3DInProcessCBImpl factories to return a base class pointer.

content/browser/renderer_host/image_transport_factory.cc

 // Copyright (c) 2012 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/renderer_host/image_transport_factory.h"
 
 #include <algorithm>
 #include <map>
 
 #include "base/bind.h"
@@ skipping 467 matching lines @@
 };
 
 // Adapts a WebGraphicsContext3DCommandBufferImpl into a
 // cc::OutputSurface that also handles vsync parameter updates
 // arriving from the GPU process.
 class BrowserCompositorOutputSurface
     : public cc::OutputSurface,
       public base::NonThreadSafe {
  public:
   BrowserCompositorOutputSurface(
-      WebGraphicsContext3DCommandBufferImpl* context,
+      scoped_ptr<WebKit::WebGraphicsContext3D> context,
       int surface_id,
       BrowserCompositorOutputSurfaceProxy* output_surface_proxy,
       base::MessageLoopProxy* compositor_message_loop,
       base::WeakPtr<ui::Compositor> compositor)
-      : OutputSurface(scoped_ptr<WebKit::WebGraphicsContext3D>(context)),
+      : OutputSurface(context.Pass()),
         surface_id_(surface_id),
         output_surface_proxy_(output_surface_proxy),
         compositor_message_loop_(compositor_message_loop),
         compositor_(compositor) {
     CommandLine* command_line = CommandLine::ForCurrentProcess();
     if (command_line->HasSwitch(switches::kUIMaxFramesPending)) {
       std::string string_value = command_line->GetSwitchValueASCII(
           switches::kUIMaxFramesPending);
       int int_value;
       if (base::StringToInt(string_value, &int_value))
@@ skipping 117 matching lines @@
  public:
   GpuProcessTransportFactory()
       : callback_factory_(this) {
     output_surface_proxy_ = new BrowserCompositorOutputSurfaceProxy();
   }
 
   virtual ~GpuProcessTransportFactory() {
     DCHECK(per_compositor_data_.empty());
   }
 
-  virtual WebGraphicsContext3DCommandBufferImpl* CreateOffscreenContext()
-      OVERRIDE {
+  scoped_ptr<WebGraphicsContext3DCommandBufferImpl>
+  CreateOffscreenCommandBufferContext() {
     base::WeakPtr<WebGraphicsContext3DSwapBuffersClient> swap_client;
     return CreateContextCommon(swap_client, 0);
   }
 
+  virtual scoped_ptr<WebKit::WebGraphicsContext3D> CreateOffscreenContext()
+      OVERRIDE {
+    return CreateOffscreenCommandBufferContext()
+        .PassAs<WebKit::WebGraphicsContext3D>();
+  }
+
   virtual cc::OutputSurface* CreateOutputSurface(
       ui::Compositor* compositor) OVERRIDE {
     PerCompositorData* data = per_compositor_data_[compositor];
     if (!data)
       data = CreatePerCompositorData(compositor);
-    WebGraphicsContext3DCommandBufferImpl* context =
-        CreateContextCommon(data->swap_client->AsWeakPtr(),
-                            data->surface_id);
     BrowserCompositorOutputSurface* surface =
         new BrowserCompositorOutputSurface(
-            context,
+            CreateContextCommon(data->swap_client->AsWeakPtr(),
+                                data->surface_id)
+                .PassAs<WebKit::WebGraphicsContext3D>(),
             per_compositor_data_[compositor]->surface_id,
             output_surface_proxy_.get(),
             base::MessageLoopProxy::current(),
             compositor->AsWeakPtr());
     if (data->reflector.get()) {
       data->reflector->CreateSharedTexture();
       data->reflector->AttachToOutputSurface(surface);
     }
     return surface;
   }
@@ skipping 153 matching lines @@
 #endif
     tracker->SetSurfaceHandle(
         data->surface_id,
         gfx::GLSurfaceHandle(widget, gfx::NATIVE_DIRECT));
 
     per_compositor_data_[compositor] = data;
 
     return data;
   }
 
-  WebGraphicsContext3DCommandBufferImpl* CreateContextCommon(
+  scoped_ptr<WebGraphicsContext3DCommandBufferImpl> CreateContextCommon(
       const base::WeakPtr<WebGraphicsContext3DSwapBuffersClient>& swap_client,
       int surface_id) {
     WebKit::WebGraphicsContext3D::Attributes attrs;
     attrs.shareResources = true;
     attrs.depth = false;
     attrs.stencil = false;
     attrs.antialias = false;
     attrs.noAutomaticFlushes = true;
     GpuChannelHostFactory* factory = BrowserGpuChannelHostFactory::instance();
     GURL url("chrome://gpu/GpuProcessTransportFactory::CreateContextCommon");
     scoped_ptr<WebGraphicsContext3DCommandBufferImpl> context(
         new WebGraphicsContext3DCommandBufferImpl(
             surface_id,
             url,
             factory,
             swap_client));
     if (!context->InitializeWithDefaultBufferSizes(
         attrs,
         false,
         CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE))
-      return NULL;
-    return context.release();
+      return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();
+    return context.Pass();
   }
 
   // Crash given that we are unable to show any UI whatsoever. On Windows we
   // also trigger code in breakpad causes a system process to show message box.
   // In all cases a crash dump is generated.
   void FatalGPUError(const char* message) {
 #if defined(OS_WIN)
     // 0xC01E0200 corresponds to STATUS_GRAPHICS_GPU_EXCEPTION_ON_DEVICE.
     ::RaiseException(0xC01E0200, EXCEPTION_NONCONTINUABLE, 0, NULL);
 #else
@@ skipping 12 matching lines @@
       return provider;
     }
 
    protected:
     explicit MainThreadContextProvider(GpuProcessTransportFactory* factory)
         : factory_(factory) {}
     virtual ~MainThreadContextProvider() {}
 
     virtual scoped_ptr<WebGraphicsContext3DCommandBufferImpl>
         CreateOffscreenContext3d() OVERRIDE {
-      return make_scoped_ptr(factory_->CreateOffscreenContext());
+      return factory_->CreateOffscreenCommandBufferContext();
     }
 
     virtual void OnLostContext() OVERRIDE {
       base::MessageLoop::current()->PostTask(
           FROM_HERE,
           base::Bind(&GpuProcessTransportFactory::OnLostMainThreadSharedContext,
                      factory_->callback_factory_.GetWeakPtr()));
     }
 
    private:
@@ skipping 23 matching lines @@
       return provider;
     }
 
    protected:
     explicit CompositorThreadContextProvider(
         GpuProcessTransportFactory* factory) : factory_(factory) {}
     virtual ~CompositorThreadContextProvider() {}
 
     virtual scoped_ptr<WebGraphicsContext3DCommandBufferImpl>
         CreateOffscreenContext3d() OVERRIDE {
-      return make_scoped_ptr(factory_->CreateOffscreenContext());
+      return factory_->CreateOffscreenCommandBufferContext();
     }
 
    private:
     GpuProcessTransportFactory* factory_;
   };
 
   virtual scoped_refptr<cc::ContextProvider>
       OffscreenContextProviderForCompositorThread() OVERRIDE {
     if (!shared_contexts_compositor_thread_.get() ||
         shared_contexts_compositor_thread_->DestroyedOnMainThread()) {
@@ skipping 58 matching lines @@
     latency_info.swap_timestamp = base::TimeTicks::HighResNow();
     RenderWidgetHostImpl::CompositorFrameDrawn(latency_info);
     cc::OutputSurface::SwapBuffers(frame);
   }
 };
 
 class SoftwareContextFactory : public ui::ContextFactory {
  public:
   SoftwareContextFactory() {}
   virtual ~SoftwareContextFactory() {}
-  virtual WebKit::WebGraphicsContext3D* CreateOffscreenContext() OVERRIDE {
-    return NULL;
+  virtual scoped_ptr<WebKit::WebGraphicsContext3D> CreateOffscreenContext()
+      OVERRIDE {
+    return scoped_ptr<WebKit::WebGraphicsContext3D>();
   }
   virtual cc::OutputSurface* CreateOutputSurface(
       ui::Compositor* compositor) OVERRIDE {
 #if defined(OS_WIN)
     scoped_ptr<SoftwareOutputDeviceWin> software_device(
         new SoftwareOutputDeviceWin(compositor));
     return new SoftwareOutputSurface(
         software_device.PassAs<cc::SoftwareOutputDevice>());
 #elif defined(USE_X11)
     scoped_ptr<SoftwareOutputDeviceX11> software_device(
@@ skipping 54 matching lines @@
   delete g_factory;
   g_factory = NULL;
 }
 
 // static
 ImageTransportFactory* ImageTransportFactory::GetInstance() {
   return g_factory;
 }
 
 }  // namespace content