Allow deleted resources to be used

gpu/command_buffer/service/gles2_cmd_decoder.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 
 #include <stdio.h>
 
 #include <algorithm>
 #include <list>
@@ skipping 548 matching lines @@
     // glBindTexture
     TextureManager::TextureInfo::Ref bound_texture_external_oes;
 
     TextureManager::TextureInfo::Ref GetInfoForSamplerType(GLenum type) {
       DCHECK(type == GL_SAMPLER_2D || type == GL_SAMPLER_CUBE ||
              type == GL_SAMPLER_EXTERNAL_OES);
       return type == GL_SAMPLER_2D ? bound_texture_2d :
           (type == GL_SAMPLER_EXTERNAL_OES ? bound_texture_external_oes :
               bound_texture_cube_map);
     }
+
+    void Unbind(TextureManager::TextureInfo* texture) {
+      if (bound_texture_2d == texture) {
+        bound_texture_2d = NULL;
+      }
+      if (bound_texture_cube_map == texture) {
+        bound_texture_cube_map = NULL;
+      }
+      if (bound_texture_external_oes == texture) {
+        bound_texture_external_oes = NULL;
+      }
+    }
   };
 
   // Initialize or re-initialize the shader translator.
   bool InitializeShaderTranslator();
 
   void UpdateCapabilities();
 
   // Helpers for the glGen and glDelete functions.
   bool GenTexturesHelper(GLsizei n, const GLuint* client_ids);
   void DeleteTexturesHelper(GLsizei n, const GLuint* client_ids);
@@ skipping 37 matching lines @@
   TextureManager::TextureInfo* CreateTextureInfo(
       GLuint client_id, GLuint service_id) {
     return texture_manager()->CreateTextureInfo(
         feature_info_, client_id, service_id);
   }
 
   // Gets the texture info for the given texture. Returns NULL if none exists.
   TextureManager::TextureInfo* GetTextureInfo(GLuint client_id) {
     TextureManager::TextureInfo* info =
         texture_manager()->GetTextureInfo(client_id);
-    return (info && !info->IsDeleted()) ? info : NULL;
+    return info;
   }
 
   // Deletes the texture info for the given texture.
   void RemoveTextureInfo(GLuint client_id) {
     texture_manager()->RemoveTextureInfo(feature_info_, client_id);
   }
 
   // Get the size (in pixels) of the currently bound frame buffer (either FBO
   // or regular back buffer).
   gfx::Size GetBoundReadFrameBufferSize();
@@ skipping 138 matching lines @@
 
   // Creates a buffer info for the given buffer.
   void CreateBufferInfo(GLuint client_id, GLuint service_id) {
     return buffer_manager()->CreateBufferInfo(client_id, service_id);
   }
 
   // Gets the buffer info for the given buffer.
   BufferManager::BufferInfo* GetBufferInfo(GLuint client_id) {
     BufferManager::BufferInfo* info =
         buffer_manager()->GetBufferInfo(client_id);
-    return (info && !info->IsDeleted()) ? info : NULL;
+    return info;
   }
 
   // Removes any buffers in the VertexAtrribInfos and BufferInfos. This is used
   // on glDeleteBuffers so we can make sure the user does not try to render
   // with deleted buffers.
   void RemoveBufferInfo(GLuint client_id);
 
   // Creates a framebuffer info for the given framebuffer.
   void CreateFramebufferInfo(GLuint client_id, GLuint service_id) {
     return framebuffer_manager()->CreateFramebufferInfo(client_id, service_id);
   }
 
   // Gets the framebuffer info for the given framebuffer.
   FramebufferManager::FramebufferInfo* GetFramebufferInfo(
       GLuint client_id) {
     FramebufferManager::FramebufferInfo* info =
         framebuffer_manager()->GetFramebufferInfo(client_id);
-    return (info && !info->IsDeleted()) ? info : NULL;
+    return info;
   }
 
   // Removes the framebuffer info for the given framebuffer.
   void RemoveFramebufferInfo(GLuint client_id) {
     framebuffer_manager()->RemoveFramebufferInfo(client_id);
   }
 
   // Creates a renderbuffer info for the given renderbuffer.
   void CreateRenderbufferInfo(GLuint client_id, GLuint service_id) {
     return renderbuffer_manager()->CreateRenderbufferInfo(
         client_id, service_id);
   }
 
   // Gets the renderbuffer info for the given renderbuffer.
   RenderbufferManager::RenderbufferInfo* GetRenderbufferInfo(
       GLuint client_id) {
     RenderbufferManager::RenderbufferInfo* info =
         renderbuffer_manager()->GetRenderbufferInfo(client_id);
-    return (info && !info->IsDeleted()) ? info : NULL;
+    return info;
   }
 
   // Removes the renderbuffer info for the given renderbuffer.
   void RemoveRenderbufferInfo(GLuint client_id) {
     renderbuffer_manager()->RemoveRenderbufferInfo(client_id);
   }
 
   void DoBindAttribLocation(GLuint client_id, GLuint index, const char* name);
 
   error::Error GetAttribLocationHelper(
@@ skipping 305 matching lines @@
 
   // Returns true if GL_FIXED attribs were simulated.
   bool SimulateFixedAttribs(GLuint max_vertex_accessed, bool* simulated);
   void RestoreStateForSimulatedFixedAttribs();
 
   // Gets the buffer id for a given target.
   BufferManager::BufferInfo* GetBufferInfoForTarget(GLenum target) {
     DCHECK(target == GL_ARRAY_BUFFER || target == GL_ELEMENT_ARRAY_BUFFER);
     BufferManager::BufferInfo* info = target == GL_ARRAY_BUFFER ?
         bound_array_buffer_ : bound_element_array_buffer_;
-    return (info && !info->IsDeleted()) ? info : NULL;
+    return info;
   }
 
   // Gets the texture id for a given target.
   TextureManager::TextureInfo* GetTextureInfoForTarget(GLenum target) {
     TextureUnit& unit = texture_units_[active_texture_unit_];
     TextureManager::TextureInfo* info = NULL;
     switch (target) {
       case GL_TEXTURE_2D:
         info = unit.bound_texture_2d;
         break;
@@ skipping 10 matching lines @@
         info = unit.bound_texture_external_oes;
         break;
       // Note: If we ever support TEXTURE_RECTANGLE as a target, be sure to
       // track |texture_| with the currently bound TEXTURE_RECTANGLE texture,
       // because |texture_| is used by the FBO rendering mechanism for readback
       // to the bits that get sent to the browser.
       default:
         NOTREACHED();
         return NULL;
     }
-    return (info && !info->IsDeleted()) ? info : NULL;
+    return info;
   }
 
   GLenum GetBindTargetForSamplerType(GLenum type) {
     DCHECK(type == GL_SAMPLER_2D || type == GL_SAMPLER_CUBE ||
            type == GL_SAMPLER_EXTERNAL_OES);
     return type == GL_SAMPLER_2D ? GL_TEXTURE_2D :
         (type == GL_SAMPLER_EXTERNAL_OES ? GL_TEXTURE_EXTERNAL_OES :
             GL_TEXTURE_CUBE_MAP);
   }
 
   // Gets the framebuffer info for a particular target.
   FramebufferManager::FramebufferInfo* GetFramebufferInfoForTarget(
       GLenum target) {
     FramebufferManager::FramebufferInfo* info = NULL;
     switch (target) {
       case GL_FRAMEBUFFER:
       case GL_DRAW_FRAMEBUFFER:
         info = bound_draw_framebuffer_;
         break;
       case GL_READ_FRAMEBUFFER:
         info = bound_read_framebuffer_;
         break;
       default:
         NOTREACHED();
         break;
     }
-    return (info && !info->IsDeleted()) ? info : NULL;
+    return info;
   }
 
   RenderbufferManager::RenderbufferInfo* GetRenderbufferInfoForTarget(
       GLenum target) {
     RenderbufferManager::RenderbufferInfo* info = NULL;
     switch (target) {
       case GL_RENDERBUFFER:
         info = bound_renderbuffer_;
         break;
       default:
         NOTREACHED();
         break;
     }
-    return (info && !info->IsDeleted()) ? info : NULL;
+    return info;
   }
 
   // Validates the program and location for a glGetUniform call and returns
   // a SizeResult setup to receive the result. Returns true if glGetUniform
   // should be called.
   bool GetUniformSetup(
       GLuint program, GLint location,
       uint32 shm_id, uint32 shm_offset,
       error::Error* error, GLuint* service_id, void** result,
       GLenum* result_type);
@@ skipping 948 matching lines @@
   glGenTextures(n, service_ids.get());
   for (GLsizei ii = 0; ii < n; ++ii) {
     CreateTextureInfo(client_ids[ii], service_ids[ii]);
   }
   return true;
 }
 
 void GLES2DecoderImpl::DeleteBuffersHelper(
     GLsizei n, const GLuint* client_ids) {
   for (GLsizei ii = 0; ii < n; ++ii) {
-    BufferManager::BufferInfo* info = GetBufferInfo(client_ids[ii]);
-    if (info) {
-      GLuint service_id = info->service_id();
+    BufferManager::BufferInfo* buffer = GetBufferInfo(client_ids[ii]);
+    if (buffer && !buffer->IsDeleted()) {
+      vertex_attrib_manager_.Unbind(buffer);
+      if (bound_array_buffer_ == buffer) {
+        bound_array_buffer_ = NULL;
+      }
+      if (bound_element_array_buffer_ == buffer) {
+        bound_element_array_buffer_ = NULL;
+      }
+      GLuint service_id = buffer->service_id();
       glDeleteBuffersARB(1, &service_id);
       RemoveBufferInfo(client_ids[ii]);
     }
   }
 }
 
 void GLES2DecoderImpl::DeleteFramebuffersHelper(
     GLsizei n, const GLuint* client_ids) {
   bool supports_seperate_framebuffer_binds =
      feature_info_->feature_flags().chromium_framebuffer_multisample;
 
   for (GLsizei ii = 0; ii < n; ++ii) {
-    FramebufferManager::FramebufferInfo* info =
+    FramebufferManager::FramebufferInfo* framebuffer =
         GetFramebufferInfo(client_ids[ii]);
-    if (info) {
-      if (info == bound_draw_framebuffer_) {
+    if (framebuffer && !framebuffer->IsDeleted()) {
+      if (framebuffer == bound_draw_framebuffer_) {
         bound_draw_framebuffer_ = NULL;
         state_dirty_ = true;
         GLenum target = supports_seperate_framebuffer_binds ?
             GL_DRAW_FRAMEBUFFER : GL_FRAMEBUFFER;
         glBindFramebufferEXT(target, GetBackbufferServiceId());
       }
-      if (info == bound_read_framebuffer_) {
+      if (framebuffer == bound_read_framebuffer_) {
         bound_read_framebuffer_ = NULL;
         GLenum target = supports_seperate_framebuffer_binds ?
             GL_READ_FRAMEBUFFER : GL_FRAMEBUFFER;
         glBindFramebufferEXT(target, GetBackbufferServiceId());
       }
-      GLuint service_id = info->service_id();
+      GLuint service_id = framebuffer->service_id();
       glDeleteFramebuffersEXT(1, &service_id);
       RemoveFramebufferInfo(client_ids[ii]);
     }
   }
 }
 
 void GLES2DecoderImpl::DeleteRenderbuffersHelper(
     GLsizei n, const GLuint* client_ids) {
+  bool supports_seperate_framebuffer_binds =
+     feature_info_->feature_flags().chromium_framebuffer_multisample;
   for (GLsizei ii = 0; ii < n; ++ii) {
-    RenderbufferManager::RenderbufferInfo* info =
+    RenderbufferManager::RenderbufferInfo* renderbuffer =
         GetRenderbufferInfo(client_ids[ii]);
-    if (info) {
+    if (renderbuffer && !renderbuffer->IsDeleted()) {
+      if (bound_renderbuffer_ == renderbuffer) {
+        bound_renderbuffer_ = NULL;
+      }
+      // Unbind from current framebuffers.
+      if (supports_seperate_framebuffer_binds) {
+        if (bound_read_framebuffer_) {
+          bound_read_framebuffer_->UnbindRenderbuffer(
+              GL_READ_FRAMEBUFFER, renderbuffer);
+        }
+        if (bound_draw_framebuffer_) {
+          bound_draw_framebuffer_->UnbindRenderbuffer(
+              GL_DRAW_FRAMEBUFFER, renderbuffer);
+        }
+      } else {
+        if (bound_draw_framebuffer_) {
+          bound_draw_framebuffer_->UnbindRenderbuffer(
+              GL_FRAMEBUFFER, renderbuffer);
+        }
+      }
       state_dirty_ = true;
-      GLuint service_id = info->service_id();
+      GLuint service_id = renderbuffer->service_id();
       glDeleteRenderbuffersEXT(1, &service_id);
       RemoveRenderbufferInfo(client_ids[ii]);
     }
   }
 }
 
 void GLES2DecoderImpl::DeleteTexturesHelper(
     GLsizei n, const GLuint* client_ids) {
+  bool supports_seperate_framebuffer_binds =
+     feature_info_->feature_flags().chromium_framebuffer_multisample;
   for (GLsizei ii = 0; ii < n; ++ii) {
-    TextureManager::TextureInfo* info = GetTextureInfo(client_ids[ii]);
-    if (info) {
-      if (info->IsAttachedToFramebuffer()) {
+    TextureManager::TextureInfo* texture = GetTextureInfo(client_ids[ii]);
+    if (texture && !texture->IsDeleted()) {
+      if (texture->IsAttachedToFramebuffer()) {
         state_dirty_ = true;
       }
-      GLuint service_id = info->service_id();
-      if (info->IsStreamTexture() && stream_texture_manager_) {
+      // Unbind texture from texture units.
+      for (size_t jj = 0; jj < group_->max_texture_units(); ++jj) {
+        texture_units_[ii].Unbind(texture);
+      }
+      // Unbind from current framebuffers.
+      if (supports_seperate_framebuffer_binds) {
+        if (bound_read_framebuffer_) {
+          bound_read_framebuffer_->UnbindTexture(GL_READ_FRAMEBUFFER, texture);
+        }
+        if (bound_draw_framebuffer_) {
+          bound_draw_framebuffer_->UnbindTexture(GL_DRAW_FRAMEBUFFER, texture);
+        }
+      } else {
+        if (bound_draw_framebuffer_) {
+          bound_draw_framebuffer_->UnbindTexture(GL_FRAMEBUFFER, texture);
+        }
+      }
+      GLuint service_id = texture->service_id();
+      if (texture->IsStreamTexture() && stream_texture_manager_) {
         stream_texture_manager_->DestroyStreamTexture(service_id);
       }
       glDeleteTextures(1, &service_id);
       RemoveTextureInfo(client_ids[ii]);
     }
   }
 }
 
 // }  // anonymous namespace
 
@@ skipping 61 matching lines @@
     last_id = 0;
   }
 
   glBindTexture(GL_TEXTURE_2D, last_id);
   glActiveTexture(GL_TEXTURE0 + active_texture_unit_);
 }
 
 bool GLES2DecoderImpl::CheckFramebufferValid(
     FramebufferManager::FramebufferInfo* framebuffer,
     GLenum target, const char* func_name) {
-  if (!framebuffer || framebuffer->IsDeleted()) {
+  if (!framebuffer) {
     return true;
   }
 
   GLenum completeness = framebuffer->IsPossiblyComplete();
   if (completeness != GL_FRAMEBUFFER_COMPLETE) {
     SetGLError(
         GL_INVALID_FRAMEBUFFER_OPERATION,
         (std::string(func_name) + " framebuffer incomplete").c_str());
     return false;
   }
@@ skipping 1448 matching lines @@
   }
   if (face == GL_BACK || face == GL_FRONT_AND_BACK) {
     mask_stencil_back_ = mask;
   }
   state_dirty_ = true;
 }
 
 // Assumes framebuffer is complete.
 void GLES2DecoderImpl::ClearUnclearedAttachments(
     GLenum target, FramebufferManager::FramebufferInfo* info) {
-  DCHECK(!info->IsDeleted());
   if (target == GL_READ_FRAMEBUFFER_EXT) {
     // bind this to the DRAW point, clear then bind back to READ
     // TODO(gman): I don't think there is any guarantee that an FBO that
     //   is complete on the READ attachment will be complete as a DRAW
     //   attachment.
     glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, 0);
     glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, info->service_id());
   }
   GLbitfield clear_bits = 0;
   if (info->HasUnclearedAttachment(GL_COLOR_ATTACHMENT0)) {
@@ skipping 745 matching lines @@
         current_program_->GetAttribInfoByLocation(info->index());
     if (attrib_info) {
       // This attrib is used in the current program.
       if (!info->CanAccess(max_vertex_accessed)) {
         SetGLError(GL_INVALID_OPERATION,
                    "glDrawXXX: attempt to access out of range vertices");
         return false;
       }
     } else {
       // This attrib is not used in the current program.
-      if (!info->buffer() || info->buffer()->IsDeleted()) {
+      if (!info->buffer()) {
         SetGLError(
             GL_INVALID_OPERATION,
             "glDrawXXX: attempt to render with no buffer attached to enabled "
             "attrib");
         return false;
       }
     }
   }
   return true;
 }
@@ skipping 232 matching lines @@
     if (WasContextLost()) {
       LOG(ERROR) << "  GLES2DecoderImpl: Context lost during DrawArrays.";
       return error::kLostContext;
     }
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleDrawElements(
     uint32 immediate_data_size, const gles2::DrawElements& c) {
-  if (!bound_element_array_buffer_ ||
-      bound_element_array_buffer_->IsDeleted()) {
+  if (!bound_element_array_buffer_) {
     SetGLError(GL_INVALID_OPERATION,
                "glDrawElements: No element array buffer bound");
     return error::kNoError;
   }
 
   GLenum mode = c.mode;
   GLsizei count = c.count;
   GLenum type = c.type;
   int32 offset = c.index_offset;
   if (count < 0) {
@@ skipping 278 matching lines @@
       shader, "glGetShaderInfoLog");
   if (!info || !info->log_info()) {
     bucket->SetFromString("");
     return error::kNoError;
   }
   bucket->SetFromString(info->log_info()->c_str());
   return error::kNoError;
 }
 
 bool GLES2DecoderImpl::DoIsBuffer(GLuint client_id) {
-  const BufferManager::BufferInfo* info = GetBufferInfo(client_id);
-  return info && info->IsValid();
+  const BufferManager::BufferInfo* buffer = GetBufferInfo(client_id);
+  return buffer && buffer->IsValid() && !buffer->IsDeleted();
 }
 
 bool GLES2DecoderImpl::DoIsFramebuffer(GLuint client_id) {
-  const FramebufferManager::FramebufferInfo* info =
+  const FramebufferManager::FramebufferInfo* framebuffer =
       GetFramebufferInfo(client_id);
-  return info && info->IsValid();
+  return framebuffer && framebuffer->IsValid() && !framebuffer->IsDeleted();
 }
 
 bool GLES2DecoderImpl::DoIsProgram(GLuint client_id) {
   // IsProgram is true for programs as soon as they are created, until they are
   // deleted and no longer in use.
-  return GetProgramInfo(client_id) != NULL;
+  const ProgramManager::ProgramInfo* program = GetProgramInfo(client_id);
+  return program != NULL && !program->IsDeleted();
 }
 
 bool GLES2DecoderImpl::DoIsRenderbuffer(GLuint client_id) {
-  const RenderbufferManager::RenderbufferInfo* info =
+  const RenderbufferManager::RenderbufferInfo* renderbuffer =
       GetRenderbufferInfo(client_id);
-  return info && info->IsValid();
+  return renderbuffer && renderbuffer->IsValid() && !renderbuffer->IsDeleted();
 }
 
 bool GLES2DecoderImpl::DoIsShader(GLuint client_id) {
   // IsShader is true for shaders as soon as they are created, until they
   // are deleted and not attached to any programs.
-  return GetShaderInfo(client_id) != NULL;
+  const ShaderManager::ShaderInfo* shader = GetShaderInfo(client_id);
+  return shader != NULL && !shader->IsDeleted();
 }
 
 bool GLES2DecoderImpl::DoIsTexture(GLuint client_id) {
-  const TextureManager::TextureInfo* info = GetTextureInfo(client_id);
-  return info && info->IsValid();
+  const TextureManager::TextureInfo* texture = GetTextureInfo(client_id);
+  return texture && texture->IsValid() && !texture->IsDeleted();
 }
 
 void GLES2DecoderImpl::DoAttachShader(
     GLuint program_client_id, GLint shader_client_id) {
   ProgramManager::ProgramInfo* program_info = GetProgramInfoNotShader(
       program_client_id, "glAttachShader");
   if (!program_info) {
     return;
   }
   ShaderManager::ShaderInfo* shader_info = GetShaderInfoNotProgram(
@@ skipping 361 matching lines @@
     return error::kNoError;
   }
   if (!validators_->pixel_type.IsValid(type)) {
     SetGLError(GL_INVALID_ENUM, "glReadPixels: type GL_INVALID_ENUM");
     return error::kNoError;
   }
   if (width == 0 || height == 0) {
     return error::kNoError;
   }
 
-  CopyRealGLErrorsToWrapper();
-
-  ScopedResolvedFrameBufferBinder binder(this, false, true);
-
   // Get the size of the current fbo or backbuffer.
   gfx::Size max_size = GetBoundReadFrameBufferSize();
 
   GLint max_x;
   GLint max_y;
   if (!SafeAdd(x, width, &max_x) || !SafeAdd(y, height, &max_y)) {
     SetGLError(GL_INVALID_VALUE, "glReadPixels: dimensions out of range");
     return error::kNoError;
   }
 
   if (!CheckBoundFramebuffersValid("glReadPixels")) {
     return error::kNoError;
   }
 
+  CopyRealGLErrorsToWrapper();
+
+  ScopedResolvedFrameBufferBinder binder(this, false, true);
+
   if (x < 0 || y < 0 || max_x > max_size.width() || max_y > max_size.height()) {
     // The user requested an out of range area. Get the results 1 line
     // at a time.
     uint32 temp_size;
     if (!GLES2Util::ComputeImageDataSize(
         width, 1, format, type, pack_alignment_, &temp_size)) {
       SetGLError(GL_INVALID_VALUE, "glReadPixels: dimensions out of range");
       return error::kNoError;
     }
     GLsizei unpadded_row_size = temp_size;
@@ skipping 820 matching lines @@
   // Check we have compatible formats.
   GLenum read_format = GetBoundReadFrameBufferInternalFormat();
   uint32 channels_exist = GLES2Util::GetChannelsForFormat(read_format);
   uint32 channels_needed = GLES2Util::GetChannelsForFormat(internal_format);
 
   if ((channels_needed & channels_exist) != channels_needed) {
     SetGLError(GL_INVALID_OPERATION, "glCopyTexImage2D: incompatible format");
     return;
   }
 
+  if (!CheckBoundFramebuffersValid("glCopyTexImage2D")) {
+    return;
+  }
+
   CopyRealGLErrorsToWrapper();
   ScopedResolvedFrameBufferBinder binder(this, false, true);
   gfx::Size size = GetBoundReadFrameBufferSize();
 
   if (info->IsAttachedToFramebuffer()) {
     state_dirty_ = true;
   }
 
   // Clip to size to source dimensions
   GLint copyX = 0;
@@ skipping 64 matching lines @@
   GLenum read_format = GetBoundReadFrameBufferInternalFormat();
   uint32 channels_exist = GLES2Util::GetChannelsForFormat(read_format);
   uint32 channels_needed = GLES2Util::GetChannelsForFormat(format);
 
   if ((channels_needed & channels_exist) != channels_needed) {
     SetGLError(
         GL_INVALID_OPERATION, "glCopyTexSubImage2D: incompatible format");
     return;
   }
 
+  if (!CheckBoundFramebuffersValid("glCopyTexSubImage2D")) {
+    return;
+  }
+
   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);
 
   if (!texture_manager()->ClearTextureLevel(this, info, target, level)) {
@@ skipping 920 matching lines @@
   return error::kNoError;
 }
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu