ContextProvider in OutputSurface

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"
 #include "cc/output/context_provider.h"
 #include "cc/output/managed_memory_policy.h"
 #include "cc/output/output_surface_client.h"
 #include "cc/output/software_output_device.h"
 #include "content/browser/android/in_process/synchronous_compositor_impl.h"
-#include "content/common/gpu/client/webgraphicscontext3d_command_buffer_impl.h"
 #include "content/public/browser/browser_thread.h"
 #include "gpu/command_buffer/client/gl_in_process_context.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkDevice.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/skia_util.h"
 #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::WebGraphicsContext3D> CreateWebGraphicsContext3D(
-    scoped_refptr<gfx::GLSurface> surface) {
+scoped_ptr<webkit::gpu::WebGraphicsContext3DInProcessCommandBufferImpl>
+CreateWebGraphicsContext3D(scoped_refptr<gfx::GLSurface> surface) {
   using webkit::gpu::WebGraphicsContext3DInProcessCommandBufferImpl;
   if (!gfx::GLSurface::InitializeOneOff())
-    return scoped_ptr<WebKit::WebGraphicsContext3D>();
+    return scoped_ptr<WebGraphicsContext3DInProcessCommandBufferImpl>();
 
   const char* allowed_extensions = "*";
   const gfx::GpuPreference gpu_preference = gfx::PreferDiscreteGpu;
 
   WebKit::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,
                                                  attributes.shareResources,
                                                  allowed_extensions,
                                                  in_process_attribs,
                                                  gpu_preference));
 
   if (!context.get())
-    return scoped_ptr<WebKit::WebGraphicsContext3D>();
+    return scoped_ptr<WebGraphicsContext3DInProcessCommandBufferImpl>();
 
-  return scoped_ptr<WebKit::WebGraphicsContext3D>(
-      WebGraphicsContext3DInProcessCommandBufferImpl::WrapContext(
-          context.Pass(), attributes));
+  return WebGraphicsContext3DInProcessCommandBufferImpl::WrapContext(
+      context.Pass(), attributes).Pass();
 }
 
 void DidActivatePendingTree(int routing_id) {
   SynchronousCompositorOutputSurfaceDelegate* delegate =
       SynchronousCompositorImpl::FromRoutingID(routing_id);
   if (delegate)
     delegate->DidActivatePendingTree();
 }
 
 } // namespace
@@ skipping 97 matching lines @@
   cc::OutputSurface::SetNeedsBeginFrame(enable);
   needs_begin_frame_ = enable;
   SynchronousCompositorOutputSurfaceDelegate* delegate = GetDelegate();
   if (delegate)
     delegate->SetContinuousInvalidate(needs_begin_frame_);
 }
 
 void SynchronousCompositorOutputSurface::SwapBuffers(
     cc::CompositorFrame* frame) {
   if (!ForcedDrawToSoftwareDevice()) {
-    DCHECK(context3d());
-    context3d()->shallowFlushCHROMIUM();
+    DCHECK(context_provider_);
+    context_provider_->Context3d()->shallowFlushCHROMIUM();
   }
   SynchronousCompositorOutputSurfaceDelegate* delegate = GetDelegate();
   if (delegate)
     delegate->UpdateFrameMetaData(frame->metadata);
 
   did_swap_buffer_ = true;
   DidSwapBuffers();
 }
 
 namespace {
 void AdjustTransformForClip(gfx::Transform* transform, gfx::Rect clip) {
   // The system-provided transform translates us from the screen origin to the
   // origin of the clip rect, but CC's draw origin starts at the clip.
   transform->matrix().postTranslate(-clip.x(), -clip.y(), 0);
 }
 } // namespace
 
 bool SynchronousCompositorOutputSurface::InitializeHwDraw(
     scoped_refptr<gfx::GLSurface> surface,
-    scoped_refptr<cc::ContextProvider> offscreen_context) {
+    scoped_refptr<cc::ContextProvider> offscreen_context_provider) {
   DCHECK(CalledOnValidThread());
   DCHECK(HasClient());
-  DCHECK(!context3d_);
+  DCHECK(!context_provider_);
   DCHECK(surface);
 
-  return InitializeAndSetContext3D(
-      CreateWebGraphicsContext3D(surface).Pass(), offscreen_context);
+  scoped_refptr<cc::ContextProvider> onscreen_context_provider =
+      webkit::gpu::ContextProviderInProcess::Create(
+          base::Bind(&CreateWebGraphicsContext3D, surface));
+  return InitializeAndSetContext3d(onscreen_context_provider,
+                                   offscreen_context_provider);
 }
 
 void SynchronousCompositorOutputSurface::ReleaseHwDraw() {
   cc::OutputSurface::ReleaseGL();
 }
 
 bool SynchronousCompositorOutputSurface::DemandDrawHw(
     gfx::Size surface_size,
     const gfx::Transform& transform,
     gfx::Rect clip,
     bool stencil_enabled) {
   DCHECK(CalledOnValidThread());
   DCHECK(HasClient());
-  DCHECK(context3d());
+  DCHECK(context_provider_);
 
   gfx::Transform adjusted_transform = transform;
   AdjustTransformForClip(&adjusted_transform, clip);
   surface_size_ = surface_size;
   SetExternalDrawConstraints(adjusted_transform, clip);
   SetExternalStencilTest(stencil_enabled);
   InvokeComposite(clip.size());
 
   return did_swap_buffer_;
 }
@@ skipping 46 matching lines @@
 bool SynchronousCompositorOutputSurface::CalledOnValidThread() const {
   return BrowserThread::CurrentlyOn(BrowserThread::UI);
 }
 
 SynchronousCompositorOutputSurfaceDelegate*
 SynchronousCompositorOutputSurface::GetDelegate() {
   return SynchronousCompositorImpl::FromRoutingID(routing_id_);
 }
 
 }  // namespace content