Add signalSyncPoint to the WebGraphicsContext3D command buffer impls.

webkit/gpu/webgraphicscontext3d_in_process_command_buffer_impl.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 "webkit/gpu/webgraphicscontext3d_in_process_command_buffer_impl.h"
 
 #include <GLES2/gl2.h>
 #ifndef GL_GLEXT_PROTOTYPES
 #define GL_GLEXT_PROTOTYPES 1
 #endif
@@ skipping 121 matching lines @@
   // can be used without making it current.
   GLES2Implementation* GetImplementation();
 
   // Return the current error.
   Error GetError();
 
   // Return true if GPU process reported GLInProcessContext lost or there was a
   // problem communicating with the GPU process.
   bool IsCommandBufferContextLost();
 
+  void LoseContext(uint32 current, uint32 other);
+
+  void SetSignalSyncPointCallback(
+      scoped_ptr<
+        WebKit::WebGraphicsContext3D::WebGraphicsSyncPointCallback> callback);
+
   CommandBufferService* GetCommandBufferService();
 
   ::gpu::gles2::GLES2Decoder* GetDecoder();
 
  private:
   explicit GLInProcessContext(bool share_resources);
 
   bool Initialize(bool is_offscreen,
                   gfx::AcceleratedWidget window,
                   const gfx::Size& size,
                   const char* allowed_extensions,
                   const int32* attrib_list,
                   gfx::GpuPreference gpu_preference);
   void Destroy();
 
   void OnContextLost();
 
   base::Closure context_lost_callback_;
   scoped_ptr<TransferBufferManagerInterface> transfer_buffer_manager_;
   scoped_ptr<CommandBufferService> command_buffer_;
   scoped_ptr< ::gpu::GpuScheduler> gpu_scheduler_;
   scoped_ptr< ::gpu::gles2::GLES2Decoder> decoder_;
   scoped_refptr<gfx::GLContext> context_;
   scoped_refptr<gfx::GLSurface> surface_;
   scoped_ptr<GLES2CmdHelper> gles2_helper_;
   scoped_ptr<TransferBuffer> transfer_buffer_;
   scoped_ptr<GLES2Implementation> gles2_implementation_;
+  scoped_ptr<WebKit::WebGraphicsContext3D::WebGraphicsSyncPointCallback>
+      signal_sync_point_callback_;
   Error last_error_;
   bool share_resources_;
   bool context_lost_;
 
   DISALLOW_COPY_AND_ASSIGN(GLInProcessContext);
 };
 
 namespace {
 
 const int32 kCommandBufferSize = 1024 * 1024;
@@ skipping 95 matching lines @@
 }
 
 AutoLockAndDecoderDetachThread::~AutoLockAndDecoderDetachThread() {
   std::for_each(contexts_.begin(),
                 contexts_.end(),
                 &DetachThread);
 }
 
 }  // namespace
 
+static void CallAndDestroy(
+    scoped_ptr<
+      WebKit::WebGraphicsContext3D::WebGraphicsSyncPointCallback> callback) {
+  callback->onSyncPointReached();
+}
+
 void GLInProcessContext::PumpCommands() {
   if (!context_lost_) {
     AutoLockAndDecoderDetachThread lock(g_decoder_lock.Get(),
                                         g_all_shared_contexts.Get());
     decoder_->MakeCurrent();
     gpu_scheduler_->PutChanged();
     ::gpu::CommandBuffer::State state = command_buffer_->GetState();
-    if (::gpu::error::IsError(state.error)) {
+    if (::gpu::error::IsError(state.error))
       context_lost_ = true;
-    }
+  }
+
+  if (!context_lost_ && signal_sync_point_callback_) {
+    base::MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(&CallAndDestroy,
+                   base::Passed(&signal_sync_point_callback_)));
   }
 }
 
 bool GLInProcessContext::GetBufferChanged(int32 transfer_buffer_id) {
   return gpu_scheduler_->SetGetBuffer(transfer_buffer_id);
 }
 
 uint32 GLInProcessContext::GetParentTextureId() {
   return 0;
 }
@@ skipping 57 matching lines @@
 }
 
 bool GLInProcessContext::IsCommandBufferContextLost() {
   if (context_lost_ || !command_buffer_.get()) {
     return true;
   }
   CommandBuffer::State state = command_buffer_->GetState();
   return ::gpu::error::IsError(state.error);
 }
 
+void GLInProcessContext::LoseContext(uint32 current, uint32 other) {
+  gles2_implementation_->LoseContextCHROMIUM(current, other);
+  gles2_implementation_->Finish();
+  DCHECK(IsCommandBufferContextLost());
+}
+
+void GLInProcessContext::SetSignalSyncPointCallback(
+    scoped_ptr<
+      WebKit::WebGraphicsContext3D::WebGraphicsSyncPointCallback> callback) {
+  signal_sync_point_callback_ = callback.Pass();
+}
+
 CommandBufferService* GLInProcessContext::GetCommandBufferService() {
   return command_buffer_.get();
 }
 
 ::gpu::gles2::GLES2Decoder* GLInProcessContext::GetDecoder() {
   return decoder_.get();
 }
 
 // TODO(gman): Remove This
 void GLInProcessContext::DisableShaderTranslation() {
@@ skipping 66 matching lines @@
     LOG(ERROR) << "Could not initialize command buffer.";
     Destroy();
     return false;
   }
 
   GLInProcessContext* context_group = NULL;
 
   {
     AutoLockAndDecoderDetachThread lock(g_decoder_lock.Get(),
                                         g_all_shared_contexts.Get());
-    if (share_resources_ && !g_all_shared_contexts.Get().empty())
-      context_group = *g_all_shared_contexts.Get().begin();
+    if (share_resources_ && !g_all_shared_contexts.Get().empty()) {
+      for (std::set<GLInProcessContext*>::iterator it =
+               g_all_shared_contexts.Get().begin();
+           it != g_all_shared_contexts.Get().end();
+           ++it) {
+        if (!(*it)->IsCommandBufferContextLost()) {
+          context_group = *it;
+          break;
+        }
+      }
+      if (!context_group)
+        share_group = new gfx::GLShareGroup;
+    }
 
     // TODO(gman): This needs to be true if this is Pepper.
     bool bind_generates_resource = false;
     decoder_.reset(::gpu::gles2::GLES2Decoder::Create(context_group ?
         context_group->decoder_->GetContextGroup() :
             new ::gpu::gles2::ContextGroup(
                 NULL, NULL, NULL, bind_generates_resource)));
 
     gpu_scheduler_.reset(new GpuScheduler(command_buffer_.get(),
                                           decoder_.get(),
@@ skipping 128 matching lines @@
   if (decoder_.get()) {
     decoder_->Destroy(!context_lost);
   }
 
   g_all_shared_contexts.Pointer()->erase(this);
 }
 
 void GLInProcessContext::OnContextLost() {
   if (!context_lost_callback_.is_null())
     context_lost_callback_.Run();
+
+  context_lost_ = true;
+  if (share_resources_) {
+      for (std::set<GLInProcessContext*>::iterator it =
+               g_all_shared_contexts.Get().begin();
+           it != g_all_shared_contexts.Get().end();
+           ++it)
+        (*it)->context_lost_ = true;
+  }
 }
 
 // static
 void
 WebGraphicsContext3DInProcessCommandBufferImpl::EnableVirtualizedContext() {
 #if !defined(NDEBUG)
   {
     AutoLockAndDecoderDetachThread lock(g_decoder_lock.Get(),
                                         g_all_shared_contexts.Get());
     DCHECK(g_all_shared_contexts.Get().empty());
@@ skipping 1167 matching lines @@
 
 DELEGATE_TO_GL_1(genMailboxCHROMIUM, GenMailboxCHROMIUM, WGC3Dbyte*)
 DELEGATE_TO_GL_2(produceTextureCHROMIUM, ProduceTextureCHROMIUM,
                  WGC3Denum, const WGC3Dbyte*)
 DELEGATE_TO_GL_2(consumeTextureCHROMIUM, ConsumeTextureCHROMIUM,
                  WGC3Denum, const WGC3Dbyte*)
 
 DELEGATE_TO_GL_2(drawBuffersEXT, DrawBuffersEXT,
                  WGC3Dsizei, const WGC3Denum*)
 
+unsigned WebGraphicsContext3DInProcessCommandBufferImpl::insertSyncPoint() {
+  shallowFlushCHROMIUM();
+  return 0;
+}
+
+void WebGraphicsContext3DInProcessCommandBufferImpl::signalSyncPoint(
+    unsigned sync_point,
+    WebGraphicsSyncPointCallback* callback) {
+  // Take ownership of the callback.
+  context_->SetSignalSyncPointCallback(make_scoped_ptr(callback));
+  // Stick something in the command buffer.
+  shallowFlushCHROMIUM();
+}
+
+void WebGraphicsContext3DInProcessCommandBufferImpl::loseContextCHROMIUM(
+    WGC3Denum current, WGC3Denum other) {
+  context_->LoseContext(current, other);
+}
+
 DELEGATE_TO_GL_9(asyncTexImage2DCHROMIUM, AsyncTexImage2DCHROMIUM,
     WGC3Denum, WGC3Dint, WGC3Denum, WGC3Dsizei, WGC3Dsizei, WGC3Dint,
     WGC3Denum, WGC3Denum, const void*)
 
 DELEGATE_TO_GL_9(asyncTexSubImage2DCHROMIUM, AsyncTexSubImage2DCHROMIUM,
     WGC3Denum, WGC3Dint, WGC3Dint, WGC3Dint, WGC3Dsizei, WGC3Dsizei,
     WGC3Denum, WGC3Denum, const void*)
 
 DELEGATE_TO_GL_1(waitAsyncTexImage2DCHROMIUM, WaitAsyncTexImage2DCHROMIUM,
     WGC3Denum)
 
 }  // namespace gpu
 }  // namespace webkit