Adds support for EXT_framebuffer_multisample...

gpu/command_buffer/service/gles2_cmd_decoder.cc

 // Copyright (c) 2009 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 <stdio.h>
 
 #include <algorithm>
 #include <list>
@@ skipping 538 matching lines @@
                           uint32 parent_client_texture_id);
   virtual void Destroy();
   virtual void ResizeOffscreenFrameBuffer(const gfx::Size& size);
   virtual bool UpdateOffscreenFrameBufferSize();
   virtual bool MakeCurrent();
   virtual GLES2Util* GetGLES2Util() { return &util_; }
   virtual gfx::GLContext* GetGLContext() { return context_.get(); }
 
   virtual void SetSwapBuffersCallback(Callback0::Type* callback);
 
+  // Restores the current state to the user's settings.
+  void RestoreCurrentFramebufferBindings();
+  void RestoreCurrentRenderbufferBindings();
+  void RestoreCurrentTexture2DBindings();
+
  private:
   friend class ScopedGLErrorSuppressor;
-  friend class ScopedTexture2DBinder;
-  friend class ScopedFrameBufferBinder;
-  friend class ScopedRenderBufferBinder;
   friend class ScopedDefaultGLContext;
   friend class RenderBuffer;
   friend class FrameBuffer;
 
   // State associated with each texture unit.
   struct TextureUnit {
     TextureUnit() : bind_target(GL_TEXTURE_2D) { }
 
     // The last target that was bound to this texture unit.
     GLenum bind_target;
@@ skipping 54 matching lines @@
     return (info && !info->IsDeleted()) ? info : NULL;
   }
 
   // Deletes the texture info for the given texture.
   void RemoveTextureInfo(GLuint client_id) {
     texture_manager()->RemoveTextureInfo(client_id);
   }
 
   // Get the size (in pixels) of the currently bound frame buffer (either FBO
   // or regular back buffer).
-  gfx::Size GetBoundFrameBufferSize();
+  gfx::Size GetBoundReadFrameBufferSize();
 
   // Wrapper for CompressedTexImage2D commands.
   error::Error DoCompressedTexImage2D(
     GLenum target,
     GLint level,
     GLenum internal_format,
     GLsizei width,
     GLsizei height,
     GLint border,
     GLsizei image_size,
@@ skipping 192 matching lines @@
 
   error::Error GetUniformLocationHelper(
     GLuint client_id, uint32 location_shm_id, uint32 location_shm_offset,
     const std::string& name_str);
 
   // Helper for glShaderSource.
   error::Error ShaderSourceHelper(
       GLuint client_id, const char* data, uint32 data_size);
 
   // Clears any uncleared render buffers attached to the given frame buffer.
-  void ClearUnclearedRenderbuffers(FramebufferManager::FramebufferInfo* info);
+  void ClearUnclearedRenderbuffers(
+      GLenum target, FramebufferManager::FramebufferInfo* info);
 
   // Remembers the state of some capabilities.
   void SetCapabilityState(GLenum cap, bool enabled);
 
   // Checks if the current program exists and is valid. If not generates the
   // appropriate GL error.  Returns true if the current program is in a usable
   // state.
   bool CheckCurrentProgram(const char* function_name);
 
   // Checks if the current program exists and is valid and that location is not
@@ skipping 28 matching lines @@
 
   // Wrapper for glBindFramebuffer since we need to track the current targets.
   void DoBindFramebuffer(GLenum target, GLuint framebuffer);
 
   // Wrapper for glBindRenderbuffer since we need to track the current targets.
   void DoBindRenderbuffer(GLenum target, GLuint renderbuffer);
 
   // Wrapper for glBindTexture since we need to track the current targets.
   void DoBindTexture(GLenum target, GLuint texture);
 
+  // Wrapper for glBlitFramebufferEXT.
+  void DoBlitFramebufferEXT(
+      GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
+      GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
+      GLbitfield mask, GLenum filter);
+
   // Wrapper for glBufferData.
   void DoBufferData(
     GLenum target, GLsizeiptr size, const GLvoid * data, GLenum usage);
 
   // Wrapper for glBufferSubData.
   void DoBufferSubData(
     GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid * data);
 
   // Wrapper for glCheckFramebufferStatus
   GLenum DoCheckFramebufferStatus(GLenum target);
@@ skipping 93 matching lines @@
   // Wrapper for glLinkProgram
   void DoLinkProgram(GLuint program);
 
   // Helper for RegisterSharedIds.
   void DoRegisterSharedIds(GLuint namespace_id, GLsizei n, const GLuint* ids);
 
   // Wrapper for glRenderbufferStorage.
   void DoRenderbufferStorage(
       GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
 
+  // Wrapper for glRenderbufferStorageMultisampleEXT.
+  void DoRenderbufferStorageMultisample(
+      GLenum target, GLsizei samples, GLenum internalformat,
+      GLsizei width, GLsizei height);
+
   // Wrapper for glReleaseShaderCompiler.
   void DoReleaseShaderCompiler() { }
 
   // Wrappers for glTexParameter functions.
   void DoTexParameterf(GLenum target, GLenum pname, GLfloat param);
   void DoTexParameteri(GLenum target, GLenum pname, GLint param);
   void DoTexParameterfv(GLenum target, GLenum pname, const GLfloat* params);
   void DoTexParameteriv(GLenum target, GLenum pname, const GLint* params);
 
   // Wrappers for glUniform1i and glUniform1iv as according to the GLES2
@@ skipping 85 matching lines @@
       // track |texture_| with the currently bound TEXTURE_RECTANGLE texture,
       // because |texture_| is used by the FBO rendering mechanism for readback
       // to the bits that get sent to the browser.
       default:
         NOTREACHED();
         return NULL;
     }
     return (info && !info->IsDeleted()) ? info : NULL;
   }
 
+  // Gets the framebuffer info for a particular target.
+  FramebufferManager::FramebufferInfo* GetFramebufferInfoForTarget(
+      GLenum target) {
+    FramebufferManager::FramebufferInfo* info = NULL;
+    switch (target) {
+      case GL_FRAMEBUFFER:
+      case GL_DRAW_FRAMEBUFFER:
+        info = bound_draw_framebuffer_;
+        break;
+      case GL_READ_FRAMEBUFFER:
+        info = bound_read_framebuffer_;
+        break;
+      default:
+        NOTREACHED();
+        break;
+    }
+    return (info && !info->IsDeleted()) ? info : NULL;
+  }
+
   // Validates the program and location for a glGetUniform call and returns
   // a SizeResult setup to receive the result. Returns true if glGetUniform
   // should be called.
   bool GetUniformSetup(
       GLuint program, GLint location,
       uint32 shm_id, uint32 shm_offset,
       error::Error* error, GLuint* service_id, void** result,
       GLenum* result_type);
 
   // Generate a member function prototype for each command in an automated and
@@ skipping 84 matching lines @@
   GLint clear_stencil_;
   GLuint mask_stencil_front_;
   GLuint mask_stencil_back_;
   GLclampf clear_depth_;
   GLboolean mask_depth_;
   bool enable_scissor_test_;
 
   // The program in use by glUseProgram
   ProgramManager::ProgramInfo::Ref current_program_;
 
-  // The currently bound framebuffer
-  FramebufferManager::FramebufferInfo::Ref bound_framebuffer_;
+  // The currently bound framebuffers
+  FramebufferManager::FramebufferInfo::Ref bound_read_framebuffer_;
+  FramebufferManager::FramebufferInfo::Ref bound_draw_framebuffer_;
 
   // The currently bound renderbuffer
   RenderbufferManager::RenderbufferInfo::Ref bound_renderbuffer_;
 
   bool anti_aliased_;
 
   // The offscreen frame buffer that the client renders to. With EGL, the
   // depth and stencil buffers are separate. With regular GL there is a single
   // packed depth stencil buffer in offscreen_target_depth_render_buffer_.
   // offscreen_target_stencil_render_buffer_ is unused.
@@ skipping 38 matching lines @@
   ScopedGLErrorSuppressor suppressor(decoder_);
 
   // TODO(apatrick): Check if there are any other states that need to be reset
   // before binding a new texture.
   glActiveTexture(GL_TEXTURE0);
   glBindTexture(GL_TEXTURE_2D, id);
 }
 
 ScopedTexture2DBinder::~ScopedTexture2DBinder() {
   ScopedGLErrorSuppressor suppressor(decoder_);
-  GLES2DecoderImpl::TextureUnit& info = decoder_->texture_units_[0];
-  GLuint last_id;
-  if (info.bound_texture_2d)
-    last_id = info.bound_texture_2d->service_id();
-  else
-    last_id = 0;
-
-  glBindTexture(GL_TEXTURE_2D, last_id);
-  glActiveTexture(GL_TEXTURE0 + decoder_->active_texture_unit_);
+  decoder_->RestoreCurrentTexture2DBindings();
 }
 
 ScopedRenderBufferBinder::ScopedRenderBufferBinder(GLES2DecoderImpl* decoder,
                                                    GLuint id)
     : decoder_(decoder) {
   ScopedGLErrorSuppressor suppressor(decoder_);
   glBindRenderbufferEXT(GL_RENDERBUFFER, id);
 }
 
 ScopedRenderBufferBinder::~ScopedRenderBufferBinder() {
   ScopedGLErrorSuppressor suppressor(decoder_);
-  glBindRenderbufferEXT(
-      GL_RENDERBUFFER,
-      decoder_->bound_renderbuffer_ ?
-          decoder_->bound_renderbuffer_->service_id() : 0);
+  decoder_->RestoreCurrentRenderbufferBindings();
 }
 
 ScopedFrameBufferBinder::ScopedFrameBufferBinder(GLES2DecoderImpl* decoder,
                                                  GLuint id)
     : decoder_(decoder) {
   ScopedGLErrorSuppressor suppressor(decoder_);
   glBindFramebufferEXT(GL_FRAMEBUFFER, id);
 }
 
 ScopedFrameBufferBinder::~ScopedFrameBufferBinder() {
   ScopedGLErrorSuppressor suppressor(decoder_);
-  FramebufferManager::FramebufferInfo* info =
-      decoder_->bound_framebuffer_.get();
-  GLuint framebuffer_id = info ? info->service_id() : 0;
-  if (framebuffer_id == 0 &&
-      decoder_->offscreen_target_frame_buffer_.get()) {
-    glBindFramebufferEXT(GL_FRAMEBUFFER,
-                         decoder_->offscreen_target_frame_buffer_->id());
-  } else {
-    glBindFramebufferEXT(GL_FRAMEBUFFER, framebuffer_id);
-  }
+  decoder_->RestoreCurrentFramebufferBindings();
 }
 
 ScopedDefaultGLContext::ScopedDefaultGLContext(GLES2DecoderImpl* decoder)
     : decoder_(decoder) {
   decoder_->default_context_->MakeCurrent();
 }
 
 ScopedDefaultGLContext::~ScopedDefaultGLContext() {
   decoder_->context_->MakeCurrent();
 }
@@ skipping 484 matching lines @@
     }
   }
 }
 
 // }  // anonymous namespace
 
 bool GLES2DecoderImpl::MakeCurrent() {
   return context_.get() ? context_->MakeCurrent() : false;
 }
 
-gfx::Size GLES2DecoderImpl::GetBoundFrameBufferSize() {
-  if (bound_framebuffer_ != 0) {
+void GLES2DecoderImpl::RestoreCurrentRenderbufferBindings() {
+  glBindRenderbufferEXT(
+      GL_RENDERBUFFER,
+      bound_renderbuffer_ ? bound_renderbuffer_->service_id() : 0);
+}
+
+static void RebindCurrentFramebuffer(
+    GLenum target,
+    FramebufferManager::FramebufferInfo* info,
+    FrameBuffer* offscreen_frame_buffer) {
+  GLuint framebuffer_id = info ? info->service_id() : 0;
+  if (framebuffer_id == 0 && offscreen_frame_buffer) {
+    framebuffer_id = offscreen_frame_buffer->id();
+  }
+  glBindFramebufferEXT(target, framebuffer_id);
+}
+
+void GLES2DecoderImpl::RestoreCurrentFramebufferBindings() {
+  if (!group_->extension_flags().ext_framebuffer_multisample) {
+    RebindCurrentFramebuffer(
+        GL_FRAMEBUFFER,
+        bound_draw_framebuffer_.get(),
+        offscreen_target_frame_buffer_.get());
+  } else {
+    RebindCurrentFramebuffer(
+        GL_READ_FRAMEBUFFER_EXT,
+        bound_read_framebuffer_.get(),
+        offscreen_target_frame_buffer_.get());
+    RebindCurrentFramebuffer(
+        GL_DRAW_FRAMEBUFFER_EXT,
+        bound_draw_framebuffer_.get(),
+        offscreen_target_frame_buffer_.get());
+  }
+}
+
+void GLES2DecoderImpl::RestoreCurrentTexture2DBindings() {
+  GLES2DecoderImpl::TextureUnit& info = texture_units_[0];
+  GLuint last_id;
+  if (info.bound_texture_2d) {
+    last_id = info.bound_texture_2d->service_id();
+  } else {
+    last_id = 0;
+  }
+
+  glBindTexture(GL_TEXTURE_2D, last_id);
+  glActiveTexture(GL_TEXTURE0 + active_texture_unit_);
+}
+
+gfx::Size GLES2DecoderImpl::GetBoundReadFrameBufferSize() {
+  if (bound_read_framebuffer_ != 0) {
     int width = 0;
     int height = 0;
 
+    GLenum target = group_->extension_flags().ext_framebuffer_multisample ?
+        GL_READ_FRAMEBUFFER_EXT : GL_FRAMEBUFFER;
+
     // Assume we have to have COLOR_ATTACHMENT0. Should we check for depth and
     // stencil.
     GLint fb_type = 0;
     glGetFramebufferAttachmentParameterivEXT(
-        GL_FRAMEBUFFER,
+        target,
         GL_COLOR_ATTACHMENT0,
         GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE,
         &fb_type);
     switch (fb_type) {
       case GL_RENDERBUFFER:
         {
           GLint renderbuffer_id = 0;
           glGetFramebufferAttachmentParameterivEXT(
-              GL_FRAMEBUFFER,
+              target,
               GL_COLOR_ATTACHMENT0,
               GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME,
               &renderbuffer_id);
           if (renderbuffer_id != 0) {
             glGetRenderbufferParameterivEXT(
                 GL_RENDERBUFFER,
                 GL_RENDERBUFFER_WIDTH,
                 &width);
             glGetRenderbufferParameterivEXT(
                 GL_RENDERBUFFER,
                 GL_RENDERBUFFER_HEIGHT,
                 &height);
           }
           break;
         }
       case GL_TEXTURE:
         {
           GLint texture_id = 0;
           glGetFramebufferAttachmentParameterivEXT(
-              GL_FRAMEBUFFER,
+              target,
               GL_COLOR_ATTACHMENT0,
               GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME,
               &texture_id);
           if (texture_id != 0) {
             GLuint client_id = 0;
             if (texture_manager()->GetClientId(texture_id, &client_id)) {
               TextureManager::TextureInfo* texture_info =
                  GetTextureInfo(client_id);
               if (texture_info) {
                 GLint level = 0;
                 GLint face = 0;
                 glGetFramebufferAttachmentParameterivEXT(
-                    GL_FRAMEBUFFER,
+                    target,
                     GL_COLOR_ATTACHMENT0,
                     GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL,
                     &level);
                 glGetFramebufferAttachmentParameterivEXT(
-                    GL_FRAMEBUFFER,
+                    target,
                     GL_COLOR_ATTACHMENT0,
                     GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE,
                     &face);
                 texture_info->GetLevelSize(
                     face ? face : GL_TEXTURE_2D, level, &width, &height);
               }
             }
           }
           break;
         }
@@ skipping 357 matching lines @@
       glGenFramebuffersEXT(1, &service_id);
       CreateFramebufferInfo(client_id, service_id);
       info = GetFramebufferInfo(client_id);
       IdAllocator* id_allocator =
           group_->GetIdAllocator(id_namespaces::kFramebuffers);
       id_allocator->MarkAsUsed(client_id);
     } else {
       service_id = info->service_id();
     }
   }
-  bound_framebuffer_ = info;
+
+  if (target == GL_FRAMEBUFFER || target == GL_DRAW_FRAMEBUFFER_EXT) {
+    bound_draw_framebuffer_ = info;
+  }
+  if (target == GL_FRAMEBUFFER || target == GL_READ_FRAMEBUFFER_EXT) {
+    bound_read_framebuffer_ = info;
+  }
 
   // When rendering to an offscreen frame buffer, instead of unbinding from
   // the current frame buffer, bind to the offscreen target frame buffer.
   if (info == NULL && offscreen_target_frame_buffer_.get())
     service_id = offscreen_target_frame_buffer_->id();
 
   glBindFramebufferEXT(target, service_id);
 }
 
 void GLES2DecoderImpl::DoBindRenderbuffer(GLenum target, GLuint client_id) {
@@ skipping 175 matching lines @@
           buffer_manager()->GetClientId(
               bound_element_array_buffer_->service_id(),
               &client_id);
           *params = client_id;
         } else {
           *params = 0;
         }
       }
       return true;
     case GL_FRAMEBUFFER_BINDING:
+    // case GL_DRAW_FRAMEBUFFER_BINDING_EXT: (same as GL_FRAMEBUFFER_BINDING)
       *num_written = 1;
       if (params) {
-        if (bound_framebuffer_) {
+        if (bound_draw_framebuffer_) {
           GLuint client_id = 0;
           framebuffer_manager()->GetClientId(
-              bound_framebuffer_->service_id(), &client_id);
+              bound_draw_framebuffer_->service_id(), &client_id);
+          *params = client_id;
+        } else {
+          *params = 0;
+        }
+      }
+      return true;
+    case GL_READ_FRAMEBUFFER_BINDING:
+      *num_written = 1;
+      if (params) {
+        if (bound_read_framebuffer_) {
+          GLuint client_id = 0;
+          framebuffer_manager()->GetClientId(
+              bound_read_framebuffer_->service_id(), &client_id);
           *params = client_id;
         } else {
           *params = 0;
         }
       }
       return true;
     case GL_RENDERBUFFER_BINDING:
       *num_written = 1;
       if (params) {
         if (bound_renderbuffer_) {
@@ skipping 318 matching lines @@
     }
     if (simulated_attrib_0) {
       RestoreStateForSimulatedAttrib0();
     }
   }
 }
 
 void GLES2DecoderImpl::DoFramebufferRenderbuffer(
     GLenum target, GLenum attachment, GLenum renderbuffertarget,
     GLuint client_renderbuffer_id) {
-  if (!bound_framebuffer_) {
+  FramebufferManager::FramebufferInfo* framebuffer_info =
+      GetFramebufferInfoForTarget(target);
+  if (!framebuffer_info) {
     SetGLError(GL_INVALID_OPERATION,
                "glFramebufferRenderbuffer: no framebuffer bound");
     return;
   }
   GLuint service_id = 0;
   RenderbufferManager::RenderbufferInfo* info = NULL;
   if (client_renderbuffer_id) {
     info = GetRenderbufferInfo(client_renderbuffer_id);
     if (!info) {
       SetGLError(GL_INVALID_OPERATION,
                  "glFramebufferRenderbuffer: unknown renderbuffer");
       return;
     }
     service_id = info->service_id();
   }
   glFramebufferRenderbufferEXT(
       target, attachment, renderbuffertarget, service_id);
   if (service_id == 0 ||
       glCheckFramebufferStatusEXT(target) == GL_FRAMEBUFFER_COMPLETE) {
-    bound_framebuffer_->AttachRenderbuffer(attachment, info);
+    framebuffer_info->AttachRenderbuffer(attachment, info);
     if (info) {
-      ClearUnclearedRenderbuffers(bound_framebuffer_);
+      ClearUnclearedRenderbuffers(target, framebuffer_info);
     }
   }
 }
 
 void GLES2DecoderImpl::SetCapabilityState(GLenum cap, bool enabled) {
   switch (cap) {
     case GL_SCISSOR_TEST:
       enable_scissor_test_ = enabled;
       break;
     default:
@@ skipping 56 matching lines @@
   } else {
     mask_stencil_back_ = mask;
   }
   glStencilMaskSeparate(face, mask);
 }
 
 // NOTE: There's an assumption here that Texture attachments
 // are cleared because they are textures so we only need to clear
 // the renderbuffers.
 void GLES2DecoderImpl::ClearUnclearedRenderbuffers(
-    FramebufferManager::FramebufferInfo* info) {
+    GLenum target, FramebufferManager::FramebufferInfo* info) {
+  if (target == GL_READ_FRAMEBUFFER_EXT) {
+    // TODO(gman): bind this to the DRAW point, clear then bind back to READ
+  }
   GLbitfield clear_bits = 0;
   if (info->HasUnclearedAttachment(GL_COLOR_ATTACHMENT0)) {
     glClearColor(0, 0, 0, 0);
     glColorMask(true, true, true, true);
     clear_bits |= GL_COLOR_BUFFER_BIT;
   }
 
   if (info->HasUnclearedAttachment(GL_STENCIL_ATTACHMENT) ||
       info->HasUnclearedAttachment(GL_DEPTH_STENCIL_ATTACHMENT)) {
     glClearStencil(0);
@@ skipping 17 matching lines @@
   glClearColor(clear_red_, clear_green_, clear_blue_, clear_alpha_);
   glColorMask(mask_red_, mask_green_, mask_blue_, mask_alpha_);
   glClearStencil(clear_stencil_);
   glStencilMaskSeparate(GL_FRONT, mask_stencil_front_);
   glStencilMaskSeparate(GL_BACK, mask_stencil_back_);
   glClearDepth(clear_depth_);
   glDepthMask(mask_depth_);
   if (enable_scissor_test_) {
     glEnable(GL_SCISSOR_TEST);
   }
+
+  if (target == GL_READ_FRAMEBUFFER_EXT) {
+    // TODO(gman): rebind draw.
+  }
 }
 
 GLenum GLES2DecoderImpl::DoCheckFramebufferStatus(GLenum target) {
-  if (!bound_framebuffer_) {
+  FramebufferManager::FramebufferInfo* info =
+      GetFramebufferInfoForTarget(target);
+  if (!info) {
     return GL_FRAMEBUFFER_COMPLETE;
   }
   return glCheckFramebufferStatusEXT(target);
 }
 
 void GLES2DecoderImpl::DoFramebufferTexture2D(
     GLenum target, GLenum attachment, GLenum textarget,
     GLuint client_texture_id, GLint level) {
-  if (!bound_framebuffer_) {
+  FramebufferManager::FramebufferInfo* framebuffer_info =
+      GetFramebufferInfoForTarget(target);
+  if (!framebuffer_info) {
     SetGLError(GL_INVALID_OPERATION,
                "glFramebufferTexture2D: no framebuffer bound.");
     return;
   }
   GLuint service_id = 0;
   TextureManager::TextureInfo* info = NULL;
   if (client_texture_id) {
     info = GetTextureInfo(client_texture_id);
     if (!info) {
       SetGLError(GL_INVALID_OPERATION,
                  "glFramebufferTexture2D: unknown texture");
       return;
     }
     service_id = info->service_id();
   }
   glFramebufferTexture2DEXT(target, attachment, textarget, service_id, level);
   if (service_id != 0 &&
       glCheckFramebufferStatusEXT(target) == GL_FRAMEBUFFER_COMPLETE) {
-    ClearUnclearedRenderbuffers(bound_framebuffer_);
+    ClearUnclearedRenderbuffers(target, framebuffer_info);
   }
 }
 
 void GLES2DecoderImpl::DoGetFramebufferAttachmentParameteriv(
     GLenum target, GLenum attachment, GLenum pname, GLint* params) {
-  if (!bound_framebuffer_) {
+  FramebufferManager::FramebufferInfo* framebuffer_info =
+      GetFramebufferInfoForTarget(target);
+  if (!framebuffer_info) {
     SetGLError(GL_INVALID_OPERATION,
                "glFramebufferAttachmentParameteriv: no framebuffer bound");
     return;
   }
   glGetFramebufferAttachmentParameterivEXT(target, attachment, pname, params);
   if (pname == GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME) {
     GLint type = 0;
     GLuint client_id = 0;
     glGetFramebufferAttachmentParameterivEXT(
         target, attachment, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, &type);
@@ skipping 20 matching lines @@
                "glGetRenderbufferParameteriv: no renderbuffer bound");
     return;
   }
   if (pname == GL_RENDERBUFFER_INTERNAL_FORMAT) {
     *params = bound_renderbuffer_->internal_format();
     return;
   }
   glGetRenderbufferParameterivEXT(target, pname, params);
 }
 
+void GLES2DecoderImpl::DoBlitFramebufferEXT(
+    GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
+    GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
+    GLbitfield mask, GLenum filter) {
+  if (!group_->extension_flags().ext_framebuffer_multisample) {
+    SetGLError(GL_INVALID_OPERATION,
+               "glBlitFramebufferEXT: function not available");
+  }
+  glBlitFramebufferEXT(
+    srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
+}
+
+void GLES2DecoderImpl::DoRenderbufferStorageMultisample(
+    GLenum target, GLsizei samples, GLenum internalformat,
+    GLsizei width, GLsizei height) {
+  if (!group_->extension_flags().ext_framebuffer_multisample) {
+    SetGLError(GL_INVALID_OPERATION,
+               "glRenderbufferStorageMultisampleEXT: function not available");
+    return;
+  }
+  bound_renderbuffer_->set_internal_format(internalformat);
+
+  if (gfx::GetGLImplementation() != gfx::kGLImplementationEGLGLES2) {
+    switch (internalformat) {
+      case GL_DEPTH_COMPONENT16:
+        internalformat = GL_DEPTH_COMPONENT;
+        break;
+      case GL_RGBA4:
+      case GL_RGB5_A1:
+        internalformat = GL_RGBA;
+        break;
+      case GL_RGB565:
+        internalformat = GL_RGB;
+        break;
+    }
+  }
+
+  glRenderbufferStorageMultisampleEXT(
+      target, samples, internalformat, width, height);
+  // TODO(gman) should not set internal format unless this succeeds
+}
+
 void GLES2DecoderImpl::DoRenderbufferStorage(
   GLenum target, GLenum internalformat, GLsizei width, GLsizei height) {
   if (!bound_renderbuffer_) {
     SetGLError(GL_INVALID_OPERATION,
                "glGetRenderbufferStorage: no renderbuffer bound");
     return;
   }
   bound_renderbuffer_->set_internal_format(internalformat);
 
   if (gfx::GetGLImplementation() != gfx::kGLImplementationEGLGLES2) {
     switch (internalformat) {
       case GL_DEPTH_COMPONENT16:
         internalformat = GL_DEPTH_COMPONENT;
         break;
       case GL_RGBA4:
       case GL_RGB5_A1:
         internalformat = GL_RGBA;
         break;
       case GL_RGB565:
         internalformat = GL_RGB;
         break;
     }
   }
 
   glRenderbufferStorageEXT(target, internalformat, width, height);
+  // TODO(gman) should not set internal format unless this succeeds
 }
 
 void GLES2DecoderImpl::DoLinkProgram(GLuint program) {
   ProgramManager::ProgramInfo* info = GetProgramInfoNotShader(
       program, "glLinkProgram");
   if (!info) {
     return;
   }
   if (!info->CanLink()) {
     return;
@@ skipping 1025 matching lines @@
     SetGLError(GL_INVALID_ENUM, "glReadPixels: type GL_INVALID_ENUM");
     return error::kNoError;
   }
   if (width == 0 || height == 0) {
     return error::kNoError;
   }
 
   CopyRealGLErrorsToWrapper();
 
   // Get the size of the current fbo or backbuffer.
-  gfx::Size max_size = GetBoundFrameBufferSize();
+  gfx::Size max_size = GetBoundReadFrameBufferSize();
 
   GLint max_x;
   GLint max_y;
   if (!SafeAdd(x, width, &max_x) || !SafeAdd(y, height, &max_y)) {
     SetGLError(GL_INVALID_VALUE, "glReadPixels: dimensions out of range");
     return error::kNoError;
   }
 
   if (x < 0 || y < 0 || max_x > max_size.width() || max_y > max_size.height()) {
     // The user requested an out of range area. Get the results 1 line
@@ skipping 1117 matching lines @@
   return error::kNoError;
 }
 
 // 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 "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu