[Command Buffer] Coding style: FrameBuffer -> Framebuffer to be comformant

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 326 matching lines @@
   explicit ScopedRenderBufferBinder(ContextState* state, GLuint id);
   ~ScopedRenderBufferBinder();
 
  private:
   ContextState* state_;
   DISALLOW_COPY_AND_ASSIGN(ScopedRenderBufferBinder);
 };
 
 // Temporarily changes a decoder's bound frame buffer and restore it when this
 // object goes out of scope.
-class ScopedFrameBufferBinder {
+class ScopedFramebufferBinder {
  public:
-  explicit ScopedFrameBufferBinder(GLES2DecoderImpl* decoder, GLuint id);
-  ~ScopedFrameBufferBinder();
+  explicit ScopedFramebufferBinder(GLES2DecoderImpl* decoder, GLuint id);
+  ~ScopedFramebufferBinder();
 
  private:
   GLES2DecoderImpl* decoder_;
-  DISALLOW_COPY_AND_ASSIGN(ScopedFrameBufferBinder);
+  DISALLOW_COPY_AND_ASSIGN(ScopedFramebufferBinder);
 };
 
 // Temporarily changes a decoder's bound frame buffer to a resolved version of
 // the multisampled offscreen render buffer if that buffer is multisampled, and,
 // if it is bound or enforce_internal_framebuffer is true. If internal is
 // true, the resolved framebuffer is not visible to the parent.
-class ScopedResolvedFrameBufferBinder {
+class ScopedResolvedFramebufferBinder {
  public:
-  explicit ScopedResolvedFrameBufferBinder(GLES2DecoderImpl* decoder,
+  explicit ScopedResolvedFramebufferBinder(GLES2DecoderImpl* decoder,
                                            bool enforce_internal_framebuffer,
                                            bool internal);
-  ~ScopedResolvedFrameBufferBinder();
+  ~ScopedResolvedFramebufferBinder();
 
  private:
   GLES2DecoderImpl* decoder_;
   bool resolve_and_bind_;
-  DISALLOW_COPY_AND_ASSIGN(ScopedResolvedFrameBufferBinder);
+  DISALLOW_COPY_AND_ASSIGN(ScopedResolvedFramebufferBinder);
 };
 
 // Encapsulates an OpenGL texture.
 class BackTexture {
  public:
   explicit BackTexture(GLES2DecoderImpl* decoder);
   ~BackTexture();
 
   // Create a new render texture.
   void Create();
@@ skipping 189 matching lines @@
   bool Initialize(const scoped_refptr<gl::GLSurface>& surface,
                   const scoped_refptr<gl::GLContext>& context,
                   bool offscreen,
                   const DisallowedFeatures& disallowed_features,
                   const ContextCreationAttribHelper& attrib_helper) override;
   void Destroy(bool have_context) override;
   void SetSurface(const scoped_refptr<gl::GLSurface>& surface) override;
   void ReleaseSurface() override;
   void TakeFrontBuffer(const Mailbox& mailbox) override;
   void ReturnFrontBuffer(const Mailbox& mailbox, bool is_lost) override;
-  bool ResizeOffscreenFrameBuffer(const gfx::Size& size) override;
+  bool ResizeOffscreenFramebuffer(const gfx::Size& size) override;
   bool MakeCurrent() override;
   GLES2Util* GetGLES2Util() override { return &util_; }
   gl::GLContext* GetGLContext() override { return context_.get(); }
   ContextGroup* GetContextGroup() override { return group_.get(); }
   const FeatureInfo* GetFeatureInfo() const override {
     return feature_info_.get();
   }
   Capabilities GetCapabilities() override;
   void RestoreState(const ContextState* prev_state) override;
 
@@ skipping 112 matching lines @@
                              GLint dstX0,
                              GLint dstY0,
                              GLint dstX1,
                              GLint dstY1,
                              GLbitfield mask,
                              GLenum filter);
 
   PathManager* path_manager() { return group_->path_manager(); }
 
  private:
-  friend class ScopedFrameBufferBinder;
-  friend class ScopedResolvedFrameBufferBinder;
+  friend class ScopedFramebufferBinder;
+  friend class ScopedResolvedFramebufferBinder;
   friend class BackFramebuffer;
   friend class BackRenderbuffer;
   friend class BackTexture;
 
   enum FramebufferOperation {
     kFramebufferDiscard,
     kFramebufferInvalidate,
     kFramebufferInvalidateSub
   };
 
@@ skipping 147 matching lines @@
     return transform_feedback_manager_->GetTransformFeedback(client_id);
   }
 
   // Deletes the TransformFeedback info for the given transformfeedback.
   void RemoveTransformFeedback(GLuint client_id) {
     transform_feedback_manager_->RemoveTransformFeedback(client_id);
   }
 
   // Get the size (in pixels) of the currently bound frame buffer (either FBO
   // or regular back buffer).
-  gfx::Size GetBoundReadFrameBufferSize();
+  gfx::Size GetBoundReadFramebufferSize();
 
   // Get the service side ID for the bound read frame buffer.
   // If it's back buffer, 0 is returned.
-  GLuint GetBoundReadFrameBufferServiceId();
+  GLuint GetBoundReadFramebufferServiceId();
 
   // Get the format/type of the currently bound frame buffer (either FBO or
   // regular back buffer).
   // If the color image is a renderbuffer, returns 0 for type.
-  GLenum GetBoundReadFrameBufferTextureType();
-  GLenum GetBoundReadFrameBufferInternalFormat();
+  GLenum GetBoundReadFramebufferTextureType();
+  GLenum GetBoundReadFramebufferInternalFormat();
 
   // Get the i-th draw buffer's internal format/type from the bound framebuffer.
   // If no framebuffer is bound, or no image is attached, or the DrawBuffers
   // setting for that image is GL_NONE, return 0.
   GLenum GetBoundColorDrawBufferType(GLint drawbuffer_i);
   GLenum GetBoundColorDrawBufferInternalFormat(GLint drawbuffer_i);
 
-  GLsizei GetBoundFrameBufferSamples(GLenum target);
+  GLsizei GetBoundFramebufferSamples(GLenum target);
 
   // Return 0 if no depth attachment.
-  GLenum GetBoundFrameBufferDepthFormat(GLenum target);
+  GLenum GetBoundFramebufferDepthFormat(GLenum target);
   // Return 0 if no stencil attachment.
-  GLenum GetBoundFrameBufferStencilFormat(GLenum target);
+  GLenum GetBoundFramebufferStencilFormat(GLenum target);
 
   void MarkDrawBufferAsCleared(GLenum buffer, GLint drawbuffer_i);
 
   // Wrapper for CompressedTexImage2D commands.
   error::Error DoCompressedTexImage2D(
       GLenum target,
       GLint level,
       GLenum internal_format,
       GLsizei width,
       GLsizei height,
@@ skipping 1481 matching lines @@
       "ScopedRenderBufferBinder::ctor", state_->GetErrorState());
   glBindRenderbufferEXT(GL_RENDERBUFFER, id);
 }
 
 ScopedRenderBufferBinder::~ScopedRenderBufferBinder() {
   ScopedGLErrorSuppressor suppressor(
       "ScopedRenderBufferBinder::dtor", state_->GetErrorState());
   state_->RestoreRenderbufferBindings();
 }
 
-ScopedFrameBufferBinder::ScopedFrameBufferBinder(GLES2DecoderImpl* decoder,
+ScopedFramebufferBinder::ScopedFramebufferBinder(GLES2DecoderImpl* decoder,
                                                  GLuint id)
     : decoder_(decoder) {
   ScopedGLErrorSuppressor suppressor(
-      "ScopedFrameBufferBinder::ctor", decoder_->GetErrorState());
+      "ScopedFramebufferBinder::ctor", decoder_->GetErrorState());
   glBindFramebufferEXT(GL_FRAMEBUFFER, id);
   decoder->OnFboChanged();
 }
 
-ScopedFrameBufferBinder::~ScopedFrameBufferBinder() {
+ScopedFramebufferBinder::~ScopedFramebufferBinder() {
   ScopedGLErrorSuppressor suppressor(
-      "ScopedFrameBufferBinder::dtor", decoder_->GetErrorState());
+      "ScopedFramebufferBinder::dtor", decoder_->GetErrorState());
   decoder_->RestoreCurrentFramebufferBindings();
 }
 
-ScopedResolvedFrameBufferBinder::ScopedResolvedFrameBufferBinder(
+ScopedResolvedFramebufferBinder::ScopedResolvedFramebufferBinder(
     GLES2DecoderImpl* decoder, bool enforce_internal_framebuffer, bool internal)
     : decoder_(decoder) {
   resolve_and_bind_ = (
       decoder_->offscreen_target_frame_buffer_.get() &&
       decoder_->IsOffscreenBufferMultisampled() &&
       (!decoder_->framebuffer_state_.bound_read_framebuffer.get() ||
        enforce_internal_framebuffer));
   if (!resolve_and_bind_)
     return;
   ScopedGLErrorSuppressor suppressor(
-      "ScopedResolvedFrameBufferBinder::ctor", decoder_->GetErrorState());
+      "ScopedResolvedFramebufferBinder::ctor", decoder_->GetErrorState());
 
   // On old AMD GPUs on macOS, glColorMask doesn't work correctly for
   // multisampled renderbuffers and the alpha channel can be overwritten. This
   // workaround clears the alpha channel before resolving.
   bool alpha_channel_needs_clear =
       decoder_->should_use_native_gmb_for_backbuffer_ &&
       !decoder_->offscreen_buffer_should_have_alpha_ &&
       decoder_->ChromiumImageNeedsRGBEmulation() &&
       decoder_->feature_info_->workarounds()
           .disable_multisampling_color_mask_usage;
@@ skipping 20 matching lines @@
       decoder_->offscreen_resolved_color_texture_->Create();
 
       DCHECK(decoder_->offscreen_saved_color_format_);
       decoder_->offscreen_resolved_color_texture_->AllocateStorage(
           decoder_->offscreen_size_, decoder_->offscreen_saved_color_format_,
           false);
       decoder_->offscreen_resolved_frame_buffer_->AttachRenderTexture(
           decoder_->offscreen_resolved_color_texture_.get());
       if (decoder_->offscreen_resolved_frame_buffer_->CheckStatus() !=
           GL_FRAMEBUFFER_COMPLETE) {
-        LOG(ERROR) << "ScopedResolvedFrameBufferBinder failed "
+        LOG(ERROR) << "ScopedResolvedFramebufferBinder failed "
                    << "because offscreen resolved FBO was incomplete.";
         return;
       }
     }
     targetid = decoder_->offscreen_resolved_frame_buffer_->id();
   } else {
     targetid = decoder_->offscreen_saved_frame_buffer_->id();
   }
   glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, targetid);
   const int width = decoder_->offscreen_size_.width();
   const int height = decoder_->offscreen_size_.height();
   decoder->state_.SetDeviceCapabilityState(GL_SCISSOR_TEST, false);
   decoder->BlitFramebufferHelper(0,
                                  0,
                                  width,
                                  height,
                                  0,
                                  0,
                                  width,
                                  height,
                                  GL_COLOR_BUFFER_BIT,
                                  GL_NEAREST);
   glBindFramebufferEXT(GL_FRAMEBUFFER, targetid);
 }
 
-ScopedResolvedFrameBufferBinder::~ScopedResolvedFrameBufferBinder() {
+ScopedResolvedFramebufferBinder::~ScopedResolvedFramebufferBinder() {
   if (!resolve_and_bind_)
     return;
 
   ScopedGLErrorSuppressor suppressor(
-      "ScopedResolvedFrameBufferBinder::dtor", decoder_->GetErrorState());
+      "ScopedResolvedFramebufferBinder::dtor", decoder_->GetErrorState());
   decoder_->RestoreCurrentFramebufferBindings();
   if (decoder_->state_.enable_flags.scissor_test) {
     decoder_->state_.SetDeviceCapabilityState(GL_SCISSOR_TEST, true);
   }
 }
 
 BackTexture::BackTexture(GLES2DecoderImpl* decoder)
     : memory_tracker_(decoder->memory_tracker()),
       bytes_allocated_(0),
       decoder_(decoder) {
@@ skipping 164 matching lines @@
 
   // Ignore the zero flag if the alpha channel needs to be cleared for RGB
   // emulation.
   bool needs_clear_for_rgb_emulation =
       !decoder_->offscreen_buffer_should_have_alpha_ &&
       decoder_->ChromiumImageNeedsRGBEmulation();
   if (zero || needs_clear_for_rgb_emulation) {
     GLuint fbo;
     glGenFramebuffersEXT(1, &fbo);
     {
-      ScopedFrameBufferBinder binder(decoder_, fbo);
+      ScopedFramebufferBinder binder(decoder_, fbo);
       glFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, Target(),
                                 id(), 0);
       glClearColor(0, 0, 0, decoder_->BackBufferAlphaClearColor());
       decoder_->state_.SetDeviceColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
       decoder_->state_.SetDeviceCapabilityState(GL_SCISSOR_TEST, false);
       glClear(GL_COLOR_BUFFER_BIT);
       decoder_->RestoreClearState();
     }
     glDeleteFramebuffersEXT(1, &fbo);
   }
@@ skipping 67 matching lines @@
                                                            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);
+      ScopedFramebufferBinder binder(decoder_, fbo);
       glFramebufferRenderbufferEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
                                    GL_RENDERBUFFER, id_);
       glClearColor(0, 0, 0, decoder_->BackBufferAlphaClearColor());
       decoder_->state_.SetDeviceColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
       decoder_->state_.SetDeviceCapabilityState(GL_SCISSOR_TEST, false);
       glClear(GL_COLOR_BUFFER_BIT);
       decoder_->RestoreClearState();
     }
     glDeleteFramebuffersEXT(1, &fbo);
   }
@@ skipping 40 matching lines @@
   ScopedGLErrorSuppressor suppressor("BackFramebuffer::Create",
                                      decoder_->GetErrorState());
   Destroy();
   glGenFramebuffersEXT(1, &id_);
 }
 
 void BackFramebuffer::AttachRenderTexture(BackTexture* texture) {
   DCHECK_NE(id_, 0u);
   ScopedGLErrorSuppressor suppressor(
       "BackFramebuffer::AttachRenderTexture", decoder_->GetErrorState());
-  ScopedFrameBufferBinder binder(decoder_, id_);
+  ScopedFramebufferBinder binder(decoder_, id_);
   GLuint attach_id = texture ? texture->id() : 0;
   glFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
                             texture->Target(), attach_id, 0);
 }
 
 void BackFramebuffer::AttachRenderBuffer(GLenum target,
                                          BackRenderbuffer* render_buffer) {
   DCHECK_NE(id_, 0u);
   ScopedGLErrorSuppressor suppressor(
       "BackFramebuffer::AttachRenderBuffer", decoder_->GetErrorState());
-  ScopedFrameBufferBinder binder(decoder_, id_);
+  ScopedFramebufferBinder binder(decoder_, id_);
   GLuint attach_id = render_buffer ? render_buffer->id() : 0;
   glFramebufferRenderbufferEXT(GL_FRAMEBUFFER,
                                target,
                                GL_RENDERBUFFER,
                                attach_id);
 }
 
 void BackFramebuffer::Destroy() {
   if (id_ != 0) {
     ScopedGLErrorSuppressor suppressor("BackFramebuffer::Destroy",
                                        decoder_->GetErrorState());
     glDeleteFramebuffersEXT(1, &id_);
     id_ = 0;
   }
 }
 
 void BackFramebuffer::Invalidate() {
   id_ = 0;
 }
 
 GLenum BackFramebuffer::CheckStatus() {
   DCHECK_NE(id_, 0u);
   ScopedGLErrorSuppressor suppressor("BackFramebuffer::CheckStatus",
                                      decoder_->GetErrorState());
-  ScopedFrameBufferBinder binder(decoder_, id_);
+  ScopedFramebufferBinder binder(decoder_, id_);
   return glCheckFramebufferStatusEXT(GL_FRAMEBUFFER);
 }
 
 GLES2Decoder* GLES2Decoder::Create(ContextGroup* group) {
   if (group->gpu_preferences().use_passthrough_cmd_decoder) {
     return new GLES2DecoderPassthroughImpl(group);
   }
   return new GLES2DecoderImpl(group);
 }
 
@@ skipping 367 matching lines @@
       // If we're an offscreen surface with zero width and/or height, set to a
       // non-zero size so that we have a complete framebuffer for operations
       // like glClear.
       // TODO(piman): allow empty framebuffers, similar to
       // EGL_KHR_surfaceless_context / GL_OES_surfaceless_context.
       initial_size = gfx::Size(1, 1);
     }
 
     // Allocate the render buffers at their initial size and check the status
     // of the frame buffers is okay.
-    if (!ResizeOffscreenFrameBuffer(initial_size)) {
+    if (!ResizeOffscreenFramebuffer(initial_size)) {
       LOG(ERROR) << "Could not allocate offscreen buffer storage.";
       Destroy(true);
       return false;
     }
 
     state_.viewport_width = initial_size.width();
     state_.viewport_height = initial_size.height();
 
     // Allocate the offscreen saved color texture.
     DCHECK(offscreen_saved_color_format_);
@@ skipping 982 matching lines @@
       framebuffer_state_.bound_draw_framebuffer.get();
   if (!framebuffer)
     return false;
   const Framebuffer::Attachment* attachment =
       framebuffer->GetReadBufferAttachment();
   if (!attachment)
     return false;
   return attachment->FormsFeedbackLoop(texture, level, layer);
 }
 
-gfx::Size GLES2DecoderImpl::GetBoundReadFrameBufferSize() {
+gfx::Size GLES2DecoderImpl::GetBoundReadFramebufferSize() {
   Framebuffer* framebuffer =
       GetFramebufferInfoForTarget(GL_READ_FRAMEBUFFER_EXT);
   if (framebuffer != NULL) {
     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() {
+GLuint GLES2DecoderImpl::GetBoundReadFramebufferServiceId() {
   Framebuffer* framebuffer =
     GetFramebufferInfoForTarget(GL_READ_FRAMEBUFFER_EXT);
   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 surface_->GetBackingFramebufferObject();
   }
   return 0;
 }
 
-GLenum GLES2DecoderImpl::GetBoundReadFrameBufferTextureType() {
+GLenum GLES2DecoderImpl::GetBoundReadFramebufferTextureType() {
   Framebuffer* framebuffer =
     GetFramebufferInfoForTarget(GL_READ_FRAMEBUFFER_EXT);
   if (framebuffer) {
     return framebuffer->GetReadBufferTextureType();
   } else {  // Back buffer.
     if (back_buffer_read_buffer_ == GL_NONE)
       return 0;
     return GL_UNSIGNED_BYTE;
   }
 }
 
-GLenum GLES2DecoderImpl::GetBoundReadFrameBufferInternalFormat() {
+GLenum GLES2DecoderImpl::GetBoundReadFramebufferInternalFormat() {
   Framebuffer* framebuffer =
       GetFramebufferInfoForTarget(GL_READ_FRAMEBUFFER_EXT);
   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_;
     }
@@ skipping 35 matching lines @@
   }
   GLenum attachment = static_cast<GLenum>(GL_COLOR_ATTACHMENT0 + drawbuffer_i);
   const Framebuffer::Attachment* buffer =
       framebuffer->GetAttachment(attachment);
   if (!buffer) {
     return 0;
   }
   return buffer->internal_format();
 }
 
-GLsizei GLES2DecoderImpl::GetBoundFrameBufferSamples(GLenum target) {
+GLsizei GLES2DecoderImpl::GetBoundFramebufferSamples(GLenum target) {
   DCHECK(target == GL_DRAW_FRAMEBUFFER || target == GL_READ_FRAMEBUFFER ||
          target == GL_FRAMEBUFFER);
   Framebuffer* framebuffer = GetFramebufferInfoForTarget(target);
   if (framebuffer) {
     return framebuffer->GetSamples();
   } else {  // Back buffer.
     if (offscreen_target_frame_buffer_.get()) {
       return offscreen_target_samples_;
     }
     return 0;
   }
 }
 
-GLenum GLES2DecoderImpl::GetBoundFrameBufferDepthFormat(
+GLenum GLES2DecoderImpl::GetBoundFramebufferDepthFormat(
     GLenum target) {
   DCHECK(target == GL_DRAW_FRAMEBUFFER || target == GL_READ_FRAMEBUFFER ||
          target == GL_FRAMEBUFFER);
   Framebuffer* framebuffer = GetFramebufferInfoForTarget(target);
   if (framebuffer) {
     return framebuffer->GetDepthFormat();
   } else {  // Back buffer.
     if (offscreen_target_frame_buffer_.get()) {
       return offscreen_target_depth_format_;
     }
     if (back_buffer_has_depth_)
       return GL_DEPTH;
     return 0;
   }
 }
 
-GLenum GLES2DecoderImpl::GetBoundFrameBufferStencilFormat(
+GLenum GLES2DecoderImpl::GetBoundFramebufferStencilFormat(
     GLenum target) {
   DCHECK(target == GL_DRAW_FRAMEBUFFER || target == GL_READ_FRAMEBUFFER ||
          target == GL_FRAMEBUFFER);
   Framebuffer* framebuffer = GetFramebufferInfoForTarget(target);
   if (framebuffer) {
     return framebuffer->GetStencilFormat();
   } else {  // Back buffer.
     if (offscreen_target_frame_buffer_.get()) {
       return offscreen_target_stencil_format_;
     }
@@ skipping 378 matching lines @@
 }
 
 size_t GLES2DecoderImpl::GetSavedBackTextureCountForTest() {
   return saved_back_textures_.size();
 }
 
 size_t GLES2DecoderImpl::GetCreatedBackTextureCountForTest() {
   return create_back_texture_count_for_test_;
 }
 
-bool GLES2DecoderImpl::ResizeOffscreenFrameBuffer(const gfx::Size& size) {
+bool GLES2DecoderImpl::ResizeOffscreenFramebuffer(const gfx::Size& size) {
   bool is_offscreen = !!offscreen_target_frame_buffer_.get();
   if (!is_offscreen) {
-    LOG(ERROR) << "GLES2DecoderImpl::ResizeOffscreenFrameBuffer called "
+    LOG(ERROR) << "GLES2DecoderImpl::ResizeOffscreenFramebuffer called "
                << " with an onscreen framebuffer.";
     return false;
   }
 
   if (offscreen_size_ == size)
     return true;
 
   offscreen_size_ = size;
   int w = offscreen_size_.width();
   int h = offscreen_size_.height();
   if (w < 0 || h < 0 || h >= (INT_MAX / 4) / (w ? w : 1)) {
-    LOG(ERROR) << "GLES2DecoderImpl::ResizeOffscreenFrameBuffer failed "
+    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(
             feature_info_.get(), offscreen_size_,
             offscreen_target_color_format_, offscreen_target_samples_)) {
-      LOG(ERROR) << "GLES2DecoderImpl::ResizeOffscreenFrameBuffer failed "
+      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 "
+      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(
           feature_info_.get(),
           offscreen_size_,
           offscreen_target_depth_format_,
           offscreen_target_samples_)) {
-    LOG(ERROR) << "GLES2DecoderImpl::ResizeOffscreenFrameBuffer failed "
+    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(
           feature_info_.get(),
           offscreen_size_,
           offscreen_target_stencil_format_,
           offscreen_target_samples_)) {
-    LOG(ERROR) << "GLES2DecoderImpl::ResizeOffscreenFrameBuffer failed "
+    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,
         offscreen_target_color_render_buffer_.get());
   } else {
@@ skipping 12 matching lines @@
         GL_STENCIL_ATTACHMENT,
         offscreen_target_depth_render_buffer_.get());
   } else if (offscreen_target_stencil_format_) {
     offscreen_target_frame_buffer_->AttachRenderBuffer(
         GL_STENCIL_ATTACHMENT,
         offscreen_target_stencil_render_buffer_.get());
   }
 
   if (offscreen_target_frame_buffer_->CheckStatus() !=
       GL_FRAMEBUFFER_COMPLETE) {
-      LOG(ERROR) << "GLES2DecoderImpl::ResizeOffscreenFrameBuffer failed "
+      LOG(ERROR) << "GLES2DecoderImpl::ResizeOffscreenFramebuffer failed "
                  << "because offscreen FBO was incomplete.";
     return false;
   }
 
   // Clear the target frame buffer.
   {
-    ScopedFrameBufferBinder binder(this, offscreen_target_frame_buffer_->id());
+    ScopedFramebufferBinder binder(this, offscreen_target_frame_buffer_->id());
     glClearColor(0, 0, 0, BackBufferAlphaClearColor());
     state_.SetDeviceColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
     glClearStencil(0);
     state_.SetDeviceStencilMaskSeparate(GL_FRONT, kDefaultStencilMask);
     state_.SetDeviceStencilMaskSeparate(GL_BACK, kDefaultStencilMask);
     glClearDepth(0);
     state_.SetDeviceDepthMask(GL_TRUE);
     state_.SetDeviceCapabilityState(GL_SCISSOR_TEST, false);
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
     RestoreClearState();
@@ skipping 27 matching lines @@
   width = std::max(1U, width);
   height = std::max(1U, height);
 
 #if defined(OS_POSIX) && !defined(OS_MACOSX) && \
     !defined(UI_COMPOSITOR_IMAGE_TRANSPORT)
   // Make sure that we are done drawing to the back buffer before resizing.
   glFinish();
 #endif
   bool is_offscreen = !!offscreen_target_frame_buffer_.get();
   if (is_offscreen) {
-    if (!ResizeOffscreenFrameBuffer(gfx::Size(width, height))) {
+    if (!ResizeOffscreenFramebuffer(gfx::Size(width, height))) {
       LOG(ERROR) << "GLES2DecoderImpl: Context lost because "
-                 << "ResizeOffscreenFrameBuffer failed.";
+                 << "ResizeOffscreenFramebuffer failed.";
       return error::kLostContext;
     }
   } else {
     if (!surface_->Resize(gfx::Size(width, height), scale_factor,
                           !!has_alpha)) {
       LOG(ERROR) << "GLES2DecoderImpl: Context lost because resize failed.";
       return error::kLostContext;
     }
     DCHECK(context_->IsCurrent(surface_.get()));
     if (!context_->IsCurrent(surface_.get())) {
@@ skipping 381 matching lines @@
         GL_DEPTH_TEST, state_.enable_flags.depth_test && have_depth);
     state_.SetDeviceCapabilityState(
         GL_STENCIL_TEST, state_.enable_flags.stencil_test && have_stencil);
     framebuffer_state_.clear_state_dirty = false;
   }
 }
 
 GLuint GLES2DecoderImpl::GetBackbufferServiceId() const {
   return (offscreen_target_frame_buffer_.get())
              ? offscreen_target_frame_buffer_->id()
-             : (surface_.get() ? surface_->GetBackingFrameBufferObject() : 0);
+             : (surface_.get() ? surface_->GetBackingFramebufferObject() : 0);
 }
 
 void GLES2DecoderImpl::RestoreState(const ContextState* prev_state) {
   TRACE_EVENT1("gpu", "GLES2DecoderImpl::RestoreState",
                "context", logger_.GetLogPrefix());
   // Restore the Framebuffer first because of bugs in Intel drivers.
   // Intel drivers incorrectly clip the viewport settings to
   // the size of the current framebuffer object.
   RestoreFramebufferBindings();
   state_.RestoreState(prev_state);
@@ skipping 647 matching lines @@
         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 (pname == GL_IMPLEMENTATION_COLOR_READ_FORMAT) {
             *params = GLES2Util::GetGLReadPixelsImplementationFormat(
-                GetBoundReadFrameBufferInternalFormat(),
-                GetBoundReadFrameBufferTextureType(),
+                GetBoundReadFramebufferInternalFormat(),
+                GetBoundReadFramebufferTextureType(),
                 feature_info_->feature_flags().ext_read_format_bgra);
           } else {
             *params = GLES2Util::GetGLReadPixelsImplementationType(
-                GetBoundReadFrameBufferInternalFormat(),
-                GetBoundReadFrameBufferTextureType());
+                GetBoundReadFramebufferInternalFormat(),
+                GetBoundReadFramebufferTextureType());
           }
         }
         if (*params == GL_HALF_FLOAT && feature_info_->IsWebGL1OrES2Context()) {
           *params = GL_HALF_FLOAT_OES;
         }
         if (*params == GL_SRGB_ALPHA_EXT) {
           *params = GL_RGBA;
         }
         if (*params == GL_SRGB_EXT) {
           *params = GL_RGB;
@@ skipping 879 matching lines @@
   if (CheckBoundDrawFramebufferValid(func_name)) {
     ApplyDirtyState();
     if (workarounds().gl_clear_broken) {
       ScopedGLErrorSuppressor suppressor("GLES2DecoderImpl::ClearWorkaround",
                                          GetErrorState());
       if (!BoundFramebufferHasDepthAttachment())
         mask &= ~GL_DEPTH_BUFFER_BIT;
       if (!BoundFramebufferHasStencilAttachment())
         mask &= ~GL_STENCIL_BUFFER_BIT;
       clear_framebuffer_blit_->ClearFramebuffer(
-          this, GetBoundReadFrameBufferSize(), mask, state_.color_clear_red,
+          this, GetBoundReadFramebufferSize(), mask, state_.color_clear_red,
           state_.color_clear_green, state_.color_clear_blue,
           state_.color_clear_alpha, state_.depth_clear, state_.stencil_clear);
       return error::kNoError;
     }
     if (mask & GL_COLOR_BUFFER_BIT) {
       Framebuffer* framebuffer =
           framebuffer_state_.bound_draw_framebuffer.get();
       if (framebuffer && framebuffer->ContainsActiveIntegerAttachments()) {
         LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, func_name,
             "can't be called on integer buffers");
@@ skipping 259 matching lines @@
         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_.SetDeviceCapabilityState(GL_SCISSOR_TEST, false);
     if (workarounds().gl_clear_broken) {
       ScopedGLErrorSuppressor suppressor("GLES2DecoderImpl::ClearWorkaround",
                                          GetErrorState());
       clear_framebuffer_blit_->ClearFramebuffer(
-          this, GetBoundReadFrameBufferSize(), clear_bits,
+          this, GetBoundReadFramebufferSize(), clear_bits,
           state_.color_clear_red, state_.color_clear_green,
           state_.color_clear_blue, state_.color_clear_alpha, state_.depth_clear,
           state_.stencil_clear);
     } else {
       glClear(clear_bits);
     }
   }
 
   if (cleared_int_renderbuffers || clear_bits) {
     if (reset_draw_buffers)
@@ skipping 292 matching lines @@
     GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
     GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
     GLbitfield mask, GLenum filter) {
   const char* func_name = "glBlitFramebufferCHROMIUM";
   DCHECK(!ShouldDeferReads() && !ShouldDeferDraws());
 
   if (!CheckBoundFramebufferValid(func_name)) {
     return;
   }
 
-  if (GetBoundFrameBufferSamples(GL_DRAW_FRAMEBUFFER) > 0) {
+  if (GetBoundFramebufferSamples(GL_DRAW_FRAMEBUFFER) > 0) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, func_name,
                        "destination framebuffer is multisampled");
     return;
   }
 
-  GLsizei read_buffer_samples = GetBoundFrameBufferSamples(GL_READ_FRAMEBUFFER);
+  GLsizei read_buffer_samples = GetBoundFramebufferSamples(GL_READ_FRAMEBUFFER);
   if (read_buffer_samples > 0 &&
       (srcX0 != dstX0 || srcY0 != dstY0 || srcX1 != dstX1 || srcY1 != dstY1)) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, func_name,
         "src framebuffer is multisampled, but src/dst regions are different");
     return;
   }
 
-  GLenum src_format = GetBoundReadFrameBufferInternalFormat();
-  GLenum src_type = GetBoundReadFrameBufferTextureType();
+  GLenum src_format = GetBoundReadFramebufferInternalFormat();
+  GLenum src_type = GetBoundReadFramebufferTextureType();
 
   if ((mask & GL_COLOR_BUFFER_BIT) != 0) {
     bool is_src_signed_int = GLES2Util::IsSignedIntegerFormat(src_format);
     bool is_src_unsigned_int = GLES2Util::IsUnsignedIntegerFormat(src_format);
     DCHECK(!is_src_signed_int || !is_src_unsigned_int);
 
     if ((is_src_signed_int || is_src_unsigned_int) && filter == GL_LINEAR) {
       LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, func_name,
                          "invalid filter for integer format");
       return;
@@ skipping 26 matching lines @@
     }
   }
 
   if ((mask & (GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT)) != 0) {
     if (filter != GL_NEAREST) {
       LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, func_name,
                          "invalid filter for depth/stencil");
       return;
     }
 
-    if ((GetBoundFrameBufferDepthFormat(GL_READ_FRAMEBUFFER) !=
-         GetBoundFrameBufferDepthFormat(GL_DRAW_FRAMEBUFFER)) ||
-        (GetBoundFrameBufferStencilFormat(GL_READ_FRAMEBUFFER) !=
-         GetBoundFrameBufferStencilFormat(GL_DRAW_FRAMEBUFFER))) {
+    if ((GetBoundFramebufferDepthFormat(GL_READ_FRAMEBUFFER) !=
+         GetBoundFramebufferDepthFormat(GL_DRAW_FRAMEBUFFER)) ||
+        (GetBoundFramebufferStencilFormat(GL_READ_FRAMEBUFFER) !=
+         GetBoundFramebufferStencilFormat(GL_DRAW_FRAMEBUFFER))) {
       LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, func_name,
                          "src and dst formats differ for depth/stencil");
       return;
     }
   }
 
   state_.SetDeviceCapabilityState(GL_SCISSOR_TEST, false);
   BlitFramebufferHelper(
       srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
   state_.SetDeviceCapabilityState(GL_SCISSOR_TEST,
@@ skipping 2962 matching lines @@
   }
   if (!validators_->read_pixel_type.IsValid(type)) {
     LOCAL_SET_GL_ERROR_INVALID_ENUM("glReadPixels", type, "type");
     return error::kNoError;
   }
 
   if (!CheckBoundReadFramebufferValid("glReadPixels",
                                       GL_INVALID_FRAMEBUFFER_OPERATION)) {
     return error::kNoError;
   }
-  GLenum src_internal_format = GetBoundReadFrameBufferInternalFormat();
+  GLenum src_internal_format = GetBoundReadFramebufferInternalFormat();
   if (src_internal_format == 0) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glReadPixels",
         "no valid color image");
     return error::kNoError;
   }
   std::vector<GLenum> accepted_formats;
   std::vector<GLenum> accepted_types;
   switch (src_internal_format) {
     case GL_R8UI:
     case GL_R16UI:
@@ skipping 24 matching lines @@
     case GL_RGB10_A2:
       accepted_formats.push_back(GL_RGBA);
       accepted_types.push_back(GL_UNSIGNED_BYTE);
       // Special case with an extra supported format/type.
       accepted_formats.push_back(GL_RGBA);
       accepted_types.push_back(GL_UNSIGNED_INT_2_10_10_10_REV);
       break;
     default:
       accepted_formats.push_back(GL_RGBA);
       {
-        GLenum src_type = GetBoundReadFrameBufferTextureType();
+        GLenum src_type = GetBoundReadFramebufferTextureType();
         switch (src_type) {
           case GL_HALF_FLOAT:
           case GL_HALF_FLOAT_OES:
           case GL_FLOAT:
           case GL_UNSIGNED_INT_10F_11F_11F_REV:
             accepted_types.push_back(GL_FLOAT);
             break;
           default:
             accepted_types.push_back(GL_UNSIGNED_BYTE);
             break;
@@ skipping 31 matching lines @@
     return error::kNoError;
   }
   if (type == GL_HALF_FLOAT_OES && !gl_version_info().is_es2) {
     type = GL_HALF_FLOAT;
   }
   if (width == 0 || height == 0) {
     return error::kNoError;
   }
 
   // Get the size of the current fbo or backbuffer.
-  gfx::Size max_size = GetBoundReadFrameBufferSize();
+  gfx::Size max_size = GetBoundReadFramebufferSize();
 
   int32_t max_x;
   int32_t max_y;
   if (!SafeAddInt32(x, width, &max_x) || !SafeAddInt32(y, height, &max_y)) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE, "glReadPixels", "dimensions out of range");
     return error::kNoError;
   }
 
   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("glReadPixels");
 
-  ScopedResolvedFrameBufferBinder binder(this, false, true);
-  GLenum read_format = GetBoundReadFrameBufferInternalFormat();
+  ScopedResolvedFramebufferBinder binder(this, false, true);
+  GLenum read_format = GetBoundReadFramebufferInternalFormat();
 
   gfx::Rect rect(x, y, width, height);  // Safe before we checked above.
   gfx::Rect max_rect(max_size);
   if (!max_rect.Contains(rect)) {
     rect.Intersect(max_rect);
     if (!rect.IsEmpty()) {
       if (y < 0) {
         pixels += static_cast<uint32_t>(-y) * padded_row_size;;
       }
       if (x < 0) {
@@ skipping 196 matching lines @@
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         "glPostSubBufferCHROMIUM", "command not supported by surface");
     return error::kNoError;
   }
   bool is_tracing;
   TRACE_EVENT_CATEGORY_GROUP_ENABLED(TRACE_DISABLED_BY_DEFAULT("gpu.debug"),
                                      &is_tracing);
   if (is_tracing) {
     bool is_offscreen = !!offscreen_target_frame_buffer_.get();
-    ScopedFrameBufferBinder binder(this, GetBackbufferServiceId());
+    ScopedFramebufferBinder binder(this, GetBackbufferServiceId());
     gpu_state_tracer_->TakeSnapshotWithCurrentFramebuffer(
         is_offscreen ? offscreen_size_ : surface_->GetSize());
   }
 
   ClearScheduleCALayerState();
 
   if (supports_async_swap_) {
     TRACE_EVENT_ASYNC_BEGIN0("cc", "GLES2DecoderImpl::AsyncSwapBuffers", this);
     surface_->PostSubBufferAsync(
         c.x, c.y, c.width, c.height,
@@ skipping 2042 matching lines @@
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE, func_name, "dimensions out of range");
     return;
   }
 
   if (!CheckBoundReadFramebufferValid(func_name,
                                       GL_INVALID_FRAMEBUFFER_OPERATION)) {
     return;
   }
 
-  GLenum read_format = GetBoundReadFrameBufferInternalFormat();
-  GLenum read_type = GetBoundReadFrameBufferTextureType();
+  GLenum read_format = GetBoundReadFramebufferInternalFormat();
+  GLenum read_type = GetBoundReadFramebufferTextureType();
   if (!ValidateCopyTexFormat(func_name, internal_format,
                              read_format, read_type)) {
     return;
   }
 
   uint32_t pixels_size = 0;
   // TODO(piman): OpenGL ES 3.0.4 Section 3.8.5 specifies how to pick an
   // effective internal format if internal_format is unsized, which is a fairly
   // involved logic. For now, just make sure we pick something valid.
   GLenum format =
@@ skipping 23 matching lines @@
   }
 
   if (FormsTextureCopyingFeedbackLoop(texture_ref, level, 0)) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         func_name, "source and destination textures are the same");
     return;
   }
 
   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER(func_name);
-  ScopedResolvedFrameBufferBinder binder(this, false, true);
-  gfx::Size size = GetBoundReadFrameBufferSize();
+  ScopedResolvedFramebufferBinder binder(this, false, true);
+  gfx::Size size = GetBoundReadFramebufferSize();
 
   if (texture->IsAttachedToFramebuffer()) {
     framebuffer_state_.clear_state_dirty = true;
   }
 
   bool requires_luma_blit =
       CopyTexImageResourceManager::CopyTexImageRequiresBlit(feature_info_.get(),
                                                             format);
   if (requires_luma_blit &&
       !InitializeCopyTexImageBlitter(func_name)) {
@@ skipping 20 matching lines @@
                  width, height, border, format, type, zero.get());
     if (copyHeight > 0 && copyWidth > 0) {
       GLint dx = copyX - x;
       GLint dy = copyY - y;
       GLint destX = dx;
       GLint destY = dy;
       if (requires_luma_blit) {
         copy_tex_image_blit_->DoCopyTexSubImageToLUMACompatibilityTexture(
             this, texture->service_id(), texture->target(), target, format,
             type, level, destX, destY, 0, copyX, copyY, copyWidth, copyHeight,
-            GetBoundReadFrameBufferServiceId(),
-            GetBoundReadFrameBufferInternalFormat());
+            GetBoundReadFramebufferServiceId(),
+            GetBoundReadFramebufferInternalFormat());
       } else {
         glCopyTexSubImage2D(target, level, destX, destY, copyX, copyY,
                             copyWidth, copyHeight);
       }
     }
   } else {
     GLenum final_internal_format = TextureManager::AdjustTexInternalFormat(
         feature_info_.get(), 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;
     uint32_t channels_exist = GLES2Util::GetChannelsForFormat(read_format);
     bool use_workaround = NeedsCopyTextureImageWorkaround(
         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, copyX, copyY, copyWidth, copyHeight,
-          GetBoundReadFrameBufferServiceId(),
-          GetBoundReadFrameBufferInternalFormat());
+          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 temp_internal_format = 0;
       if (channels_exist == GLES2Util::kRGBA) {
         temp_internal_format = GL_RGBA;
       } else if (channels_exist == GLES2Util::kRGB) {
@@ skipping 71 matching lines @@
           target, level, xoffset, yoffset, 0, width, height, 1)) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, func_name, "bad dimensions.");
     return;
   }
 
   if (!CheckBoundReadFramebufferValid(func_name,
                                       GL_INVALID_FRAMEBUFFER_OPERATION)) {
     return;
   }
 
-  GLenum read_format = GetBoundReadFrameBufferInternalFormat();
-  GLenum read_type = GetBoundReadFrameBufferTextureType();
+  GLenum read_format = GetBoundReadFramebufferInternalFormat();
+  GLenum read_type = GetBoundReadFramebufferTextureType();
   if (!ValidateCopyTexFormat(func_name, internal_format,
                              read_format, read_type)) {
     return;
   }
 
   if (FormsTextureCopyingFeedbackLoop(texture_ref, level, 0)) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         func_name, "source and destination textures are the same");
     return;
   }
 
-  ScopedResolvedFrameBufferBinder binder(this, false, true);
-  gfx::Size size = GetBoundReadFrameBufferSize();
+  ScopedResolvedFramebufferBinder binder(this, false, true);
+  gfx::Size size = GetBoundReadFramebufferSize();
   GLint copyX = 0;
   GLint copyY = 0;
   GLint copyWidth = 0;
   GLint copyHeight = 0;
   Clip(x, width, size.width(), &copyX, &copyWidth);
   Clip(y, height, size.height(), &copyY, &copyHeight);
 
   GLint dx = copyX - x;
   GLint dy = copyY - y;
   GLint destX = xoffset + dx;
@@ skipping 24 matching lines @@
   if (copyHeight > 0 && copyWidth > 0) {
     if (CopyTexImageResourceManager::CopyTexImageRequiresBlit(
             feature_info_.get(), internal_format)) {
       if (!InitializeCopyTexImageBlitter("glCopyTexSubImage2D")) {
         return;
       }
       copy_tex_image_blit_->DoCopyTexSubImageToLUMACompatibilityTexture(
           this, texture->service_id(), texture->target(), target,
           internal_format, type, level, destX, destY, 0,
           copyX, copyY, copyWidth, copyHeight,
-          GetBoundReadFrameBufferServiceId(),
-          GetBoundReadFrameBufferInternalFormat());
+          GetBoundReadFramebufferServiceId(),
+          GetBoundReadFramebufferInternalFormat());
     } else {
       glCopyTexSubImage2D(target, level, destX, destY, copyX, copyY, copyWidth,
                           copyHeight);
     }
   }
 
   // This may be a slow command.  Exit command processing to allow for
   // context preemption and GPU watchdog checks.
   ExitCommandProcessingEarly();
 }
@@ skipping 25 matching lines @@
           target, level, xoffset, yoffset, zoffset, width, height, 1)) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, func_name, "bad dimensions.");
     return;
   }
 
   if (!CheckBoundReadFramebufferValid(func_name,
                                       GL_INVALID_FRAMEBUFFER_OPERATION)) {
     return;
   }
 
-  GLenum read_format = GetBoundReadFrameBufferInternalFormat();
-  GLenum read_type = GetBoundReadFrameBufferTextureType();
+  GLenum read_format = GetBoundReadFramebufferInternalFormat();
+  GLenum read_type = GetBoundReadFramebufferTextureType();
   if (!ValidateCopyTexFormat(func_name, internal_format,
                              read_format, read_type)) {
     return;
   }
 
   if (FormsTextureCopyingFeedbackLoop(texture_ref, level, zoffset)) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         func_name, "source and destination textures are the same");
     return;
   }
 
-  ScopedResolvedFrameBufferBinder binder(this, false, true);
-  gfx::Size size = GetBoundReadFrameBufferSize();
+  ScopedResolvedFramebufferBinder binder(this, false, true);
+  gfx::Size size = GetBoundReadFramebufferSize();
   GLint copyX = 0;
   GLint copyY = 0;
   GLint copyWidth = 0;
   GLint copyHeight = 0;
   Clip(x, width, size.width(), &copyX, &copyWidth);
   Clip(y, height, size.height(), &copyY, &copyHeight);
 
   GLint dx = copyX - x;
   GLint dy = copyY - y;
   GLint destX = xoffset + dx;
@@ skipping 13 matching lines @@
   if (copyHeight > 0 && copyWidth > 0) {
     if (CopyTexImageResourceManager::CopyTexImageRequiresBlit(
             feature_info_.get(), internal_format)) {
       if (!InitializeCopyTexImageBlitter(func_name)) {
         return;
       }
       copy_tex_image_blit_->DoCopyTexSubImageToLUMACompatibilityTexture(
           this, texture->service_id(), texture->target(), target,
           internal_format, type, level, destX, destY, zoffset,
           copyX, copyY, copyWidth, copyHeight,
-          GetBoundReadFrameBufferServiceId(),
-          GetBoundReadFrameBufferInternalFormat());
+          GetBoundReadFramebufferServiceId(),
+          GetBoundReadFramebufferInternalFormat());
     } else {
       glCopyTexSubImage3D(target, level, destX, destY, zoffset,
                           copyX, copyY, copyWidth, copyHeight);
     }
   }
 
   // This may be a slow command.  Exit command processing to allow for
   // context preemption and GPU watchdog checks.
   ExitCommandProcessingEarly();
 }
@@ skipping 718 matching lines @@
     TRACE_EVENT_SYNTHETIC_DELAY("gpu.PresentingFrame");
   }
 
   ScopedGPUTrace scoped_gpu_trace(gpu_tracer_.get(), kTraceDecoder,
                                   "GLES2Decoder", "SwapBuffer");
 
   bool is_tracing;
   TRACE_EVENT_CATEGORY_GROUP_ENABLED(TRACE_DISABLED_BY_DEFAULT("gpu.debug"),
                                      &is_tracing);
   if (is_tracing) {
-    ScopedFrameBufferBinder binder(this, GetBackbufferServiceId());
+    ScopedFramebufferBinder binder(this, GetBackbufferServiceId());
     gpu_state_tracer_->TakeSnapshotWithCurrentFramebuffer(
         is_offscreen ? offscreen_size_ : surface_->GetSize());
   }
 
   ClearScheduleCALayerState();
 
   // If offscreen then don't actually SwapBuffers to the display. Just copy
   // the rendered frame to another frame buffer.
   if (is_offscreen) {
     TRACE_EVENT2("gpu", "Offscreen",
@@ skipping 14 matching lines @@
       // Allocate the offscreen saved color texture.
       DCHECK(offscreen_saved_color_format_);
       offscreen_saved_color_texture_->AllocateStorage(
           offscreen_size_, offscreen_saved_color_format_, false);
 
       offscreen_saved_frame_buffer_->AttachRenderTexture(
           offscreen_saved_color_texture_.get());
       if (offscreen_size_.width() != 0 && offscreen_size_.height() != 0) {
         if (offscreen_saved_frame_buffer_->CheckStatus() !=
             GL_FRAMEBUFFER_COMPLETE) {
-          LOG(ERROR) << "GLES2DecoderImpl::ResizeOffscreenFrameBuffer failed "
+          LOG(ERROR) << "GLES2DecoderImpl::ResizeOffscreenFramebuffer failed "
                      << "because offscreen saved FBO was incomplete.";
           MarkContextLost(error::kUnknown);
           group_->LoseContexts(error::kUnknown);
           return;
         }
 
         // Clear the offscreen color texture.
         // TODO(piman): Is this still necessary?
         {
-          ScopedFrameBufferBinder binder(this,
+          ScopedFramebufferBinder binder(this,
                                          offscreen_saved_frame_buffer_->id());
           glClearColor(0, 0, 0, BackBufferAlphaClearColor());
           state_.SetDeviceColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
           state_.SetDeviceCapabilityState(GL_SCISSOR_TEST, false);
           glClear(GL_COLOR_BUFFER_BIT);
           RestoreClearState();
         }
       }
     }
 
     if (offscreen_size_.width() == 0 || offscreen_size_.height() == 0)
       return;
     ScopedGLErrorSuppressor suppressor(
         "GLES2DecoderImpl::DoSwapBuffers", GetErrorState());
 
     if (IsOffscreenBufferMultisampled()) {
       // For multisampled buffers, resolve the frame buffer.
-      ScopedResolvedFrameBufferBinder binder(this, true, false);
+      ScopedResolvedFramebufferBinder binder(this, true, false);
     } else {
-      ScopedFrameBufferBinder binder(this,
+      ScopedFramebufferBinder binder(this,
                                      offscreen_target_frame_buffer_->id());
 
       if (offscreen_target_buffer_preserved_) {
         // Copy the target frame buffer to the saved offscreen texture.
         offscreen_saved_color_texture_->Copy();
       } else {
         offscreen_saved_color_texture_.swap(offscreen_target_color_texture_);
         offscreen_target_frame_buffer_->AttachRenderTexture(
             offscreen_target_color_texture_.get());
         offscreen_saved_frame_buffer_->AttachRenderTexture(
@@ skipping 3603 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