gpu: Expose GLFence impls

Move implementations to their own header+source files.

Then specifically use EGL_KHR_fence_sync implementation for
mailbox synchronizing because it's the only one working across
contexts and share groups.

Review URL: https://codereview.chromium.org/337783005

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@279621 0039d316-1c4b-4281-b951-d872f2087c98

3 files changed, 129 insertions, 84 deletions

diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest.cc b/gpu/command_buffer/service/gles2_cmd_decoder_unittest.cc
index f97a6dc5b..15eb0ea 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest.cc
@@ -721,6 +721,11 @@ static void CheckBeginEndQueryBadMemoryFails(GLES2DecoderTestBase* test,
     EXPECT_CALL(*gl, FenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0))
         .WillOnce(Return(kGlSync))
         .RetiresOnSaturation();
+#if DCHECK_IS_ON
+    EXPECT_CALL(*gl, IsSync(kGlSync))
+        .WillOnce(Return(GL_TRUE))
+        .RetiresOnSaturation();
+#endif
   }
 
   EndQueryEXT end_cmd;
@@ -737,6 +742,11 @@ static void CheckBeginEndQueryBadMemoryFails(GLES2DecoderTestBase* test,
         .RetiresOnSaturation();
   }
   if (query_type.type == GL_COMMANDS_COMPLETED_CHROMIUM) {
+#if DCHECK_IS_ON
+    EXPECT_CALL(*gl, IsSync(kGlSync))
+        .WillOnce(Return(GL_TRUE))
+        .RetiresOnSaturation();
+#endif
     EXPECT_CALL(*gl, ClientWaitSync(kGlSync, _, _))
         .WillOnce(Return(GL_ALREADY_SIGNALED))
         .RetiresOnSaturation();
@@ -752,8 +762,14 @@ static void CheckBeginEndQueryBadMemoryFails(GLES2DecoderTestBase* test,
   if (query_type.is_gl) {
     EXPECT_CALL(*gl, DeleteQueriesARB(1, _)).Times(1).RetiresOnSaturation();
   }
-  if (query_type.type == GL_COMMANDS_COMPLETED_CHROMIUM)
+  if (query_type.type == GL_COMMANDS_COMPLETED_CHROMIUM) {
+#if DCHECK_IS_ON
+    EXPECT_CALL(*gl, IsSync(kGlSync))
+        .WillOnce(Return(GL_TRUE))
+        .RetiresOnSaturation();
+#endif
     EXPECT_CALL(*gl, DeleteSync(kGlSync)).Times(1).RetiresOnSaturation();
+  }
   test->ResetDecoder();
 }
 
@@ -879,6 +895,11 @@ TEST_P(GLES2DecoderManualInitTest, BeginEndQueryEXTCommandsCompletedCHROMIUM) {
   EXPECT_CALL(*gl_, FenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0))
       .WillOnce(Return(kGlSync))
       .RetiresOnSaturation();
+#if DCHECK_IS_ON
+  EXPECT_CALL(*gl_, IsSync(kGlSync))
+      .WillOnce(Return(GL_TRUE))
+      .RetiresOnSaturation();
+#endif
 
   EndQueryEXT end_cmd;
   end_cmd.Init(GL_COMMANDS_COMPLETED_CHROMIUM, 1);
@@ -886,6 +907,11 @@ TEST_P(GLES2DecoderManualInitTest, BeginEndQueryEXTCommandsCompletedCHROMIUM) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_TRUE(query->pending());
 
+#if DCHECK_IS_ON
+  EXPECT_CALL(*gl_, IsSync(kGlSync))
+      .WillOnce(Return(GL_TRUE))
+      .RetiresOnSaturation();
+#endif
   EXPECT_CALL(*gl_, ClientWaitSync(kGlSync, _, _))
       .WillOnce(Return(GL_TIMEOUT_EXPIRED))
       .RetiresOnSaturation();
@@ -894,6 +920,11 @@ TEST_P(GLES2DecoderManualInitTest, BeginEndQueryEXTCommandsCompletedCHROMIUM) {
   EXPECT_TRUE(process_success);
   EXPECT_TRUE(query->pending());
 
+#if DCHECK_IS_ON
+  EXPECT_CALL(*gl_, IsSync(kGlSync))
+      .WillOnce(Return(GL_TRUE))
+      .RetiresOnSaturation();
+#endif
   EXPECT_CALL(*gl_, ClientWaitSync(kGlSync, _, _))
       .WillOnce(Return(GL_ALREADY_SIGNALED))
       .RetiresOnSaturation();
@@ -904,6 +935,11 @@ TEST_P(GLES2DecoderManualInitTest, BeginEndQueryEXTCommandsCompletedCHROMIUM) {
   QuerySync* sync = static_cast<QuerySync*>(shared_memory_address_);
   EXPECT_EQ(static_cast<GLenum>(0), static_cast<GLenum>(sync->result));
 
+#if DCHECK_IS_ON
+  EXPECT_CALL(*gl_, IsSync(kGlSync))
+      .WillOnce(Return(GL_TRUE))
+      .RetiresOnSaturation();
+#endif
   EXPECT_CALL(*gl_, DeleteSync(kGlSync)).Times(1).RetiresOnSaturation();
   ResetDecoder();
 }
diff --git a/gpu/command_buffer/service/texture_definition.cc b/gpu/command_buffer/service/texture_definition.cc
index 24382f0..d7b99b2 100644
--- a/gpu/command_buffer/service/texture_definition.cc
+++ b/gpu/command_buffer/service/texture_definition.cc
@@ -105,11 +105,32 @@ class NativeImageBufferEGL : public NativeImageBuffer {
                        EGLDisplay display,
                        EGLImageKHR image);
   virtual ~NativeImageBufferEGL();
+  virtual void AddClient(gfx::GLImage* client) OVERRIDE;
+  virtual void RemoveClient(gfx::GLImage* client) OVERRIDE;
+  virtual bool IsClient(gfx::GLImage* client) OVERRIDE;
   virtual void BindToTexture(GLenum target) OVERRIDE;
+  virtual void WillRead(gfx::GLImage* client) OVERRIDE;
+  virtual void WillWrite(gfx::GLImage* client) OVERRIDE;
+  virtual void DidRead(gfx::GLImage* client) OVERRIDE;
+  virtual void DidWrite(gfx::GLImage* client) OVERRIDE;
 
   EGLDisplay egl_display_;
   EGLImageKHR egl_image_;
 
+  base::Lock lock_;
+
+  struct ClientInfo {
+    ClientInfo(gfx::GLImage* client);
+    ~ClientInfo();
+
+    gfx::GLImage* client;
+    bool needs_wait_before_read;
+    linked_ptr<gfx::GLFence> read_fence;
+  };
+  std::list<ClientInfo> client_infos_;
+  scoped_ptr<gfx::GLFence> write_fence_;
+  gfx::GLImage* write_client_;
+
   DISALLOW_COPY_AND_ASSIGN(NativeImageBufferEGL);
 };
 
@@ -142,76 +163,35 @@ scoped_refptr<NativeImageBufferEGL> NativeImageBufferEGL::Create(
       make_scoped_ptr(gfx::GLFence::Create()), egl_display, egl_image);
 }
 
+NativeImageBufferEGL::ClientInfo::ClientInfo(gfx::GLImage* client)
+    : client(client), needs_wait_before_read(true) {}
+
+NativeImageBufferEGL::ClientInfo::~ClientInfo() {}
+
 NativeImageBufferEGL::NativeImageBufferEGL(scoped_ptr<gfx::GLFence> write_fence,
                                            EGLDisplay display,
                                            EGLImageKHR image)
-    : NativeImageBuffer(write_fence.Pass()),
+    : NativeImageBuffer(),
       egl_display_(display),
-      egl_image_(image) {
+      egl_image_(image),
+      write_fence_(write_fence.Pass()),
+      write_client_(NULL) {
   DCHECK(egl_display_ != EGL_NO_DISPLAY);
   DCHECK(egl_image_ != EGL_NO_IMAGE_KHR);
 }
 
 NativeImageBufferEGL::~NativeImageBufferEGL() {
+  DCHECK(client_infos_.empty());
   if (egl_image_ != EGL_NO_IMAGE_KHR)
     eglDestroyImageKHR(egl_display_, egl_image_);
 }
 
-void NativeImageBufferEGL::BindToTexture(GLenum target) {
-  DCHECK(egl_image_ != EGL_NO_IMAGE_KHR);
-  glEGLImageTargetTexture2DOES(target, egl_image_);
-  DCHECK_EQ(static_cast<EGLint>(EGL_SUCCESS), eglGetError());
-  DCHECK_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError());
-}
-#endif
-
-class NativeImageBufferStub : public NativeImageBuffer {
- public:
-  NativeImageBufferStub() : NativeImageBuffer(scoped_ptr<gfx::GLFence>()) {}
-
- private:
-  virtual ~NativeImageBufferStub() {}
-  virtual void BindToTexture(GLenum target) OVERRIDE {}
-
-  DISALLOW_COPY_AND_ASSIGN(NativeImageBufferStub);
-};
-
-}  // anonymous namespace
-
-// static
-scoped_refptr<NativeImageBuffer> NativeImageBuffer::Create(GLuint texture_id) {
-  switch (gfx::GetGLImplementation()) {
-#if !defined(OS_MACOSX)
-    case gfx::kGLImplementationEGLGLES2:
-      return NativeImageBufferEGL::Create(texture_id);
-#endif
-    case gfx::kGLImplementationMockGL:
-      return new NativeImageBufferStub;
-    default:
-      NOTREACHED();
-      return NULL;
-  }
-}
-
-NativeImageBuffer::ClientInfo::ClientInfo(gfx::GLImage* client)
-    : client(client), needs_wait_before_read(true) {}
-
-NativeImageBuffer::ClientInfo::~ClientInfo() {}
-
-NativeImageBuffer::NativeImageBuffer(scoped_ptr<gfx::GLFence> write_fence)
-    : write_fence_(write_fence.Pass()), write_client_(NULL) {
-}
-
-NativeImageBuffer::~NativeImageBuffer() {
-  DCHECK(client_infos_.empty());
-}
-
-void NativeImageBuffer::AddClient(gfx::GLImage* client) {
+void NativeImageBufferEGL::AddClient(gfx::GLImage* client) {
   base::AutoLock lock(lock_);
   client_infos_.push_back(ClientInfo(client));
 }
 
-void NativeImageBuffer::RemoveClient(gfx::GLImage* client) {
+void NativeImageBufferEGL::RemoveClient(gfx::GLImage* client) {
   base::AutoLock lock(lock_);
   if (write_client_ == client)
     write_client_ = NULL;
@@ -226,7 +206,7 @@ void NativeImageBuffer::RemoveClient(gfx::GLImage* client) {
   NOTREACHED();
 }
 
-bool NativeImageBuffer::IsClient(gfx::GLImage* client) {
+bool NativeImageBufferEGL::IsClient(gfx::GLImage* client) {
   base::AutoLock lock(lock_);
   for (std::list<ClientInfo>::iterator it = client_infos_.begin();
        it != client_infos_.end();
@@ -237,7 +217,14 @@ bool NativeImageBuffer::IsClient(gfx::GLImage* client) {
   return false;
 }
 
-void NativeImageBuffer::WillRead(gfx::GLImage* client) {
+void NativeImageBufferEGL::BindToTexture(GLenum target) {
+  DCHECK(egl_image_ != EGL_NO_IMAGE_KHR);
+  glEGLImageTargetTexture2DOES(target, egl_image_);
+  DCHECK_EQ(static_cast<EGLint>(EGL_SUCCESS), eglGetError());
+  DCHECK_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError());
+}
+
+void NativeImageBufferEGL::WillRead(gfx::GLImage* client) {
   base::AutoLock lock(lock_);
   if (!write_fence_.get() || write_client_ == client)
     return;
@@ -256,7 +243,7 @@ void NativeImageBuffer::WillRead(gfx::GLImage* client) {
   NOTREACHED();
 }
 
-void NativeImageBuffer::WillWrite(gfx::GLImage* client) {
+void NativeImageBufferEGL::WillWrite(gfx::GLImage* client) {
   base::AutoLock lock(lock_);
   if (write_client_ != client)
     write_fence_->ServerWait();
@@ -269,7 +256,7 @@ void NativeImageBuffer::WillWrite(gfx::GLImage* client) {
   }
 }
 
-void NativeImageBuffer::DidRead(gfx::GLImage* client) {
+void NativeImageBufferEGL::DidRead(gfx::GLImage* client) {
   base::AutoLock lock(lock_);
   for (std::list<ClientInfo>::iterator it = client_infos_.begin();
        it != client_infos_.end();
@@ -282,7 +269,7 @@ void NativeImageBuffer::DidRead(gfx::GLImage* client) {
   NOTREACHED();
 }
 
-void NativeImageBuffer::DidWrite(gfx::GLImage* client) {
+void NativeImageBufferEGL::DidWrite(gfx::GLImage* client) {
   base::AutoLock lock(lock_);
   // Sharing semantics require the client to flush in order to make changes
   // visible to other clients.
@@ -295,6 +282,43 @@ void NativeImageBuffer::DidWrite(gfx::GLImage* client) {
   }
 }
 
+#endif
+
+class NativeImageBufferStub : public NativeImageBuffer {
+ public:
+  NativeImageBufferStub() : NativeImageBuffer() {}
+
+ private:
+  virtual ~NativeImageBufferStub() {}
+  virtual void AddClient(gfx::GLImage* client) OVERRIDE {}
+  virtual void RemoveClient(gfx::GLImage* client) OVERRIDE {}
+  virtual bool IsClient(gfx::GLImage* client) OVERRIDE { return true; }
+  virtual void BindToTexture(GLenum target) OVERRIDE {}
+  virtual void WillRead(gfx::GLImage* client) OVERRIDE {}
+  virtual void WillWrite(gfx::GLImage* client) OVERRIDE {}
+  virtual void DidRead(gfx::GLImage* client) OVERRIDE {}
+  virtual void DidWrite(gfx::GLImage* client) OVERRIDE {}
+
+  DISALLOW_COPY_AND_ASSIGN(NativeImageBufferStub);
+};
+
+}  // anonymous namespace
+
+// static
+scoped_refptr<NativeImageBuffer> NativeImageBuffer::Create(GLuint texture_id) {
+  switch (gfx::GetGLImplementation()) {
+#if !defined(OS_MACOSX)
+    case gfx::kGLImplementationEGLGLES2:
+      return NativeImageBufferEGL::Create(texture_id);
+#endif
+    case gfx::kGLImplementationMockGL:
+      return new NativeImageBufferStub;
+    default:
+      NOTREACHED();
+      return NULL;
+  }
+}
+
 TextureDefinition::LevelInfo::LevelInfo(GLenum target,
                                         GLenum internal_format,
                                         GLsizei width,
diff --git a/gpu/command_buffer/service/texture_definition.h b/gpu/command_buffer/service/texture_definition.h
index 7708902..0b4816a 100644
--- a/gpu/command_buffer/service/texture_definition.h
+++ b/gpu/command_buffer/service/texture_definition.h
@@ -29,35 +29,20 @@ class Texture;
 class NativeImageBuffer : public base::RefCountedThreadSafe<NativeImageBuffer> {
  public:
   static scoped_refptr<NativeImageBuffer> Create(GLuint texture_id);
-  virtual void BindToTexture(GLenum target) = 0;
-
-  void AddClient(gfx::GLImage* client);
-  void RemoveClient(gfx::GLImage* client);
-  bool IsClient(gfx::GLImage* client);
 
-  void WillRead(gfx::GLImage* client);
-  void WillWrite(gfx::GLImage* client);
-  void DidRead(gfx::GLImage* client);
-  void DidWrite(gfx::GLImage* client);
+  virtual void AddClient(gfx::GLImage* client) = 0;
+  virtual void RemoveClient(gfx::GLImage* client) = 0;
+  virtual bool IsClient(gfx::GLImage* client) = 0;
+  virtual void BindToTexture(GLenum target) = 0;
+  virtual void WillRead(gfx::GLImage* client) = 0;
+  virtual void WillWrite(gfx::GLImage* client) = 0;
+  virtual void DidRead(gfx::GLImage* client) = 0;
+  virtual void DidWrite(gfx::GLImage* client) = 0;
 
  protected:
   friend class base::RefCountedThreadSafe<NativeImageBuffer>;
-  explicit NativeImageBuffer(scoped_ptr<gfx::GLFence> write_fence);
-  virtual ~NativeImageBuffer();
-
-  base::Lock lock_;
-
-  struct ClientInfo {
-    ClientInfo(gfx::GLImage* client);
-    ~ClientInfo();
-
-    gfx::GLImage* client;
-    bool needs_wait_before_read;
-    linked_ptr<gfx::GLFence> read_fence;
-  };
-  std::list<ClientInfo> client_infos_;
-  scoped_ptr<gfx::GLFence> write_fence_;
-  gfx::GLImage* write_client_;
+  NativeImageBuffer() {}
+  virtual ~NativeImageBuffer() {}
 
   DISALLOW_COPY_AND_ASSIGN(NativeImageBuffer);
 };