Allow one-copy task tile worker pool to use compressed textures.

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 1764 matching lines @@
     Texture* texture);
   bool ValidateCopyTextureCHROMIUM(const char* function_name,
                                    GLenum target,
                                    TextureRef* source_texture_ref,
                                    TextureRef* dest_texture_ref,
                                    GLenum dest_internal_format);
   bool ValidateCompressedCopyTextureCHROMIUM(const char* function_name,
                                              GLenum target,
                                              TextureRef* source_texture_ref,
                                              TextureRef* dest_texture_ref);
+  bool ValidateCompressedCopySubTextureDimensions(

[reveman, 2015/12/02 18:28:50]

btw, do we still need this? we're not using copysub for compressed textures yet,
right?

[christiank, 2015/12/03 12:58:00]

No we don't need it at the moment. I'll revert the changes for now, they can be
re-added later if needed.

+    const char* function_name,
+    GLenum target, GLint xoffset, GLint yoffset,
+    GLsizei width, GLsizei height, GLenum format,
+    Texture* texture);
 
   void RenderWarning(const char* filename, int line, const std::string& msg);
   void PerformanceWarning(
       const char* filename, int line, const std::string& msg);
 
   const FeatureInfo::FeatureFlags& features() const {
     return feature_info_->feature_flags();
   }
 
   const FeatureInfo::Workarounds& workarounds() const {
@@ skipping 10930 matching lines @@
 
   if (!valid_format) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, function_name,
                        "invalid internal format");
     return false;
   }
 
   return true;
 }
 
+bool GLES2DecoderImpl::ValidateCompressedCopySubTextureDimensions(
+    const char* function_name,
+    GLenum target, GLint xoffset, GLint yoffset,
+    GLsizei width, GLsizei height, GLenum format,
+    Texture* texture) {
+  if (xoffset < 0 || yoffset < 0) {
+    LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, function_name, "x/y offset < 0");
+    return false;
+  }
+
+  switch (format) {
+    case GL_ATC_RGB_AMD:
+    case GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD:
+    case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
+    case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
+    case GL_ETC1_RGB8_OES: {
+      const int kBlockWidth = 4;
+      const int kBlockHeight = 4;
+      if ((xoffset % kBlockWidth) || (yoffset % kBlockHeight)) {
+        LOCAL_SET_GL_ERROR(
+            GL_INVALID_OPERATION, function_name,
+            "xoffset or yoffset not multiple of 4");
+        return false;
+      }
+      GLsizei tex_width = 0;
+      GLsizei tex_height = 0;
+      if (!texture->GetLevelSize(target, 0, &tex_width, &tex_height, nullptr) ||
+          width - xoffset > tex_width ||
+          height - yoffset > tex_height) {
+        LOCAL_SET_GL_ERROR(
+            GL_INVALID_OPERATION, function_name, "dimensions out of range");
+        return false;
+      }
+      return ValidateCompressedTexDimensions(
+          function_name, target, 0, width, height, 1, format);
+    }
+    default:
+      return false;
+  }
+}
+
 void GLES2DecoderImpl::DoCopyTextureCHROMIUM(
     GLenum target,
     GLuint source_id,
     GLuint dest_id,
     GLenum internal_format,
     GLenum dest_type,
     GLboolean unpack_flip_y,
     GLboolean unpack_premultiply_alpha,
     GLboolean unpack_unmultiply_alpha) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::DoCopyTextureCHROMIUM");
@@ skipping 539 matching lines @@
                        "destination texture bad dimensions.");
     return;
   }
 
   if (!ValidateCompressedCopyTextureCHROMIUM(
           "glCompressedCopySubTextureCHROMIUM", target, source_texture_ref,
            dest_texture_ref)) {
     return;
   }
 
-  if (!ValidateCompressedTexSubDimensions("glCompressedCopySubTextureCHROMIUM",
-                                          source_texture->target(), 0, x, y, 0,
-                                          width, height, 1,
-                                          source_internal_format,
-                                          source_texture) ||
-      !ValidateCompressedTexSubDimensions("glCompressedCopySubTextureCHROMIUM",
-                                          dest_texture->target(), 0,
-                                          xoffset, yoffset, 0, width, height, 1,
-                                          dest_internal_format,
-                                          dest_texture)) {
+  if (!ValidateCompressedCopySubTextureDimensions(
+          "glCompressedCopySubTextureCHROMIUM",
+          source_texture->target(), x, y,
+          width, height,
+          source_internal_format,
+          source_texture) ||
+      !ValidateCompressedCopySubTextureDimensions(
+          "glCompressedCopySubTextureCHROMIUM",
+          dest_texture->target(),
+          xoffset, yoffset, width, height,
+          dest_internal_format,
+          dest_texture)) {
     return;
   }
 
   // Defer initializing the CopyTextureCHROMIUMResourceManager until it is
   // needed because it takes 10s of milliseconds to initialize.
   if (!copy_texture_CHROMIUM_.get()) {
     LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("glCompressedCopySubTextureCHROMIUM");
     copy_texture_CHROMIUM_.reset(new CopyTextureCHROMIUMResourceManager());
     copy_texture_CHROMIUM_->Initialize(this);
     RestoreCurrentFramebufferBindings();
@@ skipping 2008 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