compile

content/browser/android/in_process/synchronous_compositor_factory_impl.cc

 // Copyright 2014 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_factory_impl.h"
 
 #include "content/browser/android/in_process/synchronous_compositor_output_surface.h"
 #include "content/public/browser/browser_thread.h"
 #include "gpu/command_buffer/client/gl_in_process_context.h"
 #include "ui/gl/android/surface_texture.h"
 #include "ui/gl/gl_surface.h"
+#include "ui/gl/gl_surface_stub.h"
 #include "webkit/common/gpu/context_provider_in_process.h"
 #include "webkit/common/gpu/webgraphicscontext3d_in_process_command_buffer_impl.h"
 
 using webkit::gpu::ContextProviderWebContext;
 
 namespace content {
 
 namespace {
 
 blink::WebGraphicsContext3D::Attributes GetDefaultAttribs() {
   blink::WebGraphicsContext3D::Attributes attributes;
   attributes.antialias = false;
   attributes.shareResources = true;
   attributes.noAutomaticFlushes = true;
+  attributes.stencil = false;
+  attributes.depth = false;
 
   return attributes;
 }
 
 using webkit::gpu::WebGraphicsContext3DInProcessCommandBufferImpl;
 
 scoped_ptr<gpu::GLInProcessContext> CreateContext(
     scoped_refptr<gfx::GLSurface> surface,
     scoped_refptr<gpu::InProcessCommandBuffer::Service> service,
     gpu::GLInProcessContext* share_context) {
@@ skipping 27 matching lines @@
 class VideoContextProvider
     : public StreamTextureFactorySynchronousImpl::ContextProvider {
  public:
   VideoContextProvider(
       scoped_ptr<gpu::GLInProcessContext> gl_in_process_context)
       : gl_in_process_context_(gl_in_process_context.get()) {
 
     context_provider_ = webkit::gpu::ContextProviderInProcess::Create(
         WrapContext(gl_in_process_context.Pass()),
         "Video-Offscreen-main-thread");
+    context_provider_->BindToCurrentThread();
   }
 
   virtual scoped_refptr<gfx::SurfaceTexture> GetSurfaceTexture(
       uint32 stream_id) OVERRIDE {
     return gl_in_process_context_->GetSurfaceTexture(stream_id);
   }
 
   virtual gpu::gles2::GLES2Interface* ContextGL() OVERRIDE {
     return context_provider_->ContextGL();
   }
@@ skipping 68 matching lines @@
 // the same task. This is ok because in-process WGC3D creation may happen on
 // any thread and is lightweight.
 scoped_refptr<cc::ContextProvider> SynchronousCompositorFactoryImpl::
     GetOffscreenContextProviderForCompositorThread() {
   base::AutoLock lock(offscreen_context_for_compositor_thread_lock_);
   DCHECK(service_);
   bool failed = false;
   if (!offscreen_context_for_compositor_thread_.get() ||
       offscreen_context_for_compositor_thread_->DestroyedOnMainThread()) {
     scoped_ptr<gpu::GLInProcessContext> context =
-        CreateContext(NULL, service_, NULL);
+        CreateContext(new gfx::GLSurfaceStub, service_, NULL);
     wrapped_gl_context_for_compositor_thread_ = context.get();
     offscreen_context_for_compositor_thread_ =
         webkit::gpu::ContextProviderInProcess::Create(
             WrapContext(context.Pass()),
             "Compositor-Offscreen-compositor-thread");
     failed = !offscreen_context_for_compositor_thread_.get() ||
              !offscreen_context_for_compositor_thread_->BindToCurrentThread();
   }
   if (failed) {
     offscreen_context_for_compositor_thread_ = NULL;
@@ skipping 63 matching lines @@
   scoped_refptr<StreamTextureFactorySynchronousImpl::ContextProvider>
       context_provider;
   // This check only guarantees the main thread context is created after
   // a compositor did successfully initialize hardware draw in the past.
   // In particular this does not guarantee that the main thread context
   // will fail creation when all compositors release hardware draw.
   if (CanCreateMainThreadContext() && !video_context_provider_) {
     DCHECK(service_);
     DCHECK(wrapped_gl_context_for_compositor_thread_);
 
-    video_context_provider_ = new VideoContextProvider(CreateContext(
-        NULL, service_, wrapped_gl_context_for_compositor_thread_));
+    video_context_provider_ = new VideoContextProvider(
+        CreateContext(new gfx::GLSurfaceStub,
+                      service_,
+                      wrapped_gl_context_for_compositor_thread_));
   }
   return video_context_provider_;
 }
 
 void SynchronousCompositorFactoryImpl::SetDeferredGpuService(
     scoped_refptr<gpu::InProcessCommandBuffer::Service> service) {
   DCHECK(!service_);
   service_ = service;
 }
 
 }  // namespace content