Force cube map texture complete on Linux AMD

gpu/command_buffer/service/texture_manager.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/texture_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 377 matching lines @@
       glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buffer_->service_id());
     }
   }
 
  private:
     Buffer* buffer_;
 };
 
 }  // namespace anonymous
 
+DecoderTextureState::DecoderTextureState(
+    const GpuDriverBugWorkarounds& workarounds)
+    : tex_image_failed(false),
+      texture_upload_count(0),
+      texsubimage_faster_than_teximage(
+          workarounds.texsubimage_faster_than_teximage),
+      force_cube_map_positive_x_allocation(
+          workarounds.force_cube_map_positive_x_allocation),
+      force_cube_complete(workarounds.force_cube_complete),
+      force_int_or_srgb_cube_texture_complete(
+          workarounds.force_int_or_srgb_cube_texture_complete),
+      unpack_alignment_workaround_with_unpack_buffer(
+          workarounds.unpack_alignment_workaround_with_unpack_buffer),
+      unpack_overlapping_rows_separately_unpack_buffer(
+          workarounds.unpack_overlapping_rows_separately_unpack_buffer),
+      unpack_image_height_workaround_with_unpack_buffer(
+          workarounds.unpack_image_height_workaround_with_unpack_buffer) {}
+
 TextureManager::DestructionObserver::DestructionObserver() {}
 
 TextureManager::DestructionObserver::~DestructionObserver() {}
 
 TextureManager::~TextureManager() {
   for (unsigned int i = 0; i < destruction_observers_.size(); i++)
     destruction_observers_[i]->OnTextureManagerDestroying(this);
 
   DCHECK(textures_.empty());
 
@@ skipping 2112 matching lines @@
     ContextState* state,
     DecoderFramebufferState* framebuffer_state,
     TextureRef* texture_ref,
     const char* function_name,
     const DoTexImageArguments& args) {
   // This workaround code does not work with an unpack buffer bound.
   ScopedResetPixelUnpackBuffer scoped_reset_pbo(state);
 
   std::vector<GLenum> undefined_faces;
   Texture* texture = texture_ref->texture();
-  if (texture_state->force_cube_complete) {
+  if (texture_state->force_cube_complete ||
+      texture_state->force_int_or_srgb_cube_texture_complete) {
     int width = 0;
     int height = 0;
     for (unsigned i = 0; i < 6; i++) {
       GLenum target = static_cast<GLenum>(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i);
       bool defined = texture->GetLevelSize(
           target, args.level, &width, &height, nullptr);
+      defined = defined && width == args.width && height == args.height;

[Zhenyao Mo, 2017/04/19 17:11:53]

I understand the issue, but still, I think modifying user defined texture
silently internally is worse than having a driver bug.  I'd rather mark these
tests as fail.

[qiankun, 2017/04/20 01:35:53]

Sounds good. Removed it.

       if (!defined && target != args.target)
         undefined_faces.push_back(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i);
     }
   } else {
     DCHECK(args.target != GL_TEXTURE_CUBE_MAP_POSITIVE_X);
     int width = 0;
     int height = 0;
     if (!texture->GetLevelSize(GL_TEXTURE_CUBE_MAP_POSITIVE_X, args.level,
                                &width, &height, nullptr)) {
       undefined_faces.push_back(GL_TEXTURE_CUBE_MAP_POSITIVE_X);
@@ skipping 31 matching lines @@
   Buffer* buffer = state->bound_pixel_unpack_buffer.get();
 
   // ValidateTexImage is passed already.
   Texture* texture = texture_ref->texture();
   bool need_cube_map_workaround =
       !feature_info_->IsWebGL2OrES3Context() &&
       texture->target() == GL_TEXTURE_CUBE_MAP &&
       (texture_state->force_cube_complete ||
        (texture_state->force_cube_map_positive_x_allocation &&
         args.target != GL_TEXTURE_CUBE_MAP_POSITIVE_X));
+  // Force integer or srgb cube map texture complete, see crbug.com/712117.
+  need_cube_map_workaround =
+      need_cube_map_workaround ||
+      (feature_info_->IsWebGL2OrES3Context() &&

[Zhenyao Mo, 2017/04/19 17:11:53]

This isn't correct.  You can also get sRGB formats on ES2/WebGL1 through
extension.  Let's just remove this condition.

[qiankun, 2017/04/20 01:35:53]

What I meant is other platforms doesn't have such bug about integer and srgb
issue like Linux AMD. They require force_cube_complete due to other reasons. If
we reuse force_cube_complete workaround, other platforms which don't need to
apply the workaround for integer and srgb cube texture will apply the
workaround.

[qiankun, 2017/04/20 02:12:31]

Never mind. Please ignore my last comments. I removed the condition.

+       texture->target() == GL_TEXTURE_CUBE_MAP &&
+       texture_state->force_int_or_srgb_cube_texture_complete &&
+       (GLES2Util::IsIntegerFormat(args.internal_format) ||
+        GLES2Util::GetColorEncodingFromInternalFormat(args.internal_format) ==
+            GL_SRGB));
+
   if (need_cube_map_workaround && !buffer) {
     DoCubeMapWorkaround(texture_state, state, framebuffer_state,
                         texture_ref, function_name, args);
   }
 
   if (texture_state->unpack_overlapping_rows_separately_unpack_buffer &&
       buffer) {
     ContextState::Dimension dimension =
         (args.command_type == DoTexImageArguments::kTexImage3D)
             ? ContextState::k3D
@@ skipping 1058 matching lines @@
 uint32_t TextureManager::GetServiceIdGeneration() const {
   return current_service_id_generation_;
 }
 
 void TextureManager::IncrementServiceIdGeneration() {
   current_service_id_generation_++;
 }
 
 }  // namespace gles2
 }  // namespace gpu