Add a workaround for copyTexImage2D as it is sometimes broken on OSX.

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 1887 matching lines @@
   void DoBindFragmentInputLocationCHROMIUM(GLuint program_id,
                                            GLint location,
                                            const std::string& name);
 
   // If |texture_manager_version_| doesn't match the current version, then this
   // will rebind all external textures to match their current service_id.
   void RestoreAllExternalTextureBindingsIfNeeded() override;
 
   const SamplerState& GetSamplerStateForTextureUnit(GLenum target, GLuint unit);
 
+  // copyTexImage2D doesn't work on OSX under very specific conditions.
+  // Returns whether those conditions have been met. If this method returns
+  // true, |source_texture_service_id| and |source_texture_target| are also
+  // populated, since they are needed to implement the workaround.
+  bool NeedsCopyTextureImageWorkaround(GLenum internal_format,
+                                       int32_t channels_exist,
+                                       GLuint* source_texture_service_id,
+                                       GLenum* source_texture_target);
+
   // Generate a member function prototype for each command in an automated and
   // typesafe way.
 #define GLES2_CMD_OP(name) \
   Error Handle##name(uint32_t immediate_data_size, const void* data);
 
   GLES2_COMMAND_LIST(GLES2_CMD_OP)
 
   #undef GLES2_CMD_OP
 
   // The GL context this decoder renders to on behalf of the client.
@@ skipping 9719 matching lines @@
     if (copyHeight > 0 && copyWidth > 0) {
       GLint dx = copyX - x;
       GLint dy = copyY - y;
       GLint destX = dx;
       GLint destY = dy;
       glCopyTexSubImage2D(target, level,
                           destX, destY, copyX, copyY,
                           copyWidth, copyHeight);
     }
   } else {
-    glCopyTexImage2D(target, level, texture_manager()->AdjustTexInternalFormat(
-                                        internal_format),
-                     copyX, copyY, copyWidth, copyHeight, border);
+    GLenum final_internal_format =
+        texture_manager()->AdjustTexInternalFormat(internal_format);
+
+    // The service id and target of the texture attached to READ_FRAMEBUFFER.
+    GLuint source_texture_service_id = 0;
+    GLenum source_texture_target = 0;
+    bool use_workaround = NeedsCopyTextureImageWorkaround(
+        final_internal_format, channels_exist, &source_texture_service_id,
+        &source_texture_target);
+    if (use_workaround) {
+      GLenum dest_texture_target = target;
+      GLenum framebuffer_target = features().chromium_framebuffer_multisample
+                                      ? GL_READ_FRAMEBUFFER_EXT
+                                      : GL_FRAMEBUFFER;
+
+      GLenum temp_internal_format = 0;
+      if (channels_exist == GLES2Util::kRGBA) {
+        temp_internal_format = GL_RGBA;
+      } else if (channels_exist == GLES2Util::kRGB) {
+        temp_internal_format = GL_RGB;
+      } else {
+        NOTREACHED();
+      }
+
+      GLuint temp_texture;
+      {
+        // Copy from the read framebuffer into |temp_texture|.
+        glGenTextures(1, &temp_texture);
+        ScopedTextureBinder binder(&state_, temp_texture,
+                                   source_texture_target);
+        glCopyTexImage2D(source_texture_target, 0, temp_internal_format, copyX,
+                         copyY, copyWidth, copyHeight, border);
+
+        // Attach the temp texture to the read framebuffer.
+        glFramebufferTexture2DEXT(framebuffer_target, GL_COLOR_ATTACHMENT0,
+                                  source_texture_target, temp_texture, 0);
+      }
+
+      // Copy to the final texture.
+      DCHECK_EQ(static_cast<GLuint>(GL_TEXTURE_2D), dest_texture_target);
+      glCopyTexImage2D(dest_texture_target, level, final_internal_format, 0, 0,
+                       copyWidth, copyHeight, 0);
+
+      // Rebind source texture.
+      glFramebufferTexture2DEXT(framebuffer_target, GL_COLOR_ATTACHMENT0,
+                                source_texture_target,
+                                source_texture_service_id, 0);
+
+      glDeleteTextures(1, &temp_texture);
+    } else {
+      glCopyTexImage2D(target, level, final_internal_format, copyX, copyY,
+                       copyWidth, copyHeight, border);
+    }
   }
   GLenum error = LOCAL_PEEK_GL_ERROR("glCopyTexImage2D");
   if (error == GL_NO_ERROR) {
     texture_manager()->SetLevelInfo(texture_ref, target, level, internal_format,
                                     width, height, 1, border, format,
                                     type, gfx::Rect(width, height));
     texture->ApplyFormatWorkarounds(feature_info_.get());
   }
 
   // This may be a slow command.  Exit command processing to allow for
@@ skipping 4311 matching lines @@
       return sampler->sampler_state();
   }
   TextureUnit& texture_unit = state_.texture_units[unit];
   TextureRef* texture_ref = texture_unit.GetInfoForSamplerType(target).get();
   if (texture_ref)
     return texture_ref->texture()->sampler_state();
 
   return default_sampler_state_;
 }
 
+bool GLES2DecoderImpl::NeedsCopyTextureImageWorkaround(
+    GLenum internal_format,
+    int32_t channels_exist,
+    GLuint* source_texture_service_id,
+    GLenum* source_texture_target) {
+  // On some OSX devices, copyTexImage2D will fail if all of these conditions
+  // are met:
+  //   1. The internal format of the new texture is not GL_RGB or GL_RGBA.
+  //   2. The image of the read FBO is backed by an IOSurface.
+  // See https://crbug.com/581777#c4 for more details.
+  if (!workarounds().use_intermediary_for_copy_texture_image)
+    return false;
+
+  if (internal_format == GL_RGB || internal_format == GL_RGBA)
+    return false;
+
+  GLenum framebuffer_target = features().chromium_framebuffer_multisample
+                                  ? GL_READ_FRAMEBUFFER_EXT
+                                  : GL_FRAMEBUFFER;
+  Framebuffer* framebuffer =
+      GetFramebufferInfoForTarget(framebuffer_target);
+  if (!framebuffer)
+    return false;
+
+  const Framebuffer::Attachment* attachment =
+      framebuffer->GetReadBufferAttachment();
+  if (!attachment)
+    return false;
+
+  if (!attachment->IsTextureAttachment())
+    return false;
+
+  TextureRef* texture =
+      texture_manager()->GetTexture(attachment->object_name());
+  if (!texture->texture()->HasImages())
+    return false;
+
+  // The workaround only works if the source texture consists of the channels
+  // kRGB or kRGBA.
+  if (channels_exist != GLES2Util::kRGBA && channels_exist != GLES2Util::kRGB)
+    return false;
+
+  *source_texture_target = texture->texture()->target();
+  *source_texture_service_id = texture->service_id();
+  return true;
+}
+
 error::Error GLES2DecoderImpl::HandleBindFragmentInputLocationCHROMIUMBucket(
     uint32_t immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::BindFragmentInputLocationCHROMIUMBucket& c =
       *static_cast<const gles2::cmds::BindFragmentInputLocationCHROMIUMBucket*>(
           cmd_data);
   if (!features().chromium_path_rendering) {
     return error::kUnknownCommand;
   }
 
@@ skipping 143 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