Re-land: ui: Move GLImage::BindTexImage fallback from GLImage implementations to GLES2CmdDecoder.

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 <stdio.h>
 
 #include <algorithm>
 #include <cmath>
@@ skipping 1948 matching lines @@
   bool IsDrawValid(
       const char* function_name, GLuint max_vertex_accessed, bool instanced,
       GLsizei primcount);
 
   // Returns true if successful, simulated will be true if attrib0 was
   // simulated.
   bool SimulateAttrib0(
       const char* function_name, GLuint max_vertex_accessed, bool* simulated);
   void RestoreStateForAttrib(GLuint attrib, bool restore_array_binding);
 
-  // If an image is bound to texture, this will call Will/DidUseTexImage
+  // Calls WillUseTexImage or copies the image to the texture currently bound
+  // to |textarget| based on the value of |image_state|. The new image state is
+  // returned.
+  Texture::ImageState DoWillUseTexImage(GLenum textarget,
+                                        gfx::GLImage* image,
+                                        Texture::ImageState image_state);
+
+  // Calls DidUseTexImage based on the value of |image_state|.
+  void DoDidUseTexImage(gfx::GLImage* image, Texture::ImageState image_state);
+
+  // If an image is bound to texture, this will call DoWill/DidUseTexImage
   // if needed.
   void DoWillUseTexImageIfNeeded(Texture* texture, GLenum textarget);
   void DoDidUseTexImageIfNeeded(Texture* texture, GLenum textarget);
 
   // Returns false if textures were replaced.
   bool PrepareTexturesForRender();
   void RestoreStateForTextures();
 
   // Returns true if GL_FIXED attribs were simulated.
   bool SimulateFixedAttribs(
@@ skipping 5635 matching lines @@
     const char* filename, int line, const std::string& msg) {
   logger_.LogMessage(filename, line, std::string("RENDER WARNING: ") + msg);
 }
 
 void GLES2DecoderImpl::PerformanceWarning(
     const char* filename, int line, const std::string& msg) {
   logger_.LogMessage(filename, line,
                      std::string("PERFORMANCE WARNING: ") + msg);
 }
 
+Texture::ImageState GLES2DecoderImpl::DoWillUseTexImage(
+    GLenum textarget,
+    gfx::GLImage* image,
+    Texture::ImageState image_state) {
+  switch (image_state) {
+    case Texture::UNBOUND: {
+      bool rv = image->CopyTexImage(textarget);
+      DCHECK(rv) << "Both BindTexImage() and CopyTexImage() failed";
+      return Texture::COPIED;

[Daniele Castagna, 2015/10/14 18:40:35]

nit: should this be UNBOUND, not that it matters.

[reveman, 2015/10/14 19:28:01]

State should change to COPIED to prevent us from copying each time we draw. We
only want to copy once after each BindTexImage2D command from the client.

+    }
+    case Texture::BOUND:
+      image->WillUseTexImage();
+      return Texture::BOUND;
+    case Texture::COPIED:
+      return Texture::COPIED;
+  }
+
+  NOTREACHED();
+  return Texture::UNBOUND;
+}
+
+void GLES2DecoderImpl::DoDidUseTexImage(gfx::GLImage* image,
+                                        Texture::ImageState image_state) {
+  switch (image_state) {
+    case Texture::BOUND:
+      image->DidUseTexImage();
+      return;
+    case Texture::UNBOUND:
+    case Texture::COPIED:
+      return;
+  }
+
+  NOTREACHED();
+}
+
 void GLES2DecoderImpl::DoWillUseTexImageIfNeeded(
     Texture* texture, GLenum textarget) {
   // Image is already in use if texture is attached to a framebuffer.
   if (texture && !texture->IsAttachedToFramebuffer()) {
-    gfx::GLImage* image = texture->GetLevelImage(textarget, 0);
+    Texture::ImageState image_state;
+    gfx::GLImage* image = texture->GetLevelImage(textarget, 0, &image_state);
     if (image) {
       ScopedGLErrorSuppressor suppressor(
           "GLES2DecoderImpl::DoWillUseTexImageIfNeeded",
           GetErrorState());
       glBindTexture(textarget, texture->service_id());
-      image->WillUseTexImage();
+      Texture::ImageState new_image_state =
+          DoWillUseTexImage(textarget, image, image_state);
       RestoreCurrentTextureBindings(&state_, textarget);
+      texture->SetLevelImage(textarget, 0, image, new_image_state);
     }
   }
 }
 
 void GLES2DecoderImpl::DoDidUseTexImageIfNeeded(
     Texture* texture, GLenum textarget) {
   // Image is still in use if texture is attached to a framebuffer.
   if (texture && !texture->IsAttachedToFramebuffer()) {
-    gfx::GLImage* image = texture->GetLevelImage(textarget, 0);
+    Texture::ImageState image_state;
+    gfx::GLImage* image = texture->GetLevelImage(textarget, 0, &image_state);
     if (image) {
       ScopedGLErrorSuppressor suppressor(
           "GLES2DecoderImpl::DoDidUseTexImageIfNeeded",
           GetErrorState());
       glBindTexture(textarget, texture->service_id());
-      image->DidUseTexImage();
+      DoDidUseTexImage(image, image_state);
       RestoreCurrentTextureBindings(&state_, textarget);
     }
   }
 }
 
 bool GLES2DecoderImpl::PrepareTexturesForRender() {
   DCHECK(state_.current_program.get());
   if (!texture_manager()->HaveUnrenderableTextures() &&
       !texture_manager()->HaveImages()) {
     return true;
@@ skipping 27 matching lines @@
                 std::string("texture bound to texture unit ") +
                 base::UintToString(texture_unit_index) +
                 " is not renderable. It maybe non-power-of-2 and have"
                 " incompatible texture filtering.");
           }
           continue;
         }
 
         if (textarget != GL_TEXTURE_CUBE_MAP) {
           Texture* texture = texture_ref->texture();
-          gfx::GLImage* image = texture->GetLevelImage(textarget, 0);
+          Texture::ImageState image_state;
+          gfx::GLImage* image =
+              texture->GetLevelImage(textarget, 0, &image_state);
           if (image && !texture->IsAttachedToFramebuffer()) {
             ScopedGLErrorSuppressor suppressor(
                 "GLES2DecoderImpl::PrepareTexturesForRender", GetErrorState());
             textures_set = true;
             glActiveTexture(GL_TEXTURE0 + texture_unit_index);
-            image->WillUseTexImage();
+            Texture::ImageState new_image_state =
+                DoWillUseTexImage(textarget, image, image_state);
+            texture->SetLevelImage(textarget, 0, image, new_image_state);
             continue;
           }
         }
       }
       // else: should this be an error?
     }
   }
   return !textures_set;
 }
 
@@ skipping 17 matching lines @@
           texture_ref = texture_unit.bind_target == GL_TEXTURE_2D
                             ? texture_unit.bound_texture_2d.get()
                             : texture_unit.bound_texture_cube_map.get();
           glBindTexture(texture_unit.bind_target,
                         texture_ref ? texture_ref->service_id() : 0);
           continue;
         }
 
         if (texture_unit.bind_target != GL_TEXTURE_CUBE_MAP) {
           Texture* texture = texture_ref->texture();
+          Texture::ImageState image_state;
           gfx::GLImage* image =
-              texture->GetLevelImage(texture_unit.bind_target, 0);
+              texture->GetLevelImage(texture_unit.bind_target, 0, &image_state);
           if (image && !texture->IsAttachedToFramebuffer()) {
             ScopedGLErrorSuppressor suppressor(
                 "GLES2DecoderImpl::RestoreStateForTextures", GetErrorState());
             glActiveTexture(GL_TEXTURE0 + texture_unit_index);
-            image->DidUseTexImage();
+            DoDidUseTexImage(image, image_state);
             continue;
           }
         }
       }
     }
   }
   // Set the active texture back to whatever the user had it as.
   glActiveTexture(GL_TEXTURE0 + state_.active_texture_unit);
 }
 
@@ skipping 1706 matching lines @@
     const void* cmd_data) {
   const gles2::cmds::ScheduleOverlayPlaneCHROMIUM& c =
       *static_cast<const gles2::cmds::ScheduleOverlayPlaneCHROMIUM*>(cmd_data);
   TextureRef* ref = texture_manager()->GetTexture(c.overlay_texture_id);
   if (!ref) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE,
                        "glScheduleOverlayPlaneCHROMIUM",
                        "unknown texture");
     return error::kNoError;
   }
+  Texture::ImageState image_state;
   gfx::GLImage* image =
-      ref->texture()->GetLevelImage(ref->texture()->target(), 0);
-  if (!image) {
+      ref->texture()->GetLevelImage(ref->texture()->target(), 0, &image_state);
+  if (!image || image_state != Texture::BOUND) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE,
                        "glScheduleOverlayPlaneCHROMIUM",
                        "unsupported texture format");
     return error::kNoError;
   }
   gfx::OverlayTransform transform = GetGFXOverlayTransform(c.plane_transform);
   if (transform == gfx::OVERLAY_TRANSFORM_INVALID) {
     LOCAL_SET_GL_ERROR(GL_INVALID_ENUM,
                        "glScheduleOverlayPlaneCHROMIUM",
                        "invalid transform enum");
@@ skipping 3595 matching lines @@
     GLboolean unpack_unmultiply_alpha) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::DoCopyTextureCHROMIUM");
 
   TextureRef* source_texture_ref = GetTexture(source_id);
   TextureRef* dest_texture_ref = GetTexture(dest_id);
   Texture* source_texture = source_texture_ref->texture();
   Texture* dest_texture = dest_texture_ref->texture();
   int source_width = 0;
   int source_height = 0;
   gfx::GLImage* image =
-      source_texture->GetLevelImage(source_texture->target(), 0);
+      source_texture->GetLevelImage(source_texture->target(), 0, nullptr);
   if (image) {
     gfx::Size size = image->GetSize();
     source_width = size.width();
     source_height = size.height();
     if (source_width <= 0 || source_height <= 0) {
       LOCAL_SET_GL_ERROR(
           GL_INVALID_VALUE,
           "glCopyTextureChromium", "invalid image size");
       return;
     }
@@ skipping 83 matching lines @@
         dest_texture_ref, GL_TEXTURE_2D, 0, internal_format, source_width,
         source_height, 1, 0, internal_format, dest_type,
         gfx::Rect(source_width, source_height));
   } else {
     texture_manager()->SetLevelCleared(dest_texture_ref, GL_TEXTURE_2D, 0,
                                        true);
   }
 
   ScopedModifyPixels modify(dest_texture_ref);
 
-  // Try using GLImage::CopyTexSubImage when possible.
+  // Try using GLImage::CopyTexImage when possible.
   bool unpack_premultiply_alpha_change =
       (unpack_premultiply_alpha ^ unpack_unmultiply_alpha) != 0;
   if (image && !unpack_flip_y && !unpack_premultiply_alpha_change) {
     glBindTexture(GL_TEXTURE_2D, dest_texture->service_id());
-    if (image->CopyTexSubImage(GL_TEXTURE_2D, gfx::Point(0, 0),
-                               gfx::Rect(0, 0, source_width, source_height))) {
+    if (image->CopyTexImage(GL_TEXTURE_2D))
       return;
-    }
   }
 
   DoWillUseTexImageIfNeeded(source_texture, source_texture->target());
 
   // GL_TEXTURE_EXTERNAL_OES texture requires apply a transform matrix
   // before presenting.
   if (source_texture->target() == GL_TEXTURE_EXTERNAL_OES) {
     // TODO(hkuang): get the StreamTexture transform matrix in GPU process
     // instead of using kIdentityMatrix crbug.com/226218.
     copy_texture_CHROMIUM_->DoCopyTextureWithTransform(
@@ skipping 31 matching lines @@
     GLboolean unpack_unmultiply_alpha) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::DoCopySubTextureCHROMIUM");
 
   TextureRef* source_texture_ref = GetTexture(source_id);
   TextureRef* dest_texture_ref = GetTexture(dest_id);
   Texture* source_texture = source_texture_ref->texture();
   Texture* dest_texture = dest_texture_ref->texture();
   int source_width = 0;
   int source_height = 0;
   gfx::GLImage* image =
-      source_texture->GetLevelImage(source_texture->target(), 0);
+      source_texture->GetLevelImage(source_texture->target(), 0, nullptr);
   if (image) {
     gfx::Size size = image->GetSize();
     source_width = size.width();
     source_height = size.height();
     if (source_width <= 0 || source_height <= 0) {
       LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glCopySubTextureCHROMIUM",
                          "invalid image size");
       return;
     }
   } else {
@@ skipping 129 matching lines @@
                                                        GLuint dest_id) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::DoCompressedCopyTextureCHROMIUM");
 
   TextureRef* source_texture_ref = GetTexture(source_id);
   TextureRef* dest_texture_ref = GetTexture(dest_id);
   Texture* source_texture = source_texture_ref->texture();
   Texture* dest_texture = dest_texture_ref->texture();
   int source_width = 0;
   int source_height = 0;
   gfx::GLImage* image =
-      source_texture->GetLevelImage(source_texture->target(), 0);
+      source_texture->GetLevelImage(source_texture->target(), 0, nullptr);
   if (image) {
     gfx::Size size = image->GetSize();
     source_width = size.width();
     source_height = size.height();
     if (source_width <= 0 || source_height <= 0) {
       LOCAL_SET_GL_ERROR(
           GL_INVALID_VALUE,
           "glCompressedCopyTextureCHROMIUM", "invalid image size");
       return;
     }
@@ skipping 97 matching lines @@
 
       texture_manager()->SetLevelInfo(
           dest_texture_ref, GL_TEXTURE_2D, 0, source_internal_format,
           source_width, source_height, 1, 0, source_internal_format,
           source_type, gfx::Rect(source_width, source_height));
     } else {
       texture_manager()->SetLevelCleared(dest_texture_ref, GL_TEXTURE_2D, 0,
                                          true);
     }
 
-    if (image->CopyTexSubImage(GL_TEXTURE_2D, gfx::Point(0, 0),
-                               gfx::Rect(0, 0, source_width, source_height))) {
+    if (image->CopyTexImage(GL_TEXTURE_2D))
       return;
-    }
   }
 
   TRACE_EVENT0(
       "gpu",
       "GLES2DecoderImpl::DoCompressedCopyTextureCHROMIUM, fallback");
 
   DoWillUseTexImageIfNeeded(source_texture, source_texture->target());
 
   // As a fallback, copy into a non-compressed GL_RGBA texture.
   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("glCompressedCopyTextureCHROMIUM");
@@ skipping 40 matching lines @@
                                                           GLsizei height) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::DoCompressedCopySubTextureCHROMIUM");
 
   TextureRef* source_texture_ref = GetTexture(source_id);
   TextureRef* dest_texture_ref = GetTexture(dest_id);
   Texture* source_texture = source_texture_ref->texture();
   Texture* dest_texture = dest_texture_ref->texture();
   int source_width = 0;
   int source_height = 0;
   gfx::GLImage* image =
-      source_texture->GetLevelImage(source_texture->target(), 0);
+      source_texture->GetLevelImage(source_texture->target(), 0, nullptr);
   if (image) {
     gfx::Size size = image->GetSize();
     source_width = size.width();
     source_height = size.height();
     if (source_width <= 0 || source_height <= 0) {
       LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glCompressedCopySubTextureCHROMIUM",
                          "invalid image size");
       return;
     }
   } else {
@@ skipping 110 matching lines @@
     texture_manager()->SetLevelCleared(dest_texture_ref, GL_TEXTURE_2D, 0,
                                        true);
   }
 
   ScopedTextureBinder binder(
       &state_, dest_texture->service_id(), GL_TEXTURE_2D);
 
   ScopedModifyPixels modify(dest_texture_ref);
 
   // Try using GLImage::CopyTexSubImage when possible.
-  if (image) {
-    if (image->CopyTexSubImage(GL_TEXTURE_2D, gfx::Point(xoffset, yoffset),
-                               gfx::Rect(x, y, width, height))) {
-      return;
-    }
+  if (image &&
+      image->CopyTexSubImage(GL_TEXTURE_2D, gfx::Point(xoffset, yoffset),
+                             gfx::Rect(x, y, width, height))) {
+    return;
   }
 
   TRACE_EVENT0(
       "gpu",
       "GLES2DecoderImpl::DoCompressedCopySubTextureCHROMIUM, fallback");
 
   DoWillUseTexImageIfNeeded(source_texture, source_texture->target());
 
   // As a fallback, copy into a non-compressed GL_RGBA texture.
   if (dest_internal_format != GL_RGBA) {
@@ skipping 453 matching lines @@
   // accidents.
   TextureRef* texture_ref =
       texture_manager()->GetTextureInfoForTargetUnlessDefault(&state_, target);
   if (!texture_ref) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         "glBindTexImage2DCHROMIUM", "no texture bound");
     return;
   }
 
-  gfx::GLImage* gl_image = image_manager()->LookupImage(image_id);
-  if (!gl_image) {
+  gfx::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;
   }
 
+  Texture::ImageState image_state = Texture::UNBOUND;
+
   {
     ScopedGLErrorSuppressor suppressor(
         "GLES2DecoderImpl::DoBindTexImage2DCHROMIUM", GetErrorState());
-    if (!gl_image->BindTexImage(target)) {
-      LOCAL_SET_GL_ERROR(
-          GL_INVALID_OPERATION,
-          "glBindTexImage2DCHROMIUM", "fail to bind image with the given ID");
-      return;
-    }
+
+    // Note: We fallback to a lazy GLImage::CopyTexImage() call in
+    // DoWillUseTexImage() when BindTexImage() fails.
+    if (image->BindTexImage(target))
+      image_state = Texture::BOUND;
   }
 
-  gfx::Size size = gl_image->GetSize();
+  // GL_TEXTURE_EXTERNAL_OES is not a supported CopyTexImage() target.
+  if (target == GL_TEXTURE_EXTERNAL_OES && image_state == Texture::UNBOUND) {
+    LOCAL_SET_GL_ERROR(GL_INVALID_ENUM, "glBindTexImage2DCHROMIUM",
+                       "invalid target");
+    return;
+  }
+
+  gfx::Size size = image->GetSize();
   texture_manager()->SetLevelInfo(
-      texture_ref, target, 0, gl_image->GetInternalFormat(), size.width(),
-      size.height(), 1, 0, gl_image->GetInternalFormat(), GL_UNSIGNED_BYTE,
+      texture_ref, target, 0, image->GetInternalFormat(), size.width(),
+      size.height(), 1, 0, image->GetInternalFormat(), GL_UNSIGNED_BYTE,
       gfx::Rect(size));
-  texture_manager()->SetLevelImage(texture_ref, target, 0, gl_image);
+  texture_manager()->SetLevelImage(texture_ref, target, 0, image, image_state);
 }
 
 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");
     return;
   }
 
-  gfx::GLImage* gl_image = image_manager()->LookupImage(image_id);
-  if (!gl_image) {
+  gfx::GLImage* image = image_manager()->LookupImage(image_id);
+  if (!image) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         "glReleaseTexImage2DCHROMIUM", "no image found with the given ID");
     return;
   }
 
+  Texture::ImageState image_state;
+
   // Do nothing when image is not currently bound.
-  if (texture_ref->texture()->GetLevelImage(target, 0) != gl_image)
+  if (texture_ref->texture()->GetLevelImage(target, 0, &image_state) != image)
     return;
 
   {
     ScopedGLErrorSuppressor suppressor(
         "GLES2DecoderImpl::DoReleaseTexImage2DCHROMIUM", GetErrorState());
-    gl_image->ReleaseTexImage(target);
+
+    if (image_state == Texture::BOUND)
+      image->ReleaseTexImage(target);
+
+    if (image_state == Texture::COPIED) {
+      // Effectively frees the texture storage without deleting the texture id.
+      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA,
+                   GL_UNSIGNED_BYTE, nullptr);
+    }
   }
 
   texture_manager()->SetLevelInfo(
-      texture_ref, target, 0, gl_image->GetInternalFormat(), 0, 0, 1, 0,
-      gl_image->GetInternalFormat(), GL_UNSIGNED_BYTE, gfx::Rect());
+      texture_ref, target, 0, image->GetInternalFormat(), 0, 0, 1, 0,
+      image->GetInternalFormat(), GL_UNSIGNED_BYTE, gfx::Rect());
 }
 
 error::Error GLES2DecoderImpl::HandleTraceBeginCHROMIUM(
     uint32 immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::TraceBeginCHROMIUM& c =
       *static_cast<const gles2::cmds::TraceBeginCHROMIUM*>(cmd_data);
   Bucket* category_bucket = GetBucket(c.category_bucket_id);
   Bucket* name_bucket = GetBucket(c.name_bucket_id);
   if (!category_bucket || category_bucket->size() == 0 ||
@@ skipping 794 matching lines @@
   return error::kNoError;
 }
 
 // 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 "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu