gpu: Add CHROMIUM_texture_from_image spec and fence support.

gpu/command_buffer/service/gles2_cmd_decoder.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 "gpu/command_buffer/service/gles2_cmd_decoder.h"
 
 #include <limits.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
@@ skipping 1018 matching lines @@
                          GLenum target,
                          const volatile GLbyte* data);
 
   void EnsureTextureForClientId(GLenum target, GLuint client_id);
   void DoConsumeTextureCHROMIUM(GLenum target, const volatile GLbyte* key);
   void DoCreateAndConsumeTextureINTERNAL(GLenum target,
                                          GLuint client_id,
                                          const volatile GLbyte* key);
   void DoApplyScreenSpaceAntialiasingCHROMIUM();
 
-  void DoBindTexImage2DCHROMIUM(
-      GLenum target,
-      GLint image_id);
-  void DoReleaseTexImage2DCHROMIUM(
-      GLenum target,
-      GLint image_id);
+  void DoBindTexImage2DCHROMIUM(GLenum target, GLint image_id, GLint fence_id);
+  void DoReleaseTexImage2DCHROMIUM(GLenum target, GLint image_id);
 
   void DoTraceEndCHROMIUM(void);
 
   void DoDrawBuffersEXT(GLsizei count, const volatile GLenum* bufs);
 
   void DoLoseContextCHROMIUM(GLenum current, GLenum other);
 
   void DoFlushDriverCachesCHROMIUM(void);
 
   void DoMatrixLoadfCHROMIUM(GLenum matrix_mode,
@@ skipping 1639 matching lines @@
              : GL_TEXTURE_2D;
 }
 
 bool BackTexture::AllocateNativeGpuMemoryBuffer(const gfx::Size& size,
                                                 GLenum format,
                                                 bool zero) {
   gfx::BufferFormat buffer_format = gfx::BufferFormat::RGBA_8888;
   scoped_refptr<gl::GLImage> image =
       decoder_->GetContextGroup()->image_factory()->CreateAnonymousImage(
           size, buffer_format, format);
-  if (!image || !image->BindTexImage(Target()))
+  if (!image || !image->BindTexImage(Target(), nullptr))
     return false;
 
   image_ = image;
   decoder_->texture_manager()->SetLevelInfo(
       texture_ref_.get(), Target(), 0, image_->GetInternalFormat(),
       size.width(), size.height(), 1, 0, image_->GetInternalFormat(),
       GL_UNSIGNED_BYTE, gfx::Rect(size));
   decoder_->texture_manager()->SetLevelImage(texture_ref_.get(), Target(), 0,
                                              image_.get(), Texture::BOUND);
 
@@ skipping 13696 matching lines @@
       length ? std::string(marker, length) : std::string(marker));
 }
 
 void GLES2DecoderImpl::DoPushGroupMarkerEXT(
     GLsizei /*length*/, const GLchar* /*marker*/) {
 }
 
 void GLES2DecoderImpl::DoPopGroupMarkerEXT(void) {
 }
 
-void GLES2DecoderImpl::DoBindTexImage2DCHROMIUM(
-    GLenum target, GLint image_id) {
+void GLES2DecoderImpl::DoBindTexImage2DCHROMIUM(GLenum target,
+                                                GLint image_id,
+                                                GLint fence_id) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::DoBindTexImage2DCHROMIUM");
 
   if (target == GL_TEXTURE_CUBE_MAP) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_ENUM,
         "glBindTexImage2DCHROMIUM", "invalid target");
     return;
   }
 
   // Default target might be conceptually valid, but disallow it to avoid
   // accidents.
   TextureRef* texture_ref =
       texture_manager()->GetTextureInfoForTargetUnlessDefault(&state_, target);
   if (!texture_ref) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         "glBindTexImage2DCHROMIUM", "no texture bound");
     return;
   }
 
   gl::GLImage* image = image_manager()->LookupImage(image_id);
   if (!image) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         "glBindTexImage2DCHROMIUM", "no image found with the given ID");
     return;
   }
 
+  gl::GLFence* fence = nullptr;
+  if (fence_id) {
+    fence = fence_manager()->LookupFence(fence_id);
+    if (!fence) {
+      LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glBindTexImage2DCHROMIUM",
+                         "no fence found with the given ID");
+      return;
+    }
+  }
+
   Texture::ImageState image_state = Texture::UNBOUND;
 
   {
     ScopedGLErrorSuppressor suppressor(
         "GLES2DecoderImpl::DoBindTexImage2DCHROMIUM", GetErrorState());
 
     // Note: We fallback to using CopyTexImage() before the texture is used
     // when BindTexImage() fails.
-    if (image->BindTexImage(target))
+    if (image->BindTexImage(target, fence))
       image_state = Texture::BOUND;
   }
 
+  DLOG_IF(WARNING, fence && image_state != Texture::BOUND)
+      << "BindTexImage2D fence ignored by CopyTexImage() fallback";
+
   gfx::Size size = image->GetSize();
   GLenum internalformat = image->GetInternalFormat();
   texture_manager()->SetLevelInfo(
       texture_ref, target, 0, internalformat, size.width(), size.height(), 1, 0,
       internalformat, GL_UNSIGNED_BYTE, gfx::Rect(size));
   texture_manager()->SetLevelImage(texture_ref, target, 0, image, image_state);
 }
 
-void GLES2DecoderImpl::DoReleaseTexImage2DCHROMIUM(
-    GLenum target, GLint image_id) {
+void GLES2DecoderImpl::DoReleaseTexImage2DCHROMIUM(GLenum target,
+                                                   GLint image_id) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::DoReleaseTexImage2DCHROMIUM");
 
   // Default target might be conceptually valid, but disallow it to avoid
   // accidents.
   TextureRef* texture_ref =
       texture_manager()->GetTextureInfoForTargetUnlessDefault(&state_, target);
   if (!texture_ref) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         "glReleaseTexImage2DCHROMIUM", "no texture bound");
@@ skipping 1775 matching lines @@
 }
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "base/macros.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu