ContextProvider in OutputSurface

content/renderer/render_widget.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/renderer/render_widget.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "cc/base/switches.h"
 #include "cc/output/output_surface.h"
 #include "cc/trees/layer_tree_host.h"
 #include "content/child/npapi/webplugin.h"
+#include "content/common/gpu/client/context_provider_command_buffer.h"
 #include "content/common/gpu/client/webgraphicscontext3d_command_buffer_impl.h"
 #include "content/common/input_messages.h"
 #include "content/common/swapped_out_messages.h"
 #include "content/common/view_messages.h"
 #include "content/public/common/content_switches.h"
 #include "content/renderer/cursor_utils.h"
 #include "content/renderer/gpu/compositor_output_surface.h"
 #include "content/renderer/gpu/compositor_software_output_device.h"
 #include "content/renderer/gpu/delegated_compositor_output_surface.h"
 #include "content/renderer/gpu/input_handler_manager.h"
@@ skipping 630 matching lines @@
   // GPU and browser processes. For these reasons and to avoid platform
   // disparities we explicitly disable antialiasing.
   WebKit::WebGraphicsContext3D::Attributes attributes;
   attributes.antialias = false;
   attributes.shareResources = true;
   attributes.noAutomaticFlushes = true;
   attributes.depth = false;
   attributes.stencil = false;
   if (command_line.HasSwitch(cc::switches::kForceDirectLayerDrawing))
     attributes.stencil = true;
-  WebGraphicsContext3DCommandBufferImpl* context = NULL;
-  if (!fallback)
-    context = CreateGraphicsContext3D(attributes);
+  scoped_refptr<ContextProviderCommandBuffer> context_provider;
+  if (!fallback) {
+    context_provider = ContextProviderCommandBuffer::Create(
+        base::Bind(&RenderWidget::CreateGraphicsContext3D,
+                   base::Unretained(this),
+                   attributes));
+  }
 
-  if (!context) {
+  if (!context_provider.get()) {
     if (!command_line.HasSwitch(switches::kEnableSoftwareCompositing))
       return scoped_ptr<cc::OutputSurface>();
-    return scoped_ptr<cc::OutputSurface>(
-        new CompositorOutputSurface(routing_id(),
-                                    output_surface_id,
-                                    NULL,
-                                    new CompositorSoftwareOutputDevice(),
-                                    true));
+
+    scoped_ptr<cc::SoftwareOutputDevice> software_device(
+        new CompositorSoftwareOutputDevice());
+
+    return scoped_ptr<cc::OutputSurface>(new CompositorOutputSurface(
+        routing_id(),
+        output_surface_id,
+        NULL,
+        software_device.Pass(),
+        true));
   }
 
   if (command_line.HasSwitch(switches::kEnableDelegatedRenderer) &&
       !command_line.HasSwitch(switches::kDisableDelegatedRenderer)) {
     DCHECK(is_threaded_compositing_enabled_);
     return scoped_ptr<cc::OutputSurface>(
-        new DelegatedCompositorOutputSurface(routing_id(), output_surface_id,
-                                             context, NULL));
+        new DelegatedCompositorOutputSurface(
+            routing_id(),
+            output_surface_id,
+            context_provider,
+            scoped_ptr<cc::SoftwareOutputDevice>()));
   }
   if (command_line.HasSwitch(cc::switches::kCompositeToMailbox)) {
     DCHECK(is_threaded_compositing_enabled_);
     return scoped_ptr<cc::OutputSurface>(
-        new MailboxOutputSurface(routing_id(), output_surface_id,
-                                 context, NULL));
+        new MailboxOutputSurface(
+            routing_id(),
+            output_surface_id,
+            context_provider,
+            scoped_ptr<cc::SoftwareOutputDevice>()));
   }
+  bool use_swap_compositor_frame_message = false;
   return scoped_ptr<cc::OutputSurface>(
-      new CompositorOutputSurface(routing_id(), output_surface_id,
-                                  context, NULL, false));
+      new CompositorOutputSurface(
+          routing_id(),
+          output_surface_id,
+          context_provider,
+          scoped_ptr<cc::SoftwareOutputDevice>(),
+          use_swap_compositor_frame_message));
 }
 
 void RenderWidget::OnViewContextSwapBuffersAborted() {
   TRACE_EVENT0("renderer", "RenderWidget::OnSwapBuffersAborted");
   while (!updates_pending_swap_.empty()) {
     ViewHostMsg_UpdateRect* msg = updates_pending_swap_.front();
     updates_pending_swap_.pop_front();
     // msg can be NULL if the swap doesn't correspond to an DoDeferredUpdate
     // compositing pass, hence doesn't require an UpdateRect message.
     if (msg)
@@ skipping 1786 matching lines @@
 }
 
 void RenderWidget::hasTouchEventHandlers(bool has_handlers) {
   Send(new ViewHostMsg_HasTouchEventHandlers(routing_id_, has_handlers));
 }
 
 bool RenderWidget::HasTouchEventHandlersAt(const gfx::Point& point) const {
   return true;
 }
 
-WebGraphicsContext3DCommandBufferImpl* RenderWidget::CreateGraphicsContext3D(
+scoped_ptr<WebGraphicsContext3DCommandBufferImpl>
+RenderWidget::CreateGraphicsContext3D(
     const WebKit::WebGraphicsContext3D::Attributes& attributes) {
   if (!webwidget_)
-    return NULL;
+    return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableGpuCompositing))
-    return NULL;
+    return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();
   scoped_ptr<WebGraphicsContext3DCommandBufferImpl> context(
       new WebGraphicsContext3DCommandBufferImpl(
           surface_id(),
           GetURLForGraphicsContext3D(),
           RenderThreadImpl::current(),
           weak_ptr_factory_.GetWeakPtr()));
 
   if (!context->InitializeWithDefaultBufferSizes(
           attributes,
           false /* bind generates resources */,
           CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE))
-    return NULL;
-  return context.release();
+    return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();
+  return context.Pass();
 }
 
 }  // namespace content