command_buffer: Defer restoring of FBO bindings when changing virtual contexts

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 603 matching lines @@
   void RestoreBufferBindings() const override {
     state_.RestoreBufferBindings();
   }
   void RestoreGlobalState() const override { state_.RestoreGlobalState(NULL); }
   void RestoreProgramBindings() const override {
     state_.RestoreProgramBindings();
   }
   void RestoreTextureUnitBindings(unsigned unit) const override {
     state_.RestoreTextureUnitBindings(unit, NULL);
   }
-  void RestoreFramebufferBindings() const override;
+  void MarkFramebufferBindingsChanged() override;
   void RestoreRenderbufferBindings() override;
   void RestoreTextureState(unsigned service_id) const override;
 
   void ClearAllAttributes() const override;
   void RestoreAllAttributes() const override;
 
   QueryManager* GetQueryManager() override { return query_manager_.get(); }
   VertexArrayManager* GetVertexArrayManager() override {
     return vertex_array_manager_.get();
   }
@@ skipping 26 matching lines @@
   void ProcessFinishedAsyncTransfers();
 
   bool GetServiceTextureId(uint32_t client_texture_id,
                            uint32_t* service_texture_id) override;
 
   uint32_t GetTextureUploadCount() override;
   base::TimeDelta GetTotalTextureUploadTime() override;
   base::TimeDelta GetTotalProcessingCommandsTime() override;
   void AddProcessingCommandsTime(base::TimeDelta) override;
 
-  // Restores the current state to the user's settings.
-  void RestoreCurrentFramebufferBindings();
-
   // Sets DEPTH_TEST, STENCIL_TEST and color mask for the current framebuffer.
   void ApplyDirtyState();
 
   // These check the state of the currently bound framebuffer or the
   // backbuffer if no framebuffer is bound.
   // Check with all attached and enabled color attachments.
   bool BoundFramebufferHasColorAttachmentWithAlpha();
   bool BoundFramebufferHasDepthAttachment();
   bool BoundFramebufferHasStencilAttachment();
 
@@ skipping 61 matching lines @@
   void DeleteRenderbuffersHelper(GLsizei n, const GLuint* client_ids);
   bool GenQueriesEXTHelper(GLsizei n, const GLuint* client_ids);
   void DeleteQueriesEXTHelper(GLsizei n, const GLuint* client_ids);
   bool GenVertexArraysOESHelper(GLsizei n, const GLuint* client_ids);
   void DeleteVertexArraysOESHelper(GLsizei n, const GLuint* client_ids);
   bool GenPathsCHROMIUMHelper(GLuint first_client_id, GLsizei range);
   bool DeletePathsCHROMIUMHelper(GLuint first_client_id, GLsizei range);
   bool GenSamplersHelper(GLsizei n, const GLuint* client_ids);
   void DeleteSamplersHelper(GLsizei n, const GLuint* client_ids);
 
-  // Workarounds
-  void OnFboChanged() const;
-  void OnUseFramebuffer() const;
+  void ApplyFramebufferBindings(GLenum target);
+  void OnUseFramebuffer();
 
   error::ContextLostReason GetContextLostReasonFromResetStatus(
       GLenum reset_status) const;
 
   // TODO(gman): Cache these pointers?
   BufferManager* buffer_manager() {
     return group_->buffer_manager();
   }
 
   RenderbufferManager* renderbuffer_manager() {
@@ skipping 983 matching lines @@
     NOTREACHED();
     return 0;
   }
 
   // Gets the framebuffer info for a particular target.
   Framebuffer* GetFramebufferInfoForTarget(GLenum target) {
     Framebuffer* framebuffer = NULL;
     switch (target) {
       case GL_FRAMEBUFFER:
       case GL_DRAW_FRAMEBUFFER_EXT:
-        framebuffer = framebuffer_state_.bound_draw_framebuffer.get();
+        framebuffer = framebuffer_state_.bound_draw_framebuffer();
         break;
       case GL_READ_FRAMEBUFFER_EXT:
-        framebuffer = framebuffer_state_.bound_read_framebuffer.get();
+        framebuffer = framebuffer_state_.bound_read_framebuffer();
         break;
       default:
         NOTREACHED();
         break;
     }
     return framebuffer;
   }
 
   Renderbuffer* GetRenderbufferInfoForTarget(
       GLenum target) {
@@ skipping 66 matching lines @@
   const FeatureInfo::FeatureFlags& features() const {
     return feature_info_->feature_flags();
   }
 
   const GpuDriverBugWorkarounds& workarounds() const {
     return feature_info_->workarounds();
   }
 
   bool ShouldDeferDraws() {
     return !offscreen_target_frame_buffer_.get() &&
-           framebuffer_state_.bound_draw_framebuffer.get() == NULL &&
+           !framebuffer_state_.bound_draw_framebuffer() &&
            surface_->DeferDraws();
   }
 
   bool ShouldDeferReads() {
     return !offscreen_target_frame_buffer_.get() &&
-           framebuffer_state_.bound_read_framebuffer.get() == NULL &&
+           !framebuffer_state_.bound_read_framebuffer() &&
            surface_->DeferDraws();
   }
 
   bool IsRobustnessSupported() {
     return has_robustness_extension_ &&
            context_->WasAllocatedUsingRobustnessExtension();
   }
 
   error::Error WillAccessBoundFramebufferForDraw() {
     if (ShouldDeferDraws())
       return error::kDeferCommandUntilLater;
     if (!offscreen_target_frame_buffer_.get() &&
-        !framebuffer_state_.bound_draw_framebuffer.get() &&
+        !framebuffer_state_.bound_draw_framebuffer() &&
         !surface_->SetBackbufferAllocation(true))
       return error::kLostContext;
     return error::kNoError;
   }
 
   error::Error WillAccessBoundFramebufferForRead() {
     if (ShouldDeferReads())
       return error::kDeferCommandUntilLater;
     if (!offscreen_target_frame_buffer_.get() &&
-        !framebuffer_state_.bound_read_framebuffer.get() &&
+        !framebuffer_state_.bound_read_framebuffer() &&
         !surface_->SetBackbufferAllocation(true))
       return error::kLostContext;
     return error::kNoError;
   }
 
   bool BackBufferHasAlpha() const {
     if (back_buffer_draw_buffer_ == GL_NONE)
       return false;
     if (offscreen_target_frame_buffer_.get()) {
       return (offscreen_target_color_format_ == GL_RGBA ||
@@ skipping 316 matching lines @@
       "ScopedRenderBufferBinder::dtor", state_->GetErrorState());
   state_->RestoreRenderbufferBindings();
 }
 
 ScopedFrameBufferBinder::ScopedFrameBufferBinder(GLES2DecoderImpl* decoder,
                                                  GLuint id)
     : decoder_(decoder) {
   ScopedGLErrorSuppressor suppressor(
       "ScopedFrameBufferBinder::ctor", decoder_->GetErrorState());
   glBindFramebufferEXT(GL_FRAMEBUFFER, id);
-  decoder->OnFboChanged();
+  decoder->framebuffer_state_.MarkBindingDirty(GL_FRAMEBUFFER);
 }
 
 ScopedFrameBufferBinder::~ScopedFrameBufferBinder() {
-  ScopedGLErrorSuppressor suppressor(
-      "ScopedFrameBufferBinder::dtor", decoder_->GetErrorState());
-  decoder_->RestoreCurrentFramebufferBindings();
 }
 
 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_)
+  resolve_and_bind_ =
+      (decoder_->offscreen_target_frame_buffer_.get() &&
+       decoder_->IsOffscreenBufferMultisampled() &&
+       (!decoder_->framebuffer_state_.bound_read_framebuffer() ||
+        enforce_internal_framebuffer));
+  if (!resolve_and_bind_) {
+    decoder_->ApplyFramebufferBindings(GL_READ_FRAMEBUFFER_EXT);
     return;
+  }
 
   ScopedGLErrorSuppressor suppressor(
       "ScopedResolvedFrameBufferBinder::ctor", decoder_->GetErrorState());
   glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT,
                        decoder_->offscreen_target_frame_buffer_->id());
+  decoder->framebuffer_state_.MarkBindingDirty(GL_READ_FRAMEBUFFER_EXT);
   GLuint targetid;
   if (internal) {
     if (!decoder_->offscreen_resolved_frame_buffer_.get()) {
       decoder_->offscreen_resolved_frame_buffer_.reset(
           new BackFramebuffer(decoder_));
       decoder_->offscreen_resolved_frame_buffer_->Create();
       decoder_->offscreen_resolved_color_texture_.reset(
           new BackTexture(decoder->memory_tracker(), &decoder->state_));
       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 "
                    << "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);
+  // Binding will be marked dirty below.
   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);
+  decoder->framebuffer_state_.MarkBindingDirty(GL_FRAMEBUFFER);
 }
 
 ScopedResolvedFrameBufferBinder::~ScopedResolvedFrameBufferBinder() {
   if (!resolve_and_bind_)
     return;
 
   ScopedGLErrorSuppressor suppressor(
       "ScopedResolvedFrameBufferBinder::dtor", decoder_->GetErrorState());
-  decoder_->RestoreCurrentFramebufferBindings();
   if (decoder_->state_.enable_flags.scissor_test) {
     decoder_->state_.SetDeviceCapabilityState(GL_SCISSOR_TEST, true);
   }
 }
 
 ScopedFrameBufferReadPixelHelper::ScopedFrameBufferReadPixelHelper(
     ContextState* state,
     GLES2DecoderImpl* decoder) {
   DCHECK_EQ(static_cast<unsigned>(GL_FRAMEBUFFER_COMPLETE),
             glCheckFramebufferStatusEXT(GL_FRAMEBUFFER));
@@ skipping 1220 matching lines @@
     if (buffer && !buffer->IsDeleted()) {
       buffer->RemoveMappedRange();
       state_.RemoveBoundBuffer(buffer);
       RemoveBuffer(client_ids[ii]);
     }
   }
 }
 
 void GLES2DecoderImpl::DeleteFramebuffersHelper(
     GLsizei n, const GLuint* client_ids) {
-  bool supports_separate_framebuffer_binds =
-     features().chromium_framebuffer_multisample;
-
+  GLenum target = features().chromium_framebuffer_multisample
+                      ? GL_DRAW_FRAMEBUFFER_EXT
+                      : GL_FRAMEBUFFER;
   for (GLsizei ii = 0; ii < n; ++ii) {
     Framebuffer* framebuffer =
         GetFramebuffer(client_ids[ii]);
     if (framebuffer && !framebuffer->IsDeleted()) {
-      if (framebuffer == framebuffer_state_.bound_draw_framebuffer.get()) {
-        GLenum target = supports_separate_framebuffer_binds ?
-            GL_DRAW_FRAMEBUFFER_EXT : GL_FRAMEBUFFER;
-
+      if (framebuffer == framebuffer_state_.bound_draw_framebuffer()) {
         // Unbind attachments on FBO before deletion.
-        if (workarounds().unbind_attachments_on_bound_render_fbo_delete)
+        if (workarounds().unbind_attachments_on_bound_render_fbo_delete) {
           framebuffer->DoUnbindGLAttachmentsForWorkaround(target);
-
-        glBindFramebufferEXT(target, GetBackbufferServiceId());
-        framebuffer_state_.bound_draw_framebuffer = NULL;
-        framebuffer_state_.clear_state_dirty = true;
+        }
+        framebuffer_state_.set_bound_draw_framebuffer(nullptr);
       }
-      if (framebuffer == framebuffer_state_.bound_read_framebuffer.get()) {
-        framebuffer_state_.bound_read_framebuffer = NULL;
-        GLenum target = supports_separate_framebuffer_binds ?
-            GL_READ_FRAMEBUFFER_EXT : GL_FRAMEBUFFER;
-        glBindFramebufferEXT(target, GetBackbufferServiceId());
-      }
-      OnFboChanged();
+      if (framebuffer == framebuffer_state_.bound_read_framebuffer())
+        framebuffer_state_.set_bound_read_framebuffer(nullptr);
       RemoveFramebuffer(client_ids[ii]);
     }
   }
 }
 
 void GLES2DecoderImpl::DeleteRenderbuffersHelper(
     GLsizei n, const GLuint* client_ids) {
   bool supports_separate_framebuffer_binds =
      features().chromium_framebuffer_multisample;
   for (GLsizei ii = 0; ii < n; ++ii) {
     Renderbuffer* renderbuffer =
         GetRenderbuffer(client_ids[ii]);
     if (renderbuffer && !renderbuffer->IsDeleted()) {
       if (state_.bound_renderbuffer.get() == renderbuffer) {
         state_.bound_renderbuffer = NULL;
       }
       // Unbind from current framebuffers.
       if (supports_separate_framebuffer_binds) {
-        if (framebuffer_state_.bound_read_framebuffer.get()) {
-          framebuffer_state_.bound_read_framebuffer
-              ->UnbindRenderbuffer(GL_READ_FRAMEBUFFER_EXT, renderbuffer);
+        if (framebuffer_state_.bound_read_framebuffer()) {
+          framebuffer_state_.bound_read_framebuffer()->UnbindRenderbuffer(
+              GL_READ_FRAMEBUFFER_EXT, renderbuffer);
         }
-        if (framebuffer_state_.bound_draw_framebuffer.get()) {
-          framebuffer_state_.bound_draw_framebuffer
-              ->UnbindRenderbuffer(GL_DRAW_FRAMEBUFFER_EXT, renderbuffer);
+        if (framebuffer_state_.bound_draw_framebuffer()) {
+          framebuffer_state_.bound_draw_framebuffer()->UnbindRenderbuffer(
+              GL_DRAW_FRAMEBUFFER_EXT, renderbuffer);
         }
       } else {
-        if (framebuffer_state_.bound_draw_framebuffer.get()) {
-          framebuffer_state_.bound_draw_framebuffer
-              ->UnbindRenderbuffer(GL_FRAMEBUFFER, renderbuffer);
+        if (framebuffer_state_.bound_draw_framebuffer()) {
+          framebuffer_state_.bound_draw_framebuffer()->UnbindRenderbuffer(
+              GL_FRAMEBUFFER, renderbuffer);
         }
       }
-      framebuffer_state_.clear_state_dirty = true;
+      framebuffer_state_.NotifyBoundFramebuffersChanged();
       RemoveRenderbuffer(client_ids[ii]);
     }
   }
 }
 
 void GLES2DecoderImpl::DeleteTexturesHelper(
     GLsizei n, const GLuint* client_ids) {
   bool supports_separate_framebuffer_binds =
      features().chromium_framebuffer_multisample;
   for (GLsizei ii = 0; ii < n; ++ii) {
     TextureRef* texture_ref = GetTexture(client_ids[ii]);
     if (texture_ref) {
       Texture* texture = texture_ref->texture();
       if (texture->IsAttachedToFramebuffer()) {
-        framebuffer_state_.clear_state_dirty = true;
+        framebuffer_state_.NotifyBoundFramebuffersChanged();
       }
       // Unbind texture_ref from texture_ref units.
       state_.UnbindTexture(texture_ref);
 
       // Unbind from current framebuffers.
       if (supports_separate_framebuffer_binds) {
-        if (framebuffer_state_.bound_read_framebuffer.get()) {
-          framebuffer_state_.bound_read_framebuffer
-              ->UnbindTexture(GL_READ_FRAMEBUFFER_EXT, texture_ref);
+        if (framebuffer_state_.bound_read_framebuffer()) {
+          framebuffer_state_.bound_read_framebuffer()->UnbindTexture(
+              GL_READ_FRAMEBUFFER_EXT, texture_ref);
         }
-        if (framebuffer_state_.bound_draw_framebuffer.get()) {
-          framebuffer_state_.bound_draw_framebuffer
-              ->UnbindTexture(GL_DRAW_FRAMEBUFFER_EXT, texture_ref);
+        if (framebuffer_state_.bound_draw_framebuffer()) {
+          framebuffer_state_.bound_draw_framebuffer()->UnbindTexture(
+              GL_DRAW_FRAMEBUFFER_EXT, texture_ref);
         }
       } else {
-        if (framebuffer_state_.bound_draw_framebuffer.get()) {
-          framebuffer_state_.bound_draw_framebuffer
-              ->UnbindTexture(GL_FRAMEBUFFER, texture_ref);
+        if (framebuffer_state_.bound_draw_framebuffer()) {
+          framebuffer_state_.bound_draw_framebuffer()->UnbindTexture(
+              GL_FRAMEBUFFER, texture_ref);
         }
       }
 #if defined(OS_MACOSX)
       GLuint service_id = texture->service_id();
       if (texture->target() == GL_TEXTURE_RECTANGLE_ARB) {
         ReleaseIOSurfaceForTexture(service_id);
       }
 #endif
       RemoveTexture(client_ids[ii]);
     }
@@ skipping 35 matching lines @@
     LOG(ERROR)
         << "  GLES2DecoderImpl: Context reset detected after MakeCurrent.";
     group_->LoseContexts(error::kUnknown);
     return false;
   }
 
   ProcessFinishedAsyncTransfers();
 
   // Rebind the FBO if it was unbound by the context.
   if (workarounds().unbind_fbo_on_context_switch)
-    RestoreFramebufferBindings();
+    MarkFramebufferBindingsChanged();
 
-  framebuffer_state_.clear_state_dirty = true;
+  framebuffer_state_.NotifyBoundFramebuffersChanged();
 
   // Rebind textures if the service ids may have changed.
   RestoreAllExternalTextureBindingsIfNeeded();
 
   return true;
 }
 
 void GLES2DecoderImpl::ProcessFinishedAsyncTransfers() {
   ProcessPendingReadPixels(false);
   if (engine() && query_manager_.get())
     query_manager_->ProcessPendingTransferQueries();
 }
 
-static void RebindCurrentFramebuffer(
-    GLenum target,
-    Framebuffer* framebuffer,
-    GLuint back_buffer_service_id) {
-  GLuint framebuffer_id = framebuffer ? framebuffer->service_id() : 0;
-
-  if (framebuffer_id == 0) {
-    framebuffer_id = back_buffer_service_id;
-  }
-
-  glBindFramebufferEXT(target, framebuffer_id);
-}
-
-void GLES2DecoderImpl::RestoreCurrentFramebufferBindings() {
-  framebuffer_state_.clear_state_dirty = true;
-
-  if (!features().chromium_framebuffer_multisample) {
-    RebindCurrentFramebuffer(
-        GL_FRAMEBUFFER,
-        framebuffer_state_.bound_draw_framebuffer.get(),
-        GetBackbufferServiceId());
-  } else {
-    RebindCurrentFramebuffer(
-        GL_READ_FRAMEBUFFER_EXT,
-        framebuffer_state_.bound_read_framebuffer.get(),
-        GetBackbufferServiceId());
-    RebindCurrentFramebuffer(
-        GL_DRAW_FRAMEBUFFER_EXT,
-        framebuffer_state_.bound_draw_framebuffer.get(),
-        GetBackbufferServiceId());
-  }
-  OnFboChanged();
-}
-
 bool GLES2DecoderImpl::CheckFramebufferValid(
     Framebuffer* framebuffer,
     GLenum target,
     bool clear_uncleared_images,
     const char* func_name) {
   if (!framebuffer) {
     if (surfaceless_)
       return false;
     if (backbuffer_needs_clear_bits_ && clear_uncleared_images) {
       glClearColor(0, 0, 0, BackBufferHasAlpha() ? 0 : 1.f);
@@ skipping 62 matching lines @@
     }
     framebuffer_manager()->MarkAsComplete(framebuffer);
   }
   return true;
 }
 
 bool GLES2DecoderImpl::CheckBoundDrawFramebufferValid(
     bool clear_uncleared_images, const char* func_name) {
   GLenum target = features().chromium_framebuffer_multisample ?
       GL_DRAW_FRAMEBUFFER : GL_FRAMEBUFFER;
+  ApplyFramebufferBindings(target);
   Framebuffer* framebuffer = GetFramebufferInfoForTarget(target);
   bool valid = CheckFramebufferValid(
       framebuffer, target, clear_uncleared_images, func_name);
   if (valid && !features().chromium_framebuffer_multisample)
     OnUseFramebuffer();
   return valid;
 }
 
 bool GLES2DecoderImpl::CheckBoundReadFramebufferValid(const char* func_name) {
   GLenum target = features().chromium_framebuffer_multisample ?
       GL_READ_FRAMEBUFFER : GL_FRAMEBUFFER;
+  ApplyFramebufferBindings(target);
   Framebuffer* framebuffer = GetFramebufferInfoForTarget(target);
   bool valid = CheckFramebufferValid(framebuffer, target, true, func_name);
   return valid;
 }
 
 GLint GLES2DecoderImpl::GetColorEncodingFromInternalFormat(
     GLenum internalformat) {
   switch (internalformat) {
     case GL_SRGB_EXT:
     case GL_SRGB_ALPHA_EXT:
     case GL_SRGB8:
     case GL_SRGB8_ALPHA8:
       return GL_SRGB;
     default:
       return GL_LINEAR;
   }
 }
 
 bool GLES2DecoderImpl::FormsTextureCopyingFeedbackLoop(
     TextureRef* texture, GLint level) {
-  Framebuffer* framebuffer = features().chromium_framebuffer_multisample ?
-      framebuffer_state_.bound_read_framebuffer.get() :
-      framebuffer_state_.bound_draw_framebuffer.get();
+  Framebuffer* framebuffer = features().chromium_framebuffer_multisample
+                                 ? framebuffer_state_.bound_read_framebuffer()
+                                 : framebuffer_state_.bound_draw_framebuffer();
   if (!framebuffer)
     return false;
   const Framebuffer::Attachment* attachment = framebuffer->GetAttachment(
       GL_COLOR_ATTACHMENT0);
   if (!attachment)
     return false;
   return attachment->FormsFeedbackLoop(texture, level);
 }
 
 gfx::Size GLES2DecoderImpl::GetBoundReadFrameBufferSize() {
@@ skipping 200 matching lines @@
   state_.default_vertex_attrib_manager = NULL;
   state_.texture_units.clear();
   state_.sampler_units.clear();
   state_.bound_array_buffer = NULL;
   state_.bound_copy_read_buffer = NULL;
   state_.bound_copy_write_buffer = NULL;
   state_.bound_pixel_pack_buffer = NULL;
   state_.bound_pixel_unpack_buffer = NULL;
   state_.bound_transform_feedback_buffer = NULL;
   state_.bound_uniform_buffer = NULL;
-  framebuffer_state_.bound_read_framebuffer = NULL;
-  framebuffer_state_.bound_draw_framebuffer = NULL;
+  framebuffer_state_.set_bound_read_framebuffer(nullptr);
+  framebuffer_state_.set_bound_draw_framebuffer(nullptr);
   state_.bound_renderbuffer = NULL;
 
   if (offscreen_saved_color_texture_info_.get()) {
     DCHECK(offscreen_target_color_texture_);
     DCHECK_EQ(offscreen_saved_color_texture_info_->service_id(),
               offscreen_saved_color_texture_->id());
     offscreen_saved_color_texture_->Invalidate();
     offscreen_saved_color_texture_info_ = NULL;
   }
   if (have_context) {
@@ skipping 124 matching lines @@
   }
   texture_to_io_surface_map_.clear();
 #endif
 }
 
 void GLES2DecoderImpl::SetSurface(
     const scoped_refptr<gfx::GLSurface>& surface) {
   DCHECK(context_->IsCurrent(NULL));
   DCHECK(surface_.get());
   surface_ = surface;
-  RestoreCurrentFramebufferBindings();
+  MarkFramebufferBindingsChanged();
+  // Applying the framebuffer bindings would be possible to be done lazily.
+  // For ease of testing, commit the bindings now.
+  if (!features().chromium_framebuffer_multisample) {
+    ApplyFramebufferBindings(GL_FRAMEBUFFER);
+  } else {
+    ApplyFramebufferBindings(GL_DRAW_FRAMEBUFFER_EXT);
+    ApplyFramebufferBindings(GL_READ_FRAMEBUFFER_EXT);
+  }
 }
 
 void GLES2DecoderImpl::ProduceFrontBuffer(const Mailbox& mailbox) {
   if (!offscreen_saved_color_texture_.get()) {
     LOG(ERROR) << "Called ProduceFrontBuffer on a non-offscreen context";
     return;
   }
   if (!offscreen_saved_color_texture_info_.get()) {
     GLuint service_id = offscreen_saved_color_texture_->id();
     offscreen_saved_color_texture_info_ = TextureRef::Create(
@@ skipping 504 matching lines @@
     return framebuffer->HasStencilAttachment();
   }
   if (offscreen_target_frame_buffer_.get()) {
     return offscreen_target_stencil_format_ != 0 ||
            offscreen_target_depth_format_ == GL_DEPTH24_STENCIL8;
   }
   return back_buffer_has_stencil_;
 }
 
 void GLES2DecoderImpl::ApplyDirtyState() {
-  if (framebuffer_state_.clear_state_dirty) {
+  if (framebuffer_state_.is_draw_framebuffer_clear_state_dirty()) {
     bool have_alpha = BoundFramebufferHasColorAttachmentWithAlpha();
     state_.SetDeviceColorMask(state_.color_mask_red,
                               state_.color_mask_green,
                               state_.color_mask_blue,
                               state_.color_mask_alpha && have_alpha);
 
     bool have_depth = BoundFramebufferHasDepthAttachment();
     state_.SetDeviceDepthMask(state_.depth_mask && have_depth);
 
     bool have_stencil = BoundFramebufferHasStencilAttachment();
     state_.SetDeviceStencilMaskSeparate(
         GL_FRONT, have_stencil ? state_.stencil_front_writemask : 0);
     state_.SetDeviceStencilMaskSeparate(
         GL_BACK, have_stencil ? state_.stencil_back_writemask : 0);
 
     state_.SetDeviceCapabilityState(
         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;
+    framebuffer_state_.set_draw_framebuffer_clear_state_dirty(false);
   }
 }
 
 GLuint GLES2DecoderImpl::GetBackbufferServiceId() const {
   return (offscreen_target_frame_buffer_.get())
              ? offscreen_target_frame_buffer_->id()
              : (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();
+  MarkFramebufferBindingsChanged();

[vmiura, 2016/04/28 22:28:20]

Based on the previous comment here, we have to ensure the frame buffer is bound
before restoring Viewport settings on some drivers.

Perhaps this could be handled similar to the "restore_scissor_on_fbo_change"
workaround.

   state_.RestoreState(prev_state);
 }
 
-void GLES2DecoderImpl::RestoreFramebufferBindings() const {
-  GLuint service_id =
-      framebuffer_state_.bound_draw_framebuffer.get()
-          ? framebuffer_state_.bound_draw_framebuffer->service_id()
-          : GetBackbufferServiceId();
-  if (!features().chromium_framebuffer_multisample) {
-    glBindFramebufferEXT(GL_FRAMEBUFFER, service_id);
-  } else {
-    glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER, service_id);
-    service_id = framebuffer_state_.bound_read_framebuffer.get()
-                     ? framebuffer_state_.bound_read_framebuffer->service_id()
-                     : GetBackbufferServiceId();
-    glBindFramebufferEXT(GL_READ_FRAMEBUFFER, service_id);
-  }
-  OnFboChanged();
+void GLES2DecoderImpl::MarkFramebufferBindingsChanged() {
+  framebuffer_state_.MarkBindingDirty(GL_DRAW_FRAMEBUFFER_EXT);
+  framebuffer_state_.MarkBindingDirty(GL_READ_FRAMEBUFFER_EXT);
 }
 
 void GLES2DecoderImpl::RestoreRenderbufferBindings() {
   state_.RestoreRenderbufferBindings();
 }
 
 void GLES2DecoderImpl::RestoreTextureState(unsigned service_id) const {
   Texture* texture = texture_manager()->GetTextureForServiceId(service_id);
   if (texture) {
     GLenum target = texture->target();
@@ skipping 36 matching lines @@
   force_shader_name_hashing_for_test = force;
 }
 
 // Added specifically for testing backbuffer_needs_clear_bits unittests.
 uint32_t GLES2DecoderImpl::GetAndClearBackbufferClearBitsForTest() {
   uint32_t clear_bits = backbuffer_needs_clear_bits_;
   backbuffer_needs_clear_bits_ = 0;
   return clear_bits;
 }
 
-void GLES2DecoderImpl::OnFboChanged() const {
+void GLES2DecoderImpl::ApplyFramebufferBindings(GLenum target) {
+  if (!framebuffer_state_.IsBindingDirty(target))
+    return;
+  Framebuffer* framebuffer = GetFramebufferInfoForTarget(target);
+  GLuint service_id =
+      framebuffer ? framebuffer->service_id() : GetBackbufferServiceId();
+
+  glBindFramebufferEXT(target, service_id);
+
+  framebuffer_state_.MarkBindingClean(target);
+
   if (workarounds().restore_scissor_on_fbo_change)
     state_.fbo_binding_for_scissor_workaround_dirty = true;
 }
 
 // Called after the FBO is checked for completeness.
-void GLES2DecoderImpl::OnUseFramebuffer() const {
+void GLES2DecoderImpl::OnUseFramebuffer() {
   if (state_.fbo_binding_for_scissor_workaround_dirty) {
-    state_.fbo_binding_for_scissor_workaround_dirty = false;
     // The driver forgets the correct scissor when modifying the FBO binding.
     glScissor(state_.scissor_x,
               state_.scissor_y,
               state_.scissor_width,
               state_.scissor_height);
 
     // crbug.com/222018 - Also on QualComm, the flush here avoids flicker,
     // it's unclear how this bug works.
     glFlush();
   }
 }
 
 void GLES2DecoderImpl::DoBindFramebuffer(GLenum target, GLuint client_id) {
   Framebuffer* framebuffer = NULL;
-  GLuint service_id = 0;
   if (client_id != 0) {
     framebuffer = GetFramebuffer(client_id);
     if (!framebuffer) {
       if (!group_->bind_generates_resource()) {
         LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION,
                            "glBindFramebuffer",
                            "id not generated by glGenFramebuffers");
         return;
       }
 
       // It's a new id so make a framebuffer framebuffer for it.
+      GLuint service_id = 0;
       glGenFramebuffersEXT(1, &service_id);
       CreateFramebuffer(client_id, service_id);
       framebuffer = GetFramebuffer(client_id);
-    } else {
-      service_id = framebuffer->service_id();
     }
     framebuffer->MarkAsValid();
   }
   LogClientServiceForInfo(framebuffer, client_id, "glBindFramebuffer");
 
-  if (target == GL_FRAMEBUFFER || target == GL_DRAW_FRAMEBUFFER_EXT) {
-    framebuffer_state_.bound_draw_framebuffer = framebuffer;
-  }
-
-  // vmiura: This looks like dup code
-  if (target == GL_FRAMEBUFFER || target == GL_READ_FRAMEBUFFER_EXT) {
-    framebuffer_state_.bound_read_framebuffer = framebuffer;
-  }
-
-  framebuffer_state_.clear_state_dirty = true;
-
-  // If we are rendering to the backbuffer get the FBO id for any simulated
-  // backbuffer.
-  if (framebuffer == NULL) {
-    service_id = GetBackbufferServiceId();
-  }
-
-  glBindFramebufferEXT(target, service_id);
-  OnFboChanged();
+  framebuffer_state_.SetBoundFramebuffer(target, framebuffer);
+  // Currently we apply the framebuffer binding directly. In the future,
+  // this may not be neccessary. Current test expectations prevent more
+  // lazy application.
+  ApplyFramebufferBindings(target);
 }
 
 void GLES2DecoderImpl::DoBindRenderbuffer(GLenum target, GLuint client_id) {
   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,
@@ skipping 1346 matching lines @@
     renderbuffer = GetRenderbuffer(client_renderbuffer_id);
     if (!renderbuffer) {
       LOCAL_SET_GL_ERROR(
           GL_INVALID_OPERATION,
           "glFramebufferRenderbuffer", "unknown renderbuffer");
       return;
     }
     service_id = renderbuffer->service_id();
   }
   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("glFramebufferRenderbuffer");
   if (attachment == GL_DEPTH_STENCIL_ATTACHMENT) {

[vmiura, 2016/04/28 22:28:20]

Also needs ApplyFramebufferBindings(target) ?

     glFramebufferRenderbufferEXT(
         target, GL_DEPTH_ATTACHMENT, renderbuffertarget, service_id);
     glFramebufferRenderbufferEXT(
         target, GL_STENCIL_ATTACHMENT, renderbuffertarget, service_id);
   } else {
     glFramebufferRenderbufferEXT(
         target, attachment, renderbuffertarget, service_id);
   }
   GLenum error = LOCAL_PEEK_GL_ERROR("glFramebufferRenderbuffer");
   if (error == GL_NO_ERROR) {
     framebuffer->AttachRenderbuffer(attachment, renderbuffer);
+    framebuffer_state_.NotifyFramebufferChanged(framebuffer);
   }
-  if (framebuffer == framebuffer_state_.bound_draw_framebuffer.get()) {
-    framebuffer_state_.clear_state_dirty = true;
-  }
-  OnFboChanged();
 }
 
 void GLES2DecoderImpl::DoDisable(GLenum cap) {
   if (SetCapabilityState(cap, false)) {
     if (cap == GL_PRIMITIVE_RESTART_FIXED_INDEX &&
         feature_info_->feature_flags().emulate_primitive_restart_fixed_index) {
       // Enable and Disable PRIMITIVE_RESTART only before and after
       // DrawElements* for old desktop GL.
       return;
     }
@@ skipping 103 matching lines @@
                                              GetBackbufferServiceId();
       glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER, service_id);
     }
   }
 
   framebuffer_manager()->MarkAttachmentsAsCleared(
       framebuffer, renderbuffer_manager(), texture_manager());
 }
 
 void GLES2DecoderImpl::RestoreClearState() {
-  framebuffer_state_.clear_state_dirty = true;
+  framebuffer_state_.set_draw_framebuffer_clear_state_dirty(true);
   glClearColor(
       state_.color_clear_red, state_.color_clear_green, state_.color_clear_blue,
       state_.color_clear_alpha);
   glClearStencil(state_.stencil_clear);
   glClearDepth(state_.depth_clear);
   state_.SetDeviceCapabilityState(GL_SCISSOR_TEST,
                                   state_.enable_flags.scissor_test);
   glScissor(state_.scissor_x, state_.scissor_y, state_.scissor_width,
             state_.scissor_height);
 }
@@ skipping 60 matching lines @@
       !texture_manager()->ValidForTarget(textarget, level, 0, 0, 1)) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE,
         name, "level out of range");
     return;
   }
 
   if (texture_ref)
     DoCopyTexImageIfNeeded(texture_ref->texture(), textarget);
 
+  ApplyFramebufferBindings(target);
   std::vector<GLenum> attachments;
   if (attachment == GL_DEPTH_STENCIL_ATTACHMENT) {
     attachments.push_back(GL_DEPTH_ATTACHMENT);
     attachments.push_back(GL_STENCIL_ATTACHMENT);
   } else {
     attachments.push_back(attachment);
   }
   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER(name);
   for (size_t ii = 0; ii < attachments.size(); ++ii) {
     if (0 == samples) {
       glFramebufferTexture2DEXT(
           target, attachments[ii], textarget, service_id, level);
     } else {
       if (features().use_img_for_multisampled_render_to_texture) {
         glFramebufferTexture2DMultisampleIMG(
             target, attachments[ii], textarget, service_id, level, samples);
       } else {
         glFramebufferTexture2DMultisampleEXT(
             target, attachments[ii], textarget, service_id, level, samples);
       }
     }
   }
   GLenum error = LOCAL_PEEK_GL_ERROR(name);
   if (error == GL_NO_ERROR) {
     framebuffer->AttachTexture(attachment, texture_ref, textarget, level,
          samples);
+    framebuffer_state_.NotifyFramebufferChanged(framebuffer);
   }
-  if (framebuffer == framebuffer_state_.bound_draw_framebuffer.get()) {
-    framebuffer_state_.clear_state_dirty = true;
-  }
-
-  OnFboChanged();
 }
 
 void GLES2DecoderImpl::DoFramebufferTextureLayer(
     GLenum target, GLenum attachment, GLuint client_texture_id,
     GLint level, GLint layer) {
   // TODO(zmo): Add full validation.
   GLuint service_id = 0;
   TextureRef* texture_ref = NULL;
   Framebuffer* framebuffer = GetFramebufferInfoForTarget(target);
   if (!framebuffer) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         "glFramebufferTextureLayer", "no framebuffer bound.");
     return;
   }
   if (client_texture_id) {
     texture_ref = GetTexture(client_texture_id);
     if (!texture_ref) {
       LOCAL_SET_GL_ERROR(
           GL_INVALID_OPERATION,
           "glFramebufferTextureLayer", "unknown texture_ref");
       return;
     }
     service_id = texture_ref->service_id();
   }
+  ApplyFramebufferBindings(target);
   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("glFramebufferTextureLayer");
   glFramebufferTextureLayer(target, attachment, service_id, level, layer);
   GLenum error = LOCAL_PEEK_GL_ERROR("glFramebufferTextureLayer");
   if (error == GL_NO_ERROR) {
     framebuffer->AttachTextureLayer(attachment, texture_ref,
         texture_ref ? texture_ref->texture()->target() : 0,
         level, layer);
-  }
-  if (framebuffer == framebuffer_state_.bound_draw_framebuffer.get()) {
-    framebuffer_state_.clear_state_dirty = true;
+    framebuffer_state_.NotifyFramebufferChanged(framebuffer);
   }
 }
 
 void GLES2DecoderImpl::DoGetFramebufferAttachmentParameteriv(
     GLenum target, GLenum attachment, GLenum pname, GLint* params) {
   const char kFunctionName[] = "glGetFramebufferAttachmentParameteriv";
   Framebuffer* framebuffer = GetFramebufferInfoForTarget(target);
   if (!framebuffer) {
     if (!unsafe_es3_apis_enabled()) {
       LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, kFunctionName,
@@ skipping 47 matching lines @@
   }
   if (pname == GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME) {
     DCHECK(framebuffer);
     // If we query from the driver, it will be service ID; however, we need to
     // return the client ID here.
     const Framebuffer::Attachment* attachment_object =
         framebuffer->GetAttachment(attachment);
     *params = attachment_object ? attachment_object->object_name() : 0;
     return;
   }
-
+  ApplyFramebufferBindings(target);
   glGetFramebufferAttachmentParameterivEXT(target, attachment, pname, params);
   // We didn't perform a full error check before gl call.
   LOCAL_PEEK_GL_ERROR(kFunctionName);
 }
 
 void GLES2DecoderImpl::DoGetRenderbufferParameteriv(
     GLenum target, GLenum pname, GLint* params) {
   Renderbuffer* renderbuffer =
       GetRenderbufferInfoForTarget(GL_RENDERBUFFER);
   if (!renderbuffer) {
@@ skipping 3674 matching lines @@
   DCHECK(target != GL_TEXTURE_3D && target != GL_TEXTURE_2D_ARRAY);
   uint32_t channels = GLES2Util::GetChannelsForFormat(format);
   if ((feature_info_->feature_flags().angle_depth_texture ||
        feature_info_->IsES3Enabled())
       && (channels & GLES2Util::kDepth) != 0) {
     // It's a depth format and ANGLE doesn't allow texImage2D or texSubImage2D
     // on depth formats.
     GLuint fb = 0;
     glGenFramebuffersEXT(1, &fb);
     glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, fb);
+    framebuffer_state_.MarkBindingDirty(GL_DRAW_FRAMEBUFFER_EXT);
 
     glFramebufferTexture2DEXT(GL_DRAW_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT,
                               target, texture->service_id(), level);
     bool have_stencil = (channels & GLES2Util::kStencil) != 0;
     if (have_stencil) {
       glFramebufferTexture2DEXT(GL_DRAW_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT,
                                 target, texture->service_id(), level);
     }
 
     // ANGLE promises a depth only attachment ok.
     if (glCheckFramebufferStatusEXT(GL_DRAW_FRAMEBUFFER_EXT) !=
         GL_FRAMEBUFFER_COMPLETE) {
+      ApplyFramebufferBindings(GL_DRAW_FRAMEBUFFER_EXT);
       return false;
     }
     glClearStencil(0);
     state_.SetDeviceStencilMaskSeparate(GL_FRONT, kDefaultStencilMask);
     state_.SetDeviceStencilMaskSeparate(GL_BACK, kDefaultStencilMask);
     glClearDepth(1.0f);
     state_.SetDeviceDepthMask(GL_TRUE);
     state_.SetDeviceCapabilityState(GL_SCISSOR_TEST, true);
     glScissor(xoffset, yoffset, width, height);
     glClear(GL_DEPTH_BUFFER_BIT | (have_stencil ? GL_STENCIL_BUFFER_BIT : 0));
 
     RestoreClearState();
 
     glDeleteFramebuffersEXT(1, &fb);
-    Framebuffer* framebuffer =
-        GetFramebufferInfoForTarget(GL_DRAW_FRAMEBUFFER_EXT);
-    GLuint fb_service_id =
-        framebuffer ? framebuffer->service_id() : GetBackbufferServiceId();
-    glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, fb_service_id);
+    ApplyFramebufferBindings(GL_DRAW_FRAMEBUFFER_EXT);
     return true;
   }
 
   const uint32_t kMaxZeroSize = 1024 * 1024 * 4;
 
   uint32_t size;
   uint32_t padded_row_size;
   if (!GLES2Util::ComputeImageDataSizes(
           width, height, 1, format, type, state_.unpack_alignment, &size,
           NULL, &padded_row_size)) {
@@ skipping 634 matching lines @@
     return error::kNoError;
   }
 
   if (!EnsureGPUMemoryAvailable(image_size)) {
     LOCAL_SET_GL_ERROR(
         GL_OUT_OF_MEMORY, "glCompressedTexImage2D", "out of memory");
     return error::kNoError;
   }
 
   if (texture->IsAttachedToFramebuffer()) {
-    framebuffer_state_.clear_state_dirty = true;
+    framebuffer_state_.NotifyBoundFramebuffersChanged();
   }
 
   std::unique_ptr<int8_t[]> zero;
   if (!data) {
     zero.reset(new int8_t[image_size]);
     memset(zero.get(), 0, image_size);
     data = zero.get();
   }
   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("glCompressedTexImage2D");
   glCompressedTexImage2D(
@@ skipping 174 matching lines @@
     return error::kNoError;
   }
 
   if (!EnsureGPUMemoryAvailable(image_size)) {
     LOCAL_SET_GL_ERROR(
         GL_OUT_OF_MEMORY, "glCompressedTexImage3D", "out of memory");
     return error::kNoError;
   }
 
   if (texture->IsAttachedToFramebuffer()) {
-    framebuffer_state_.clear_state_dirty = true;
+    framebuffer_state_.NotifyBoundFramebuffersChanged();
   }
 
   std::unique_ptr<int8_t[]> zero;
   if (!data) {
     zero.reset(new int8_t[image_size]);
     memset(zero.get(), 0, image_size);
     data = zero.get();
   }
   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("glCompressedTexImage3D");
   glCompressedTexImage3D(target, level, internal_format, width, height, depth,
@@ skipping 532 matching lines @@
         GL_INVALID_OPERATION,
         "glCopyTexImage2D", "source and destination textures are the same");
     return;
   }
 
   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("glCopyTexImage2D");
   ScopedResolvedFrameBufferBinder binder(this, false, true);
   gfx::Size size = GetBoundReadFrameBufferSize();
 
   if (texture->IsAttachedToFramebuffer()) {
-    framebuffer_state_.clear_state_dirty = true;
+    framebuffer_state_.NotifyBoundFramebuffersChanged();
   }
 
   // Clip to size to source dimensions
   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);
 
@@ skipping 2584 matching lines @@
   }
   TextureRef* texture_ref = texture_manager()->GetTextureInfoForTarget(
       &state_, target);
   if (!texture_ref) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION, function_name, "unknown texture for target");
     return;
   }
   Texture* texture = texture_ref->texture();
   if (texture->IsAttachedToFramebuffer()) {
-    framebuffer_state_.clear_state_dirty = true;
+    framebuffer_state_.NotifyBoundFramebuffersChanged();
   }
   if (texture->IsImmutable()) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION, function_name, "texture is immutable");
     return;
   }
 
   GLenum format = TextureManager::ExtractFormatFromStorageFormat(
       internal_format);
   GLenum type = TextureManager::ExtractTypeFromStorageFormat(internal_format);
@@ skipping 1995 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