Update from chromium a8e7c94b1b79a0948d05a1fcfff53391d22ce37a

gpu/command_buffer/service/texture_definition.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 "gpu/command_buffer/service/texture_definition.h"
 
 #include <list>
 
 #include "base/memory/linked_ptr.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/synchronization/lock.h"
 #include "gpu/command_buffer/service/texture_manager.h"
 #include "ui/gl/gl_image.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/scoped_binders.h"
 
 #if !defined(OS_MACOSX)
-#include "ui/gl/gl_fence_egl.h"
 #include "ui/gl/gl_surface_egl.h"
 #endif
 
 namespace gpu {
 namespace gles2 {
 
 namespace {
 
 class GLImageSync : public gfx::GLImage {
  public:
@@ skipping 52 matching lines @@
 
 void GLImageSync::ReleaseTexImage(unsigned target) {
   NOTREACHED();
 }
 
 bool GLImageSync::CopyTexImage(unsigned target) {
   return false;
 }
 
 void GLImageSync::WillUseTexImage() {
-  if (buffer_.get())
-    buffer_->WillRead(this);
 }
 
 void GLImageSync::DidUseTexImage() {
-  if (buffer_.get())
-    buffer_->DidRead(this);
 }
 
 void GLImageSync::WillModifyTexImage() {
-  if (buffer_.get())
-    buffer_->WillWrite(this);
 }
 
 void GLImageSync::DidModifyTexImage() {
-  if (buffer_.get())
-    buffer_->DidWrite(this);
 }
 
 bool GLImageSync::ScheduleOverlayPlane(gfx::AcceleratedWidget widget,
                                        int z_order,
                                        gfx::OverlayTransform transform,
                                        const gfx::Rect& bounds_rect,
                                        const gfx::RectF& crop_rect) {
   NOTREACHED();
   return false;
 }
 
 #if !defined(OS_MACOSX)
 class NativeImageBufferEGL : public NativeImageBuffer {
  public:
   static scoped_refptr<NativeImageBufferEGL> Create(GLuint texture_id);
 
  private:
   NativeImageBufferEGL(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);
 };
 
 scoped_refptr<NativeImageBufferEGL> NativeImageBufferEGL::Create(
     GLuint texture_id) {
   EGLDisplay egl_display = gfx::GLSurfaceEGL::GetHardwareDisplay();
   EGLContext egl_context = eglGetCurrentContext();
 
   DCHECK_NE(EGL_NO_CONTEXT, egl_context);
   DCHECK_NE(EGL_NO_DISPLAY, egl_display);
   DCHECK(glIsTexture(texture_id));
 
   DCHECK(gfx::g_driver_egl.ext.b_EGL_KHR_image_base &&
          gfx::g_driver_egl.ext.b_EGL_KHR_gl_texture_2D_image &&
-         gfx::g_driver_gl.ext.b_GL_OES_EGL_image &&
-         gfx::g_driver_egl.ext.b_EGL_KHR_fence_sync);
+         gfx::g_driver_gl.ext.b_GL_OES_EGL_image);
 
   const EGLint egl_attrib_list[] = {
       EGL_GL_TEXTURE_LEVEL_KHR, 0, EGL_IMAGE_PRESERVED_KHR, EGL_TRUE, EGL_NONE};
   EGLClientBuffer egl_buffer = reinterpret_cast<EGLClientBuffer>(texture_id);
   EGLenum egl_target = EGL_GL_TEXTURE_2D_KHR; // TODO
 
   EGLImageKHR egl_image = eglCreateImageKHR(
       egl_display, egl_context, egl_target, egl_buffer, egl_attrib_list);
 
   if (egl_image == EGL_NO_IMAGE_KHR)
     return NULL;
 
   return new NativeImageBufferEGL(egl_display, egl_image);
 }
 
 NativeImageBufferEGL::ClientInfo::ClientInfo(gfx::GLImage* client)
     : client(client), needs_wait_before_read(true) {}
 
 NativeImageBufferEGL::ClientInfo::~ClientInfo() {}
 
 NativeImageBufferEGL::NativeImageBufferEGL(EGLDisplay display,
                                            EGLImageKHR image)
     : NativeImageBuffer(),
       egl_display_(display),
       egl_image_(image),
-      write_fence_(new gfx::GLFenceEGL(true)),
       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_);
 }
@@ skipping 29 matching lines @@
   return false;
 }
 
 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;
-
-  for (std::list<ClientInfo>::iterator it = client_infos_.begin();
-       it != client_infos_.end();
-       it++) {
-    if (it->client == client) {
-      if (it->needs_wait_before_read) {
-        it->needs_wait_before_read = false;
-        write_fence_->ServerWait();
-      }
-      return;
-    }
-  }
-  NOTREACHED();
-}
-
-void NativeImageBufferEGL::WillWrite(gfx::GLImage* client) {
-  base::AutoLock lock(lock_);
-  if (write_client_ != client)
-    write_fence_->ServerWait();
-
-  for (std::list<ClientInfo>::iterator it = client_infos_.begin();
-       it != client_infos_.end();
-       it++) {
-    if (it->read_fence.get() && it->client != client)
-      it->read_fence->ServerWait();
-  }
-}
-
-void NativeImageBufferEGL::DidRead(gfx::GLImage* client) {
-  base::AutoLock lock(lock_);
-  for (std::list<ClientInfo>::iterator it = client_infos_.begin();
-       it != client_infos_.end();
-       it++) {
-    if (it->client == client) {
-      it->read_fence = make_linked_ptr(new gfx::GLFenceEGL(true));
-      return;
-    }
-  }
-  NOTREACHED();
-}
-
-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.
-  write_fence_.reset(new gfx::GLFenceEGL(false));
-  write_client_ = client;
-  for (std::list<ClientInfo>::iterator it = client_infos_.begin();
-       it != client_infos_.end();
-       it++) {
-    it->needs_wait_before_read = true;
-  }
-}
-
 #endif
 
 class NativeImageBufferStub : public NativeImageBuffer {
  public:
   NativeImageBufferStub() : NativeImageBuffer() {}
 
  private:
   ~NativeImageBufferStub() override {}
   void AddClient(gfx::GLImage* client) override {}
   void RemoveClient(gfx::GLImage* client) override {}
   bool IsClient(gfx::GLImage* client) override { return true; }
   void BindToTexture(GLenum target) override {}
-  void WillRead(gfx::GLImage* client) override {}
-  void WillWrite(gfx::GLImage* client) override {}
-  void DidRead(gfx::GLImage* client) override {}
-  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)
@@ skipping 160 matching lines @@
 
   // All structural changes should have orphaned the texture.
   if (image_buffer_.get() && !texture->GetLevelImage(texture->target(), 0))
     return false;
 
   return true;
 }
 
 }  // namespace gles2
 }  // namespace gpu