Revert of Select correct copy method for DoCopySubTexture

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 1277 matching lines @@
                     int height,
                     int depth) override;
 
   // Restore all GL state that affects clearing.
   void RestoreClearState();
 
   // Remembers the state of some capabilities.
   // Returns: true if glEnable/glDisable should actually be called.
   bool SetCapabilityState(GLenum cap, bool enabled);
 
+  // Infer color encoding from internalformat
+  static GLint GetColorEncodingFromInternalFormat(GLenum internalformat);
+
   // Check that the currently bound read framebuffer's color image
   // isn't the target texture of the glCopyTex{Sub}Image{2D|3D}.
   bool FormsTextureCopyingFeedbackLoop(
       TextureRef* texture,
       GLint level,
       GLint layer);
 
   // Check if a framebuffer meets our requirements.
   // Generates |gl_error| if the framebuffer is incomplete.
   bool CheckFramebufferValid(
@@ skipping 3099 matching lines @@
   Framebuffer* draw_framebuffer = GetBoundDrawFramebuffer();
   bool valid = CheckFramebufferValid(
       draw_framebuffer, GetDrawFramebufferTarget(), gl_error, func_name);
 
   Framebuffer* read_framebuffer = GetBoundReadFramebuffer();
   valid = valid && CheckFramebufferValid(
       read_framebuffer, GetReadFramebufferTarget(), gl_error, func_name);
   return valid;
 }
 
+GLint GLES2DecoderImpl::GetColorEncodingFromInternalFormat(
+    GLenum internalformat) {
+  switch (internalformat) {
+    case GL_SRGB_EXT:
+    case GL_SRGB_ALPHA_EXT:
+    case GL_SRGB8:
+    case GL_SRGB8_ALPHA8:
+      return GL_SRGB;
+    default:
+      return GL_LINEAR;
+  }
+}
+
 bool GLES2DecoderImpl::FormsTextureCopyingFeedbackLoop(
     TextureRef* texture, GLint level, GLint layer) {
   Framebuffer* framebuffer = GetBoundReadFramebuffer();
   if (!framebuffer)
     return false;
   const Framebuffer::Attachment* attachment =
       framebuffer->GetReadBufferAttachment();
   if (!attachment)
     return false;
   return attachment->FormsFeedbackLoop(texture, level, layer);
@@ skipping 1780 matching lines @@
         tex->GetLevelType(target, tex->base_level(), &type, &internal_format)) {
       format = TextureManager::ExtractFormatFromStorageFormat(internal_format);
       glTexImage2D(target, 0, internal_format, 1, 1, 0, format, type, nullptr);
       texture_zero_level_set = true;
     }
   }
 
   bool enable_srgb = 0;
   if (target == GL_TEXTURE_2D) {
     tex->GetLevelType(target, tex->base_level(), &type, &internal_format);
-    enable_srgb = GLES2Util::GetColorEncodingFromInternalFormat(
-                      internal_format) == GL_SRGB;
+    enable_srgb =
+        GetColorEncodingFromInternalFormat(internal_format) == GL_SRGB;
   }
   if (enable_srgb && feature_info_->feature_flags().desktop_srgb_support) {
     state_.EnableDisableFramebufferSRGB(enable_srgb);
   }
   if (enable_srgb && workarounds().decode_encode_srgb_for_generatemipmap) {
     if (target == GL_TEXTURE_2D) {
       if (!InitializeSRGBConverter("generateMipmap")) {
         return;
       }
       srgb_converter_->GenerateMipmap(this, tex, target);
@@ skipping 1799 matching lines @@
         }
       } else if (stencil_buffer_draw->IsSameAttachment(stencil_buffer_read)) {
         is_feedback_loop = FeedbackLoopTrue;
       }
     }
   }
 
   GLenum src_internal_format = GetBoundReadFramebufferInternalFormat();
   GLenum src_type = GetBoundReadFramebufferTextureType();
 
-  bool read_buffer_has_srgb = GLES2Util::GetColorEncodingFromInternalFormat(
-                                  src_internal_format) == GL_SRGB;
+  bool read_buffer_has_srgb =
+      GetColorEncodingFromInternalFormat(src_internal_format) == GL_SRGB;
   bool draw_buffers_has_srgb = false;
   if ((mask & GL_COLOR_BUFFER_BIT) != 0) {
     bool is_src_signed_int =
         GLES2Util::IsSignedIntegerFormat(src_internal_format);
     bool is_src_unsigned_int =
         GLES2Util::IsUnsignedIntegerFormat(src_internal_format);
     DCHECK(!is_src_signed_int || !is_src_unsigned_int);
 
     if ((is_src_signed_int || is_src_unsigned_int) && filter == GL_LINEAR) {
       LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, func_name,
@@ skipping 11 matching lines @@
     for (uint32_t ii = 0; ii < group_->max_draw_buffers(); ++ii) {
       GLenum dst_format = GetBoundColorDrawBufferInternalFormat(
           static_cast<GLint>(ii));
       GLenum dst_type = GetBoundColorDrawBufferType(static_cast<GLint>(ii));
       if (dst_format == 0)
         continue;
       draw_buffer_has_image = true;
       if (!src_internal_format) {
         read_framebuffer_miss_image = true;
       }
-      if (GLES2Util::GetColorEncodingFromInternalFormat(dst_format) == GL_SRGB)
+      if (GetColorEncodingFromInternalFormat(dst_format) == GL_SRGB)
         draw_buffers_has_srgb = true;
       if (read_buffer_samples > 0 &&
           (src_sized_format !=
            GLES2Util::ConvertToSizedFormat(dst_format, dst_type))) {
         LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, func_name,
                            "src and dst formats differ for color");
         return;
       }
       bool is_dst_signed_int = GLES2Util::IsSignedIntegerFormat(dst_format);
       bool is_dst_unsigned_int = GLES2Util::IsUnsignedIntegerFormat(dst_format);
@@ skipping 5859 matching lines @@
   }
   // Check we have compatible formats.
   uint32_t channels_exist = GLES2Util::GetChannelsForFormat(read_format);
   uint32_t channels_needed = GLES2Util::GetChannelsForFormat(internal_format);
   if (!channels_needed ||
       (channels_needed & channels_exist) != channels_needed) {
     *output_error_msg = std::string("incompatible format");
     return false;
   }
   if (feature_info_->IsWebGL2OrES3Context()) {
-    GLint color_encoding =
-        GLES2Util::GetColorEncodingFromInternalFormat(read_format);
+    GLint color_encoding = GetColorEncodingFromInternalFormat(read_format);
     bool float_mismatch = feature_info_->ext_color_buffer_float_available() ?
         (GLES2Util::IsIntegerFormat(internal_format) !=
          GLES2Util::IsIntegerFormat(read_format)) :
         GLES2Util::IsFloatFormat(internal_format);
-    if (color_encoding !=
-            GLES2Util::GetColorEncodingFromInternalFormat(internal_format) ||
-        float_mismatch || (GLES2Util::IsSignedIntegerFormat(internal_format) !=
-                           GLES2Util::IsSignedIntegerFormat(read_format)) ||
+    if (color_encoding != GetColorEncodingFromInternalFormat(internal_format) ||
+        float_mismatch ||
+        (GLES2Util::IsSignedIntegerFormat(internal_format) !=
+         GLES2Util::IsSignedIntegerFormat(read_format)) ||
         (GLES2Util::IsUnsignedIntegerFormat(internal_format) !=
          GLES2Util::IsUnsignedIntegerFormat(read_format))) {
       *output_error_msg = std::string("incompatible format");
       return false;
     }
   }
   if ((channels_needed & (GLES2Util::kDepth | GLES2Util::kStencil)) != 0) {
     *output_error_msg =
         std::string("can not be used with depth or stencil textures");
     return false;
@@ skipping 2478 matching lines @@
   // crbug.com/678526. Once the bug is fixed, the limitation for WebGL 2.0 and
   // OpenGL ES 3.0 can be lifted.
   if (((dest_level > 0 || dest_binding_target == GL_TEXTURE_CUBE_MAP) &&
        method == DIRECT_DRAW) ||
       (source_level > 0 && method == DIRECT_COPY)) {
     method = DRAW_AND_COPY;
   }
 
   if (feature_info_->feature_flags().desktop_srgb_support) {
     bool enable_framebuffer_srgb =
-        GLES2Util::GetColorEncodingFromInternalFormat(source_internal_format) ==
-            GL_SRGB ||
-        GLES2Util::GetColorEncodingFromInternalFormat(internal_format) ==
-            GL_SRGB;
+        GetColorEncodingFromInternalFormat(source_internal_format) == GL_SRGB ||
+        GetColorEncodingFromInternalFormat(internal_format) == GL_SRGB;
     state_.EnableDisableFramebufferSRGB(enable_framebuffer_srgb);
   }
 
   int source_width = 0;
   int source_height = 0;
   gl::GLImage* image =
       source_texture->GetLevelImage(source_target, source_level);
   if (image) {
     gfx::Size size = image->GetSize();
     source_width = size.width();
@@ skipping 225 matching lines @@
   }
 
   CopyTextureMethod method = ValidateCopyTextureCHROMIUMInternalFormats(
       kFunctionName, source_texture_ref, source_level, dest_internal_format);
   // INVALID_OPERATION is already generated by
   // ValidateCopyTextureCHROMIUMInternalFormats.
   if (method == NOT_COPYABLE) {
     return;
   }
 
-#if defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY)
-  // glDrawArrays is faster than glCopyTexSubImage2D on IA Mesa driver,
-  // although opposite in Android.
-  // TODO(dshwang): After Mesa fixes this issue, remove this hack.
-  // https://bugs.freedesktop.org/show_bug.cgi?id=98478, crbug.com/535198.
-  if (Texture::ColorRenderable(GetFeatureInfo(), dest_internal_format, false) &&
-      method == DIRECT_COPY) {
-    method = DIRECT_DRAW;
-  }
-#endif
-
   // Draw to a fbo attaching level 0 of an intermediate texture,
   // then copy from the fbo to dest texture level with glCopyTexImage2D.
   // For WebGL 1.0 or OpenGL ES 2.0, DIRECT_DRAW path isn't available for
   // dest_level > 0 due to level > 0 isn't supported by glFramebufferTexture2D
   // in ES2 context. DIRECT_DRAW path isn't available for cube map dest texture
   // either due to it may be cube map incomplete. Go to DRAW_AND_COPY path in
   // these cases.
   // TODO(qiankun.miao@intel.com): for WebGL 2.0 or OpenGL ES 3.0, both
   // DIRECT_DRAW path for dest_level > 0 and DIRECT_COPY path for source_level >
   // 0 are not available due to a framebuffer completeness bug:
   // crbug.com/678526. Once the bug is fixed, the limitation for WebGL 2.0 and
   // OpenGL ES 3.0 can be lifted.
   if (((dest_level > 0 || dest_binding_target == GL_TEXTURE_CUBE_MAP) &&
        method == DIRECT_DRAW) ||
       (source_level > 0 && method == DIRECT_COPY)) {
     method = DRAW_AND_COPY;
   }
 
   if (feature_info_->feature_flags().desktop_srgb_support) {
     bool enable_framebuffer_srgb =
-        GLES2Util::GetColorEncodingFromInternalFormat(source_internal_format) ==
-            GL_SRGB ||
-        GLES2Util::GetColorEncodingFromInternalFormat(dest_internal_format) ==
-            GL_SRGB;
+        GetColorEncodingFromInternalFormat(source_internal_format) == GL_SRGB ||
+        GetColorEncodingFromInternalFormat(dest_internal_format) == GL_SRGB;
     state_.EnableDisableFramebufferSRGB(enable_framebuffer_srgb);
   }
 
   // Clear the source texture if necessary.
   if (!texture_manager()->ClearTextureLevel(this, source_texture_ref,
                                             source_target, source_level)) {
     LOCAL_SET_GL_ERROR(GL_OUT_OF_MEMORY, kFunctionName,
                        "source texture dimensions too big");
     return;
   }
@@ skipping 2493 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