Change GetIntegerv(IMPLEMENTATION_COLOR_READ_FORMAT/TYPE) behavior.

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 1918 matching lines @@
       case GL_INT_SAMPLER_2D_ARRAY:
       case GL_UNSIGNED_INT_SAMPLER_2D_ARRAY:
         return GL_TEXTURE_2D_ARRAY;
       default:
         NOTREACHED();
         return 0;
     }
   }
 
   // Gets the framebuffer info for a particular target.
-  Framebuffer* GetFramebufferInfoForTarget(GLenum target) {
-    Framebuffer* framebuffer = NULL;
+  Framebuffer* GetFramebufferInfoForTarget(GLenum target) const {
+    Framebuffer* framebuffer = nullptr;
     switch (target) {
       case GL_FRAMEBUFFER:
       case GL_DRAW_FRAMEBUFFER_EXT:
         framebuffer = framebuffer_state_.bound_draw_framebuffer.get();
         break;
       case GL_READ_FRAMEBUFFER_EXT:
         framebuffer = framebuffer_state_.bound_read_framebuffer.get();
         break;
       default:
         NOTREACHED();
@@ skipping 177 matching lines @@
   // using GL_RGBA and glColorMask.
   bool ChromiumImageNeedsRGBEmulation();
 
   // The GL_CHROMIUM_schedule_ca_layer extension requires that SwapBuffers and
   // equivalent functions reset shared state.
   void ClearScheduleCALayerState();
 
   // Helper method to call glClear workaround.
   void ClearFramebufferForWorkaround(GLbitfield mask);
 
+  bool SupportsSeparateFramebufferBinds() const {
+    return (feature_info_->feature_flags().chromium_framebuffer_multisample ||
+            feature_info_->IsWebGL2OrES3Context());
+  }
+
+  GLenum GetDrawFramebufferTarget() const {
+    return SupportsSeparateFramebufferBinds() ?
+        GL_DRAW_FRAMEBUFFER : GL_FRAMEBUFFER;
+  }
+
+  GLenum GetReadFramebufferTarget() const {
+    return SupportsSeparateFramebufferBinds() ?
+        GL_READ_FRAMEBUFFER : GL_FRAMEBUFFER;
+  }
+
+  Framebuffer* GetBoundDrawFramebuffer() const {
+    return framebuffer_state_.bound_draw_framebuffer.get();
+  }
+
+  Framebuffer* GetBoundReadFramebuffer() const {
+    GLenum target = GetReadFramebufferTarget();
+    return GetFramebufferInfoForTarget(target);
+  }
+
   bool InitializeCopyTexImageBlitter(const char* function_name);
   bool InitializeCopyTextureCHROMIUM(const char* function_name);
   bool InitializeSRGBConverter(const char* function_name);
   // 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 volatile void* data);
 
   GLES2_COMMAND_LIST(GLES2_CMD_OP)
 
@@ skipping 1853 matching lines @@
       buffer->RemoveMappedRange();
       state_.RemoveBoundBuffer(buffer);
       RemoveBuffer(client_id);
     }
   }
 }
 
 void GLES2DecoderImpl::DeleteFramebuffersHelper(
     GLsizei n,
     const volatile GLuint* client_ids) {
-  bool supports_separate_framebuffer_binds =
-     features().chromium_framebuffer_multisample;
-
   for (GLsizei ii = 0; ii < n; ++ii) {
     GLuint client_id = client_ids[ii];
     Framebuffer* framebuffer = GetFramebuffer(client_id);
     if (framebuffer && !framebuffer->IsDeleted()) {
       if (framebuffer == framebuffer_state_.bound_draw_framebuffer.get()) {
-        GLenum target = supports_separate_framebuffer_binds ?
-            GL_DRAW_FRAMEBUFFER_EXT : GL_FRAMEBUFFER;
+        GLenum target = GetDrawFramebufferTarget();
 
         // Unbind attachments on FBO before deletion.
         if (workarounds().unbind_attachments_on_bound_render_fbo_delete)
           framebuffer->DoUnbindGLAttachmentsForWorkaround(target);
 
         glBindFramebufferEXT(target, GetBackbufferServiceId());
         framebuffer_state_.bound_draw_framebuffer = NULL;
         framebuffer_state_.clear_state_dirty = true;
       }
       if (framebuffer == framebuffer_state_.bound_read_framebuffer.get()) {
         framebuffer_state_.bound_read_framebuffer = NULL;
-        GLenum target = supports_separate_framebuffer_binds ?
-            GL_READ_FRAMEBUFFER_EXT : GL_FRAMEBUFFER;
+        GLenum target = GetReadFramebufferTarget();
         glBindFramebufferEXT(target, GetBackbufferServiceId());
       }
       OnFboChanged();
       RemoveFramebuffer(client_id);
     }
   }
 }
 
 void GLES2DecoderImpl::DeleteRenderbuffersHelper(
     GLsizei n,
@@ skipping 24 matching lines @@
         }
       }
       framebuffer_state_.clear_state_dirty = true;
       RemoveRenderbuffer(client_id);
     }
   }
 }
 
 void GLES2DecoderImpl::DeleteTexturesHelper(GLsizei n,
                                             const volatile GLuint* client_ids) {
-  bool supports_separate_framebuffer_binds =
-     features().chromium_framebuffer_multisample;
+  bool supports_separate_framebuffer_binds = SupportsSeparateFramebufferBinds();
   for (GLsizei ii = 0; ii < n; ++ii) {
     GLuint client_id = client_ids[ii];
     TextureRef* texture_ref = GetTexture(client_id);
     if (texture_ref) {
       Texture* texture = texture_ref->texture();
       if (texture->IsAttachedToFramebuffer()) {
         framebuffer_state_.clear_state_dirty = true;
       }
       // Unbind texture_ref from texture_ref units.
       state_.UnbindTexture(texture_ref);
@@ skipping 121 matching lines @@
   if (framebuffer_id == 0) {
     framebuffer_id = back_buffer_service_id;
   }
 
   glBindFramebufferEXT(target, framebuffer_id);
 }
 
 void GLES2DecoderImpl::RestoreCurrentFramebufferBindings() {
   framebuffer_state_.clear_state_dirty = true;
 
-  if (!features().chromium_framebuffer_multisample) {
+  if (!SupportsSeparateFramebufferBinds()) {
     RebindCurrentFramebuffer(
         GL_FRAMEBUFFER,
         framebuffer_state_.bound_draw_framebuffer.get(),
         GetBackbufferServiceId());
   } else {
     RebindCurrentFramebuffer(
         GL_READ_FRAMEBUFFER_EXT,
         framebuffer_state_.bound_read_framebuffer.get(),
         GetBackbufferServiceId());
     RebindCurrentFramebuffer(
@@ skipping 67 matching lines @@
   if (renderbuffer_manager()->HaveUnclearedRenderbuffers() ||
       texture_manager()->HaveUnclearedMips()) {
     if (!framebuffer->IsCleared()) {
       ClearUnclearedAttachments(target, framebuffer);
     }
   }
   return true;
 }
 
 bool GLES2DecoderImpl::CheckBoundDrawFramebufferValid(const char* func_name) {
-  GLenum target = features().chromium_framebuffer_multisample ?
-      GL_DRAW_FRAMEBUFFER : GL_FRAMEBUFFER;
-  Framebuffer* framebuffer = GetFramebufferInfoForTarget(target);
+  Framebuffer* framebuffer = GetBoundDrawFramebuffer();
   bool valid = CheckFramebufferValid(
-      framebuffer, target, GL_INVALID_FRAMEBUFFER_OPERATION, func_name);
+      framebuffer, GetDrawFramebufferTarget(),
+      GL_INVALID_FRAMEBUFFER_OPERATION, func_name);
   if (!valid)
     return false;
 
-  if (!features().chromium_framebuffer_multisample)
+  if (!SupportsSeparateFramebufferBinds())
     OnUseFramebuffer();
 
   UpdateFramebufferSRGB(framebuffer);
   return true;
 }
 
 void GLES2DecoderImpl::UpdateFramebufferSRGB(Framebuffer* framebuffer) {
   // Manually set the value of FRAMEBUFFER_SRGB based on the state that was set
   // by the client.
   bool needs_enable_disable_framebuffer_srgb = false;
@@ skipping 11 matching lines @@
     needs_enable_disable_framebuffer_srgb = true;
     // Assume that the default fbo does not have an sRGB image.
     enable_framebuffer_srgb &= framebuffer && framebuffer->HasSRGBAttachments();
   }
   if (needs_enable_disable_framebuffer_srgb)
     state_.EnableDisableFramebufferSRGB(enable_framebuffer_srgb);
 }
 
 bool GLES2DecoderImpl::CheckBoundReadFramebufferValid(
     const char* func_name, GLenum gl_error) {
-  GLenum target = features().chromium_framebuffer_multisample ?
-      GL_READ_FRAMEBUFFER : GL_FRAMEBUFFER;
-  Framebuffer* framebuffer = GetFramebufferInfoForTarget(target);
+  Framebuffer* framebuffer = GetBoundReadFramebuffer();
   bool valid = CheckFramebufferValid(
-      framebuffer, target, gl_error, func_name);
+      framebuffer, GetReadFramebufferTarget(), gl_error, func_name);
   return valid;
 }
 
 bool GLES2DecoderImpl::CheckBoundFramebufferValid(const char* func_name) {
-  GLenum target = features().chromium_framebuffer_multisample ?
-      GL_DRAW_FRAMEBUFFER : GL_FRAMEBUFFER;
-  Framebuffer* draw_framebuffer = GetFramebufferInfoForTarget(target);
+  GLenum gl_error = GL_INVALID_FRAMEBUFFER_OPERATION;
+  Framebuffer* draw_framebuffer = GetBoundDrawFramebuffer();
   bool valid = CheckFramebufferValid(
-      draw_framebuffer, target, GL_INVALID_FRAMEBUFFER_OPERATION, func_name);
+      draw_framebuffer, GetDrawFramebufferTarget(), gl_error, func_name);
 
-  target = features().chromium_framebuffer_multisample ?
-      GL_READ_FRAMEBUFFER : GL_FRAMEBUFFER;
-  Framebuffer* read_framebuffer = GetFramebufferInfoForTarget(target);
+  Framebuffer* read_framebuffer = GetBoundReadFramebuffer();
   valid = valid && CheckFramebufferValid(
-      read_framebuffer, target, GL_INVALID_FRAMEBUFFER_OPERATION, func_name);
+      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 = features().chromium_framebuffer_multisample ?
-      framebuffer_state_.bound_read_framebuffer.get() :
-      framebuffer_state_.bound_draw_framebuffer.get();
+  Framebuffer* framebuffer = GetBoundReadFramebuffer();
   if (!framebuffer)
     return false;
   const Framebuffer::Attachment* attachment =
       framebuffer->GetReadBufferAttachment();
   if (!attachment)
     return false;
   return attachment->FormsFeedbackLoop(texture, level, layer);
 }
 
 gfx::Size GLES2DecoderImpl::GetBoundReadFramebufferSize() {
-  Framebuffer* framebuffer =
-      GetFramebufferInfoForTarget(GL_READ_FRAMEBUFFER_EXT);
-  if (framebuffer != NULL) {
+  Framebuffer* framebuffer = GetBoundReadFramebuffer();
+  if (framebuffer) {
     const Framebuffer::Attachment* attachment =
         framebuffer->GetReadBufferAttachment();
     if (attachment) {
       return gfx::Size(attachment->width(), attachment->height());
     }
     return gfx::Size(0, 0);
   } else if (offscreen_target_frame_buffer_.get()) {
     return offscreen_size_;
   } else {
     return surface_->GetSize();
   }
 }
 
 GLuint GLES2DecoderImpl::GetBoundReadFramebufferServiceId() {
-  Framebuffer* framebuffer =
-    GetFramebufferInfoForTarget(GL_READ_FRAMEBUFFER_EXT);
+  Framebuffer* framebuffer = GetBoundReadFramebuffer();
   if (framebuffer) {
     return framebuffer->service_id();
   }
   if (offscreen_resolved_frame_buffer_.get()) {
     return offscreen_resolved_frame_buffer_->id();
   }
   if (offscreen_target_frame_buffer_.get()) {
     return offscreen_target_frame_buffer_->id();
   }
   if (surface_.get()) {
     return surface_->GetBackingFramebufferObject();
   }
   return 0;
 }
 
 GLuint GLES2DecoderImpl::GetBoundDrawFramebufferServiceId() {
-  Framebuffer* framebuffer =
-    GetFramebufferInfoForTarget(GL_DRAW_FRAMEBUFFER_EXT);
+  Framebuffer* framebuffer = GetBoundDrawFramebuffer();
   if (framebuffer) {
     return framebuffer->service_id();
   }
   if (offscreen_target_frame_buffer_.get()) {
     return offscreen_target_frame_buffer_->id();
   }
   if (surface_.get()) {
     return surface_->GetBackingFramebufferObject();
   }
   return 0;
 }
 
 GLenum GLES2DecoderImpl::GetBoundReadFramebufferTextureType() {
-  Framebuffer* framebuffer =
-    GetFramebufferInfoForTarget(GL_READ_FRAMEBUFFER_EXT);
+  Framebuffer* framebuffer = GetBoundReadFramebuffer();
   if (framebuffer) {
     return framebuffer->GetReadBufferTextureType();
   } else {  // Back buffer.
     if (back_buffer_read_buffer_ == GL_NONE)
       return 0;
     return GL_UNSIGNED_BYTE;
   }
 }
 
 GLenum GLES2DecoderImpl::GetBoundReadFramebufferInternalFormat() {
-  Framebuffer* framebuffer =
-      GetFramebufferInfoForTarget(GL_READ_FRAMEBUFFER_EXT);
+  Framebuffer* framebuffer = GetBoundReadFramebuffer();
   if (framebuffer) {
     return framebuffer->GetReadBufferInternalFormat();
   } else {  // Back buffer.
     if (back_buffer_read_buffer_ == GL_NONE)
       return 0;
     if (offscreen_target_frame_buffer_.get()) {
       return offscreen_target_color_format_;
     }
     return back_buffer_color_format_;
   }
 }
 
 GLenum GLES2DecoderImpl::GetBoundColorDrawBufferType(GLint drawbuffer_i) {
   DCHECK(drawbuffer_i >= 0 &&
          drawbuffer_i < static_cast<GLint>(group_->max_draw_buffers()));
-  Framebuffer* framebuffer = GetFramebufferInfoForTarget(GL_DRAW_FRAMEBUFFER);
+  Framebuffer* framebuffer = GetBoundDrawFramebuffer();
   if (!framebuffer) {
     return 0;
   }
   GLenum drawbuffer = static_cast<GLenum>(GL_DRAW_BUFFER0 + drawbuffer_i);
   if (framebuffer->GetDrawBuffer(drawbuffer) == GL_NONE) {
     return 0;
   }
   GLenum attachment = static_cast<GLenum>(GL_COLOR_ATTACHMENT0 + drawbuffer_i);
   const Framebuffer::Attachment* buffer =
       framebuffer->GetAttachment(attachment);
   if (!buffer) {
     return 0;
   }
   return buffer->texture_type();
 }
 
 GLenum GLES2DecoderImpl::GetBoundColorDrawBufferInternalFormat(
     GLint drawbuffer_i) {
   DCHECK(drawbuffer_i >= 0 &&
          drawbuffer_i < static_cast<GLint>(group_->max_draw_buffers()));
-  Framebuffer* framebuffer = GetFramebufferInfoForTarget(GL_DRAW_FRAMEBUFFER);
+  Framebuffer* framebuffer = GetBoundDrawFramebuffer();
   if (!framebuffer) {
     return 0;
   }
   GLenum drawbuffer = static_cast<GLenum>(GL_DRAW_BUFFER0 + drawbuffer_i);
   if (framebuffer->GetDrawBuffer(drawbuffer) == GL_NONE) {
     return 0;
   }
   GLenum attachment = static_cast<GLenum>(GL_COLOR_ATTACHMENT0 + drawbuffer_i);
   const Framebuffer::Attachment* buffer =
       framebuffer->GetAttachment(attachment);
@@ skipping 46 matching lines @@
       return offscreen_target_stencil_format_;
     }
     if (back_buffer_has_stencil_)
       return GL_STENCIL;
     return 0;
   }
 }
 
 void GLES2DecoderImpl::MarkDrawBufferAsCleared(
     GLenum buffer, GLint drawbuffer_i) {
-  Framebuffer* framebuffer = GetFramebufferInfoForTarget(GL_DRAW_FRAMEBUFFER);
+  Framebuffer* framebuffer = GetBoundDrawFramebuffer();
   if (!framebuffer)
     return;
   GLenum attachment  = 0;
   switch (buffer) {
     case GL_COLOR:
       DCHECK(drawbuffer_i >= 0 &&
              drawbuffer_i < static_cast<GLint>(group_->max_draw_buffers()));
       attachment = static_cast<GLenum>(GL_COLOR_ATTACHMENT0 + drawbuffer_i);
       break;
     case GL_DEPTH:
@@ skipping 857 matching lines @@
 
 void GLES2DecoderImpl::DoBindBufferRange(GLenum target, GLuint index,
                                          GLuint client_id,
                                          GLintptr offset,
                                          GLsizeiptr size) {
   BindIndexedBufferImpl(target, index, client_id, offset, size,
                         kBindBufferRange, "glBindBufferRange");
 }
 
 bool GLES2DecoderImpl::BoundFramebufferAllowsChangesToAlphaChannel() {
-  Framebuffer* framebuffer =
-      GetFramebufferInfoForTarget(GL_DRAW_FRAMEBUFFER_EXT);
+  Framebuffer* framebuffer = GetBoundDrawFramebuffer();
   if (framebuffer)
     return framebuffer->HasAlphaMRT();
   if (back_buffer_draw_buffer_ == GL_NONE)
     return false;
   if (offscreen_target_frame_buffer_.get()) {
     GLenum format = offscreen_target_color_format_;
     return (format == GL_RGBA || format == GL_RGBA8) &&
            offscreen_buffer_should_have_alpha_;
   }
   return (back_buffer_color_format_ == GL_RGBA ||
           back_buffer_color_format_ == GL_RGBA8);
 }
 
 bool GLES2DecoderImpl::BoundFramebufferHasDepthAttachment() {
-  Framebuffer* framebuffer =
-      GetFramebufferInfoForTarget(GL_DRAW_FRAMEBUFFER_EXT);
+  Framebuffer* framebuffer = GetBoundDrawFramebuffer();
   if (framebuffer) {
     return framebuffer->HasDepthAttachment();
   }
   if (offscreen_target_frame_buffer_.get()) {
     return offscreen_target_depth_format_ != 0;
   }
   return back_buffer_has_depth_;
 }
 
 bool GLES2DecoderImpl::BoundFramebufferHasStencilAttachment() {
-  Framebuffer* framebuffer =
-      GetFramebufferInfoForTarget(GL_DRAW_FRAMEBUFFER_EXT);
+  Framebuffer* framebuffer = GetBoundDrawFramebuffer();
   if (framebuffer) {
     return framebuffer->HasStencilAttachment();
   }
   if (offscreen_target_frame_buffer_.get()) {
     return offscreen_target_stencil_format_ != 0 ||
            offscreen_target_depth_format_ == GL_DEPTH24_STENCIL8;
   }
   return back_buffer_has_stencil_;
 }
 
@@ skipping 35 matching lines @@
   // the size of the current framebuffer object.
   RestoreFramebufferBindings();
   state_.RestoreState(prev_state);
 }
 
 void GLES2DecoderImpl::RestoreFramebufferBindings() const {
   GLuint service_id =
       framebuffer_state_.bound_draw_framebuffer.get()
           ? framebuffer_state_.bound_draw_framebuffer->service_id()
           : GetBackbufferServiceId();
-  if (!features().chromium_framebuffer_multisample) {
+  if (!SupportsSeparateFramebufferBinds()) {
     glBindFramebufferEXT(GL_FRAMEBUFFER, service_id);
   } else {
     glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER, service_id);
     service_id = framebuffer_state_.bound_read_framebuffer.get()
                      ? framebuffer_state_.bound_read_framebuffer->service_id()
                      : GetBackbufferServiceId();
     glBindFramebufferEXT(GL_READ_FRAMEBUFFER, service_id);
   }
   OnFboChanged();
 }
@@ skipping 661 matching lines @@
     texture_manager()->MarkMipmapsGenerated(texture_ref);
   }
 }
 
 bool GLES2DecoderImpl::GetHelper(
     GLenum pname, GLint* params, GLsizei* num_written) {
   DCHECK(num_written);
   switch (pname) {
     case GL_IMPLEMENTATION_COLOR_READ_FORMAT:
     case GL_IMPLEMENTATION_COLOR_READ_TYPE:
-      // They are not supported on Desktop GL until 4.1, but could be exposed
-      // through GL_OES_read_format extension. However, a conflicting extension
-      // GL_ARB_ES2_compatibility specifies an error case when requested on
-      // integer/floating point buffers.
-      // To simpify the handling, we just query and check for GL errors. If an
-      // GL error occur, we fall back to our internal implementation.
       *num_written = 1;
-      if (!CheckBoundReadFramebufferValid("glGetIntegerv",
-                                          GL_INVALID_OPERATION)) {
-        if (params) {
-          *params = 0;
+      {
+        Framebuffer* framebuffer = GetBoundReadFramebuffer();
+        if (framebuffer &&
+            framebuffer->IsPossiblyComplete(feature_info_.get()) !=
+            GL_FRAMEBUFFER_COMPLETE) {
+          // Here we avoid querying the driver framebuffer status because the
+          // above should cover most cases. This is an effort to reduce crashes
+          // on MacOSX. See crbug.com/662802.
+          LOCAL_SET_GL_ERROR(
+              GL_INVALID_OPERATION, "glGetIntegerv", "incomplete framebuffer");
+          if (params) {
+            *params = 0;
+          }
+          return true;
         }
-        return true;
       }
       if (params) {
-        ScopedGLErrorSuppressor suppressor("GLES2DecoderImpl::GetHelper",
-                                           GetErrorState());
-        glGetIntegerv(pname, params);
-        bool is_valid = glGetError() == GL_NO_ERROR;
-        if (is_valid) {
-          is_valid = pname == GL_IMPLEMENTATION_COLOR_READ_FORMAT ?
-              validators_->read_pixel_format.IsValid(*params) :
-              validators_->read_pixel_type.IsValid(*params);
-        }
-        if (!is_valid) {
+        if (feature_info_->gl_version_info().is_es) {
+          glGetIntegerv(pname, params);
+        } else {
+          // On Desktop GL where these two enums can be queried, instead of
+          // returning the second pair of read format/type, the preferred pair
+          // is returned. So this semantic is different from GL ES.
           if (pname == GL_IMPLEMENTATION_COLOR_READ_FORMAT) {
             *params = GLES2Util::GetGLReadPixelsImplementationFormat(
                 GetBoundReadFramebufferInternalFormat(),
                 GetBoundReadFramebufferTextureType(),
                 feature_info_->feature_flags().ext_read_format_bgra);
           } else {
             *params = GLES2Util::GetGLReadPixelsImplementationType(
                 GetBoundReadFramebufferInternalFormat(),
                 GetBoundReadFramebufferTextureType());
           }
@@ skipping 52 matching lines @@
         glGetIntegerv(GL_MAX_VARYING_VECTORS, &max_varying_vectors);
         *num_written = 1;
         if (params) {
           *params = max_varying_vectors * 4;
         }
         return true;
       }
       case GL_READ_BUFFER:
         *num_written = 1;
         if (params) {
-          Framebuffer* framebuffer =
-              GetFramebufferInfoForTarget(GL_READ_FRAMEBUFFER);
+          Framebuffer* framebuffer = GetBoundReadFramebuffer();
           GLenum read_buffer;
           if (framebuffer) {
             read_buffer = framebuffer->read_buffer();
           } else {
             read_buffer = back_buffer_read_buffer_;
           }
           *params = static_cast<GLint>(read_buffer);
         }
         return true;
       case GL_TRANSFORM_FEEDBACK_ACTIVE:
@@ skipping 56 matching lines @@
     case GL_MAX_DRAW_BUFFERS_ARB:
       *num_written = 1;
       if (params) {
         params[0] = group_->max_draw_buffers();
       }
       return true;
     case GL_ALPHA_BITS:
       *num_written = 1;
       if (params) {
         GLint v = 0;
-        Framebuffer* framebuffer =
-            GetFramebufferInfoForTarget(GL_DRAW_FRAMEBUFFER_EXT);
+        Framebuffer* framebuffer = GetBoundDrawFramebuffer();
         if (framebuffer) {
           if (framebuffer->HasAlphaMRT() &&
               framebuffer->HasSameInternalFormatsMRT()) {
             if (gl_version_info().is_desktop_core_profile) {
               for (uint32_t i = 0; i < group_->max_draw_buffers(); i++) {
                 if (framebuffer->HasColorAttachment(i)) {
                   glGetFramebufferAttachmentParameterivEXT(
                       GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + i,
                       GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE, &v);
                   break;
                 }
               }
             } else {
               glGetIntegerv(GL_ALPHA_BITS, &v);
             }
           }
         } else {
           v = (ClientExposedBackBufferHasAlpha() ? 8 : 0);
         }
         params[0] = v;
       }
       return true;
     case GL_DEPTH_BITS:
       *num_written = 1;
       if (params) {
         GLint v = 0;
         if (gl_version_info().is_desktop_core_profile) {
-          Framebuffer* framebuffer =
-              GetFramebufferInfoForTarget(GL_DRAW_FRAMEBUFFER_EXT);
+          Framebuffer* framebuffer = GetBoundDrawFramebuffer();
           if (framebuffer) {
             if (framebuffer->HasDepthAttachment()) {
               glGetFramebufferAttachmentParameterivEXT(
                   GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
                   GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE, &v);
             }
           } else {
             v = (back_buffer_has_depth_ ? 24 : 0);
           }
         } else {
           glGetIntegerv(GL_DEPTH_BITS, &v);
         }
         params[0] = BoundFramebufferHasDepthAttachment() ? v : 0;
       }
       return true;
     case GL_RED_BITS:
     case GL_GREEN_BITS:
     case GL_BLUE_BITS:
       *num_written = 1;
       if (params) {
         GLint v = 0;
         if (gl_version_info().is_desktop_core_profile) {
-          Framebuffer* framebuffer =
-              GetFramebufferInfoForTarget(GL_DRAW_FRAMEBUFFER_EXT);
+          Framebuffer* framebuffer = GetBoundDrawFramebuffer();
           if (framebuffer) {
             if (framebuffer->HasSameInternalFormatsMRT()) {
               GLenum framebuffer_enum = 0;
               switch (pname) {
                 case GL_RED_BITS:
                   framebuffer_enum = GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE;
                   break;
                 case GL_GREEN_BITS:
                   framebuffer_enum = GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE;
                   break;
@@ skipping 17 matching lines @@
           glGetIntegerv(pname, &v);
         }
         params[0] = v;
       }
       return true;
     case GL_STENCIL_BITS:
       *num_written = 1;
       if (params) {
         GLint v = 0;
         if (gl_version_info().is_desktop_core_profile) {
-          Framebuffer* framebuffer =
-              GetFramebufferInfoForTarget(GL_DRAW_FRAMEBUFFER_EXT);
+          Framebuffer* framebuffer = GetBoundDrawFramebuffer();
           if (framebuffer) {
             if (framebuffer->HasStencilAttachment()) {
               glGetFramebufferAttachmentParameterivEXT(
                   GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT,
                   GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE, &v);
             }
           } else {
             v = (back_buffer_has_stencil_ ? 8 : 0);
           }
         } else {
@@ skipping 1006 matching lines @@
 // Assumes framebuffer is complete.
 void GLES2DecoderImpl::ClearUnclearedAttachments(
     GLenum target, Framebuffer* framebuffer) {
   // Clear textures that we can't use glClear first. These textures will be
   // marked as cleared after the call and no longer be part of the following
   // code.
   framebuffer->ClearUnclearedIntOr3DTexturesOrPartiallyClearedTextures(
       this, texture_manager());
 
   bool cleared_int_renderbuffers = false;
-  Framebuffer* draw_framebuffer =
-      GetFramebufferInfoForTarget(GL_DRAW_FRAMEBUFFER);
+  Framebuffer* draw_framebuffer = GetBoundDrawFramebuffer();
   if (framebuffer->HasUnclearedIntRenderbufferAttachments()) {
     if (target == GL_READ_FRAMEBUFFER && draw_framebuffer != framebuffer) {
       // TODO(zmo): There is no guarantee that an FBO that is complete on the
       // READ attachment will be complete as a DRAW attachment.
       glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER, framebuffer->service_id());
     }
     state_.SetDeviceColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
     state_.SetDeviceCapabilityState(GL_SCISSOR_TEST, false);
 
     // TODO(zmo): Assume DrawBuffers() does not affect ClearBuffer().
@@ skipping 6568 matching lines @@
         final_internal_format, channels_exist, &source_texture_service_id,
         &source_texture_target);
     if (requires_luma_blit) {
       copy_tex_image_blit_->DoCopyTexImage2DToLUMACompatibilityTexture(
           this, texture->service_id(), texture->target(), target, format,
           type, level, internal_format, x, y, width, height,
           GetBoundReadFramebufferServiceId(),
           GetBoundReadFramebufferInternalFormat());
     } else if (use_workaround) {
       GLenum dest_texture_target = target;
-      GLenum framebuffer_target = features().chromium_framebuffer_multisample
-                                      ? GL_READ_FRAMEBUFFER_EXT
-                                      : GL_FRAMEBUFFER;
+      GLenum framebuffer_target = GetReadFramebufferTarget();
 
       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();
       }
 
@@ skipping 4649 matching lines @@
   // 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);
+  Framebuffer* framebuffer = GetBoundReadFramebuffer();
   if (!framebuffer)
     return false;
 
   const Framebuffer::Attachment* attachment =
       framebuffer->GetReadBufferAttachment();
   if (!attachment)
     return false;
 
   if (!attachment->IsTextureAttachment())
     return false;
@@ skipping 189 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