Revert "Workaround for Qualcomm renderbuffer resize bug"

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 376 matching lines @@
 // Encapsulates an OpenGL render buffer of any format.
 class BackRenderbuffer {
  public:
   explicit BackRenderbuffer(GLES2DecoderImpl* decoder);
   ~BackRenderbuffer();
 
   // Create a new render buffer.
   void Create();
 
   // Set the initial size and format of a render buffer or resize it.
-  bool AllocateStorage(const gfx::Size& size, GLenum format, GLsizei samples);
+  bool AllocateStorage(const FeatureInfo* feature_info,
+                       const gfx::Size& size,
+                       GLenum format,
+                       GLsizei samples);
 
   // Destroy the render buffer. This must be explicitly called before destroying
   // this object.
   void Destroy();
 
   // Invalidate the render buffer. This can be used when a context is lost and
   // it is not possible to make it current in order to free the resource.
   void Invalidate();
 
   GLuint id() const {
@@ skipping 213 matching lines @@
   bool BoundFramebufferHasStencilAttachment();
 
   // Overriden from ErrorStateClient.
   void OnContextLostError() override;
   void OnOutOfMemoryError() override;
 
   // Ensure Renderbuffer corresponding to last DoBindRenderbuffer() is bound.
   void EnsureRenderbufferBound();
 
   // Helpers to facilitate calling into compatible extensions.
-  void RenderbufferStorageMultisampleWithWorkaround(GLenum target,
-                                                    GLsizei samples,
-                                                    GLenum internal_format,
-                                                    GLsizei width,
-                                                    GLsizei height);
-  void RenderbufferStorageMultisampleHelper(GLenum target,
-                                            GLsizei samples,
-                                            GLenum internal_format,
-                                            GLsizei width,
-                                            GLsizei height);
-  bool RegenerateRenderbufferIfNeeded(Renderbuffer* renderbuffer);
+  static void RenderbufferStorageMultisampleHelper(
+      const FeatureInfo* feature_info,
+      GLenum target,
+      GLsizei samples,
+      GLenum internal_format,
+      GLsizei width,
+      GLsizei height);
 
   void BlitFramebufferHelper(GLint srcX0,
                              GLint srcY0,
                              GLint srcX1,
                              GLint srcY1,
                              GLint dstX0,
                              GLint dstY0,
                              GLint dstX1,
                              GLint dstY1,
                              GLbitfield mask,
@@ skipping 2250 matching lines @@
   DCHECK_EQ(id_, 0u);
 }
 
 void BackRenderbuffer::Create() {
   ScopedGLErrorSuppressor suppressor("BackRenderbuffer::Create",
                                      decoder_->state_.GetErrorState());
   Destroy();
   glGenRenderbuffersEXT(1, &id_);
 }
 
-bool BackRenderbuffer::AllocateStorage(const gfx::Size& size,
+bool BackRenderbuffer::AllocateStorage(const FeatureInfo* feature_info,
+                                       const gfx::Size& size,
                                        GLenum format,
                                        GLsizei samples) {
   ScopedGLErrorSuppressor suppressor("BackRenderbuffer::AllocateStorage",
                                      decoder_->state_.GetErrorState());
   ScopedRenderBufferBinder binder(&decoder_->state_, id_);
 
   uint32_t estimated_size = 0;
   if (!decoder_->renderbuffer_manager()->ComputeEstimatedRenderbufferSize(
           size.width(), size.height(), samples, format, &estimated_size)) {
     return false;
   }
 
   if (!memory_tracker_.EnsureGPUMemoryAvailable(estimated_size)) {
     return false;
   }
 
-  // TODO(kainino): "samples <= 1" is technically incorrect (it should be
-  // "samples == 0"), but it causes framebuffer incompleteness in some
-  // situations. Once this is fixed, this entire arm is no longer necessary -
-  // RenderbufferStorageMultisampleHelper implements it. http://crbug.com/731286
   if (samples <= 1) {
     glRenderbufferStorageEXT(GL_RENDERBUFFER,
                              format,
                              size.width(),
                              size.height());
   } else {
-    // TODO(kainino): This path will not perform RegenerateRenderbufferIfNeeded
-    // on devices where multisample_renderbuffer_resize_emulation is needed.
-    // Thus any code using this path (pepper?) could encounter issues on those
-    // devices. RenderbufferStorageMultisampleWithWorkaround should be used
-    // instead, but can only be used if BackRenderbuffer tracks its
-    // renderbuffers in the renderbuffer manager instead of manually.
-    // http://crbug.com/731287
-    decoder_->RenderbufferStorageMultisampleHelper(
-        GL_RENDERBUFFER, samples, format, size.width(), size.height());
+    GLES2DecoderImpl::RenderbufferStorageMultisampleHelper(feature_info,
+                                                           GL_RENDERBUFFER,
+                                                           samples,
+                                                           format,
+                                                           size.width(),
+                                                           size.height());
   }
 
   bool alpha_channel_needs_clear =
       (format == GL_RGBA || format == GL_RGBA8) &&
       !decoder_->offscreen_buffer_should_have_alpha_;
   if (alpha_channel_needs_clear) {
     GLuint fbo;
     glGenFramebuffersEXT(1, &fbo);
     {
       ScopedFramebufferBinder binder(decoder_, fbo);
@@ skipping 2094 matching lines @@
   if (w < 0 || h < 0 || h >= (INT_MAX / 4) / (w ? w : 1)) {
     LOG(ERROR) << "GLES2DecoderImpl::ResizeOffscreenFramebuffer failed "
                << "to allocate storage due to excessive dimensions.";
     return false;
   }
 
   // Reallocate the offscreen target buffers.
   DCHECK(offscreen_target_color_format_);
   if (IsOffscreenBufferMultisampled()) {
     if (!offscreen_target_color_render_buffer_->AllocateStorage(
-            offscreen_size_, offscreen_target_color_format_,
-            offscreen_target_samples_)) {
+            feature_info_.get(), offscreen_size_,
+            offscreen_target_color_format_, offscreen_target_samples_)) {
       LOG(ERROR) << "GLES2DecoderImpl::ResizeOffscreenFramebuffer failed "
                  << "to allocate storage for offscreen target color buffer.";
       return false;
     }
   } else {
     if (!offscreen_target_color_texture_->AllocateStorage(
         offscreen_size_, offscreen_target_color_format_, false)) {
       LOG(ERROR) << "GLES2DecoderImpl::ResizeOffscreenFramebuffer failed "
                  << "to allocate storage for offscreen target color texture.";
       return false;
     }
   }
   if (offscreen_target_depth_format_ &&
       !offscreen_target_depth_render_buffer_->AllocateStorage(
-          offscreen_size_, offscreen_target_depth_format_,
+          feature_info_.get(),
+          offscreen_size_,
+          offscreen_target_depth_format_,
           offscreen_target_samples_)) {
     LOG(ERROR) << "GLES2DecoderImpl::ResizeOffscreenFramebuffer failed "
                << "to allocate storage for offscreen target depth buffer.";
     return false;
   }
   if (offscreen_target_stencil_format_ &&
       !offscreen_target_stencil_render_buffer_->AllocateStorage(
-          offscreen_size_, offscreen_target_stencil_format_,
+          feature_info_.get(),
+          offscreen_size_,
+          offscreen_target_stencil_format_,
           offscreen_target_samples_)) {
     LOG(ERROR) << "GLES2DecoderImpl::ResizeOffscreenFramebuffer failed "
                << "to allocate storage for offscreen target stencil buffer.";
     return false;
   }
 
   // Attach the offscreen target buffers to the target frame buffer.
   if (IsOffscreenBufferMultisampled()) {
     offscreen_target_frame_buffer_->AttachRenderBuffer(
         GL_COLOR_ATTACHMENT0,
@@ skipping 662 matching lines @@
   // backbuffer.
   if (framebuffer == NULL) {
     service_id = GetBackbufferServiceId();
   }
 
   glBindFramebufferEXT(target, service_id);
   OnFboChanged();
 }
 
 void GLES2DecoderImpl::DoBindRenderbuffer(GLenum target, GLuint client_id) {
-  DCHECK_EQ(target, (GLenum)GL_RENDERBUFFER);
   Renderbuffer* renderbuffer = NULL;
   GLuint service_id = 0;
   if (client_id != 0) {
     renderbuffer = GetRenderbuffer(client_id);
     if (!renderbuffer) {
       if (!group_->bind_generates_resource()) {
         LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION,
                            "glBindRenderbuffer",
                            "id not generated by glGenRenderbuffers");
         return;
@@ skipping 2603 matching lines @@
 void GLES2DecoderImpl::EnsureRenderbufferBound() {
   if (!state_.bound_renderbuffer_valid) {
     state_.bound_renderbuffer_valid = true;
     glBindRenderbufferEXT(GL_RENDERBUFFER,
                           state_.bound_renderbuffer.get()
                               ? state_.bound_renderbuffer->service_id()
                               : 0);
   }
 }
 
-void GLES2DecoderImpl::RenderbufferStorageMultisampleWithWorkaround(
+void GLES2DecoderImpl::RenderbufferStorageMultisampleHelper(
+    const FeatureInfo* feature_info,
     GLenum target,
     GLsizei samples,
     GLenum internal_format,
     GLsizei width,
     GLsizei height) {
-  RegenerateRenderbufferIfNeeded(state_.bound_renderbuffer.get());
-  EnsureRenderbufferBound();
-  RenderbufferStorageMultisampleHelper(target, samples, internal_format, width,
-                                       height);
-}
-
-void GLES2DecoderImpl::RenderbufferStorageMultisampleHelper(
-    GLenum target,
-    GLsizei samples,
-    GLenum internal_format,
-    GLsizei width,
-    GLsizei height) {
-  if (samples == 0) {
-    glRenderbufferStorageEXT(target, internal_format, width, height);
-    return;
-  }
-
   // TODO(sievers): This could be resolved at the GL binding level, but the
   // binding process is currently a bit too 'brute force'.
-  if (features().use_img_for_multisampled_render_to_texture) {
-    glRenderbufferStorageMultisampleIMG(target, samples, internal_format, width,
-                                        height);
-  } else if (features().use_core_framebuffer_multisample) {
+  if (feature_info->feature_flags().use_core_framebuffer_multisample) {
     glRenderbufferStorageMultisample(
         target, samples, internal_format, width, height);
-  } else if (features().angle_framebuffer_multisample) {
+  } else if (feature_info->feature_flags().angle_framebuffer_multisample) {
     // This is ES2 only.
     glRenderbufferStorageMultisampleANGLE(
         target, samples, internal_format, width, height);
   } else {
     glRenderbufferStorageMultisampleEXT(
         target, samples, internal_format, width, height);
   }
 }
 
-bool GLES2DecoderImpl::RegenerateRenderbufferIfNeeded(
-    Renderbuffer* renderbuffer) {
-  if (!workarounds().multisample_renderbuffer_resize_emulation) {
-    return false;
-  }
-
-  if (!renderbuffer->RegenerateAndBindBackingObjectIfNeeded()) {
-    return false;
-  }
-
-  if (renderbuffer != state_.bound_renderbuffer.get()) {
-    // The renderbuffer bound in the driver has changed to the new
-    // renderbuffer->service_id(). If that isn't state_.bound_renderbuffer,
-    // then state_.bound_renderbuffer is no longer bound in the driver.
-    state_.bound_renderbuffer_valid = false;
-  }
-
-  return true;
-}
-
 void GLES2DecoderImpl::BlitFramebufferHelper(GLint srcX0,
                                              GLint srcY0,
                                              GLint srcX1,
                                              GLint srcY1,
                                              GLint dstX0,
                                              GLint dstY0,
                                              GLint dstX1,
                                              GLint dstY1,
                                              GLbitfield mask,
                                              GLenum filter) {
@@ skipping 60 matching lines @@
                        "glRenderbufferStorageMultisampleCHROMIUM",
                        "no renderbuffer bound");
     return;
   }
 
   if (!ValidateRenderbufferStorageMultisample(
       samples, internalformat, width, height)) {
     return;
   }
 
+  EnsureRenderbufferBound();
   GLenum impl_format =
       renderbuffer_manager()->InternalRenderbufferFormatToImplFormat(
           internalformat);
   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER(
       "glRenderbufferStorageMultisampleCHROMIUM");
-  RenderbufferStorageMultisampleWithWorkaround(target, samples, impl_format,
-                                               width, height);
+  RenderbufferStorageMultisampleHelper(
+      feature_info_.get(), target, samples, impl_format, width, height);
   GLenum error =
       LOCAL_PEEK_GL_ERROR("glRenderbufferStorageMultisampleCHROMIUM");
   if (error == GL_NO_ERROR) {
     if (workarounds().validate_multisample_buffer_allocation) {
       if (!VerifyMultisampleRenderbufferIntegrity(
           renderbuffer->service_id(), impl_format)) {
         LOCAL_SET_GL_ERROR(
             GL_OUT_OF_MEMORY,
             "glRenderbufferStorageMultisampleCHROMIUM", "out of memory");
         return;
@@ skipping 15 matching lines @@
                        "glRenderbufferStorageMultisampleEXT",
                        "no renderbuffer bound");
     return;
   }
 
   if (!ValidateRenderbufferStorageMultisample(
       samples, internalformat, width, height)) {
     return;
   }
 
+  EnsureRenderbufferBound();
   GLenum impl_format =
       renderbuffer_manager()->InternalRenderbufferFormatToImplFormat(
           internalformat);
   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("glRenderbufferStorageMultisampleEXT");
-  RenderbufferStorageMultisampleWithWorkaround(target, samples, impl_format,
-                                               width, height);
+  if (features().use_img_for_multisampled_render_to_texture) {
+    glRenderbufferStorageMultisampleIMG(
+        target, samples, impl_format, width, height);
+  } else {
+    glRenderbufferStorageMultisampleEXT(
+        target, samples, impl_format, width, height);
+  }
   GLenum error = LOCAL_PEEK_GL_ERROR("glRenderbufferStorageMultisampleEXT");
   if (error == GL_NO_ERROR) {
     renderbuffer_manager()->SetInfoAndInvalidate(renderbuffer, samples,
                                                  internalformat, width, height);
   }
 }
 
 // This function validates the allocation of a multisampled renderbuffer
 // by clearing it to a key color, blitting the contents to a texture, and
 // reading back the color to ensure it matches the key.
@@ skipping 123 matching lines @@
         GL_OUT_OF_MEMORY, "glRenderbufferStorage", "dimensions too large");
     return;
   }
 
   if (!EnsureGPUMemoryAvailable(estimated_size)) {
     LOCAL_SET_GL_ERROR(
         GL_OUT_OF_MEMORY, "glRenderbufferStorage", "out of memory");
     return;
   }
 
+  EnsureRenderbufferBound();
   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("glRenderbufferStorage");
-  RenderbufferStorageMultisampleWithWorkaround(
-      target, 0,
+  glRenderbufferStorageEXT(
+      target,
       renderbuffer_manager()->InternalRenderbufferFormatToImplFormat(
           internalformat),
-      width, height);
+      width,
+      height);
   GLenum error = LOCAL_PEEK_GL_ERROR("glRenderbufferStorage");
   if (error == GL_NO_ERROR) {
     renderbuffer_manager()->SetInfoAndInvalidate(renderbuffer, 0,
                                                  internalformat, width, height);
   }
 }
 
 void GLES2DecoderImpl::DoLineWidth(GLfloat width) {
   glLineWidth(
       std::min(std::max(width, line_width_range_[0]), line_width_range_[1]));
@@ skipping 10997 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