gpu: Add async pixel transfer interface, stub and tests.

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 <stdio.h>
 
 #include <algorithm>
 #include <list>
@@ skipping 38 matching lines @@
 #include "gpu/command_buffer/service/renderbuffer_manager.h"
 #include "gpu/command_buffer/service/shader_manager.h"
 #include "gpu/command_buffer/service/shader_translator.h"
 #include "gpu/command_buffer/service/shader_translator_cache.h"
 #include "gpu/command_buffer/service/stream_texture.h"
 #include "gpu/command_buffer/service/stream_texture_manager.h"
 #include "gpu/command_buffer/service/texture_definition.h"
 #include "gpu/command_buffer/service/texture_manager.h"
 #include "gpu/command_buffer/service/vertex_attrib_manager.h"
 #include "gpu/command_buffer/service/vertex_array_manager.h"
+#include "ui/gl/async_pixel_transfer_delegate.h"
 #include "ui/gl/gl_image.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_surface.h"
 #if defined(OS_MACOSX)
 #include "ui/surface/io_surface_support_mac.h"
 #endif
 
 #if !defined(GL_DEPTH24_STENCIL8)
 #define GL_DEPTH24_STENCIL8 0x88F0
 #endif
@@ skipping 117 matching lines @@
 }
 
 static inline GLenum GetTexInternalFormat(GLenum internal_format) {
   if (gfx::GetGLImplementation() != gfx::kGLImplementationEGLGLES2) {
     if (internal_format == GL_BGRA_EXT || internal_format == GL_BGRA8_EXT)
       return GL_RGBA8;
   }
   return internal_format;
 }
 
+// TODO(epenner): Could the above function be merged into this and removed?
+static inline GLenum GetTexInternalFormat(GLenum internal_format,
+                                          GLenum format,
+                                          GLenum type) {
+  GLenum gl_internal_format = GetTexInternalFormat(internal_format);
+
+  if (gfx::GetGLImplementation() == gfx::kGLImplementationEGLGLES2)
+    return gl_internal_format;
+
+  if (type == GL_FLOAT) {
+    switch (format) {
+      case GL_RGBA:
+        gl_internal_format = GL_RGBA32F_ARB;
+        break;
+      case GL_RGB:
+        gl_internal_format = GL_RGB32F_ARB;
+        break;
+      case GL_LUMINANCE_ALPHA:
+        gl_internal_format = GL_LUMINANCE_ALPHA32F_ARB;
+        break;
+      case GL_LUMINANCE:
+        gl_internal_format = GL_LUMINANCE32F_ARB;
+        break;
+      case GL_ALPHA:
+        gl_internal_format = GL_ALPHA32F_ARB;
+        break;
+      default:
+        NOTREACHED();
+        break;
+    }
+  } else if (type == GL_HALF_FLOAT_OES) {
+    switch (format) {
+      case GL_RGBA:
+        gl_internal_format = GL_RGBA16F_ARB;
+        break;
+      case GL_RGB:
+        gl_internal_format = GL_RGB16F_ARB;
+        break;
+      case GL_LUMINANCE_ALPHA:
+        gl_internal_format = GL_LUMINANCE_ALPHA16F_ARB;
+        break;
+      case GL_LUMINANCE:
+        gl_internal_format = GL_LUMINANCE16F_ARB;
+        break;
+      case GL_ALPHA:
+        gl_internal_format = GL_ALPHA16F_ARB;
+        break;
+      default:
+        NOTREACHED();
+        break;
+    }
+  }
+  return gl_internal_format;
+}
+
 static void WrappedTexImage2D(
     GLenum target,
     GLint level,
     GLenum internal_format,
     GLsizei width,
     GLsizei height,
     GLint border,
     GLenum format,
     GLenum type,
     const void* pixels) {
-  GLenum gl_internal_format = GetTexInternalFormat(internal_format);
-  if (gfx::GetGLImplementation() != gfx::kGLImplementationEGLGLES2) {
-    if (type == GL_FLOAT) {
-      switch (format) {
-        case GL_RGBA:
-          gl_internal_format = GL_RGBA32F_ARB;
-          break;
-        case GL_RGB:
-          gl_internal_format = GL_RGB32F_ARB;
-          break;
-        case GL_LUMINANCE_ALPHA:
-          gl_internal_format = GL_LUMINANCE_ALPHA32F_ARB;
-          break;
-        case GL_LUMINANCE:
-          gl_internal_format = GL_LUMINANCE32F_ARB;
-          break;
-        case GL_ALPHA:
-          gl_internal_format = GL_ALPHA32F_ARB;
-          break;
-        default:
-          NOTREACHED();
-          break;
-      }
-    } else if (type == GL_HALF_FLOAT_OES) {
-      switch (format) {
-        case GL_RGBA:
-          gl_internal_format = GL_RGBA16F_ARB;
-          break;
-        case GL_RGB:
-          gl_internal_format = GL_RGB16F_ARB;
-          break;
-        case GL_LUMINANCE_ALPHA:
-          gl_internal_format = GL_LUMINANCE_ALPHA16F_ARB;
-          break;
-        case GL_LUMINANCE:
-          gl_internal_format = GL_LUMINANCE16F_ARB;
-          break;
-        case GL_ALPHA:
-          gl_internal_format = GL_ALPHA16F_ARB;
-          break;
-        default:
-          NOTREACHED();
-          break;
-      }
-    }
-  }
   glTexImage2D(
-      target, level, gl_internal_format, width, height, border, format, type,
-      pixels);
+      target, level, GetTexInternalFormat(internal_format, format, type),
+      width, height, border, format, type, pixels);
 }
 
 // Wrapper for glEnable/glDisable that doesn't suck.
 static void EnableDisable(GLenum pname, bool enable) {
   if (enable) {
     glEnable(pname);
   } else {
     glDisable(pname);
   }
 }
@@ skipping 280 matching lines @@
                           const char* msg);
   virtual void SetGLErrorInvalidEnum(const char* function_name,
                                      GLenum value,
                                      const char* label);
   virtual void SetResizeCallback(
       const base::Callback<void(gfx::Size)>& callback) OVERRIDE;
 
   virtual void SetMsgCallback(const MsgCallback& callback) OVERRIDE;
 
   virtual void SetStreamTextureManager(StreamTextureManager* manager) OVERRIDE;
+
+  virtual gfx::AsyncPixelTransferDelegate*
+      GetAsyncPixelTransferDelegate() OVERRIDE;
+  virtual void SetAsyncPixelTransferDelegate(
+      gfx::AsyncPixelTransferDelegate* delegate) OVERRIDE;
+
   virtual bool GetServiceTextureId(uint32 client_texture_id,
                                    uint32* service_texture_id) OVERRIDE;
 
   virtual uint32 GetGLError() OVERRIDE;
 
   virtual uint32 GetTextureUploadCount() OVERRIDE;
   virtual base::TimeDelta GetTotalTextureUploadTime() OVERRIDE;
   virtual base::TimeDelta GetTotalProcessingCommandsTime() OVERRIDE;
   virtual void AddProcessingCommandsTime(base::TimeDelta) OVERRIDE;
 
@@ skipping 202 matching lines @@
       GLenum target,
       GLint level,
       GLint xoffset,
       GLint yoffset,
       GLsizei width,
       GLsizei height,
       GLenum format,
       GLenum type,
       const void * data);
 
+  // Extra validation for async tex(Sub)Image2D.
+  bool ValidateAsyncTransfer(
+      const char* function_name,
+      TextureManager::TextureInfo* info,
+      GLenum target,
+      GLint level,
+      const void * data);
+
   // Wrapper for TexImageIOSurface2DCHROMIUM.
   void DoTexImageIOSurface2DCHROMIUM(
       GLenum target,
       GLsizei width,
       GLsizei height,
       GLuint io_surface_id,
       GLuint plane);
 
   void DoCopyTextureCHROMIUM(
       GLenum target,
@@ skipping 804 matching lines @@
 
   scoped_ptr<QueryManager> query_manager_;
 
   scoped_ptr<VertexArrayManager> vertex_array_manager_;
 
   base::Callback<void(gfx::Size)> resize_callback_;
 
   MsgCallback msg_callback_;
 
   StreamTextureManager* stream_texture_manager_;
+  scoped_ptr<gfx::AsyncPixelTransferDelegate> async_pixel_transfer_delegate_;
 
   // The format of the back buffer_
   GLenum back_buffer_color_format_;
   bool back_buffer_has_depth_;
   bool back_buffer_has_stencil_;
 
   // Backbuffer attachments that are currently undefined.
   uint32 backbuffer_needs_clear_bits_;
 
   bool teximage2d_faster_than_texsubimage2d_;
@@ skipping 772 matching lines @@
   DoBindFramebuffer(GL_FRAMEBUFFER, 0);
   DoBindRenderbuffer(GL_RENDERBUFFER, 0);
 
   // AMD and Intel drivers on Mac OS apparently get gl_PointCoord
   // backward from the spec and this setting makes them work
   // correctly. rdar://problem/11883495
   if (feature_info_->workarounds().reverse_point_sprite_coord_origin) {
     glPointParameteri(GL_POINT_SPRITE_COORD_ORIGIN, GL_LOWER_LEFT);
   }
 
+  // Create a delegate to perform async pixel transfers.
+  async_pixel_transfer_delegate_ =
+      gfx::AsyncPixelTransferDelegate::Create(context.get());
+
   return true;
 }
 
 void GLES2DecoderImpl::UpdateCapabilities() {
   util_.set_num_compressed_texture_formats(
       validators_->compressed_texture_format.GetValues().size());
   util_.set_num_shader_binary_formats(
       validators_->shader_binary_format.GetValues().size());
 }
 
@@ skipping 311 matching lines @@
     last_id = 0;
   }
 
   glBindTexture(GL_TEXTURE_2D, last_id);
   glActiveTexture(GL_TEXTURE0 + state_.active_texture_unit);
 }
 
 bool GLES2DecoderImpl::CheckFramebufferValid(
     FramebufferManager::FramebufferInfo* framebuffer,
     GLenum target, const char* func_name) {
+
+  // As this occurs before every draw, take this opportunity to
+  // bind any unbound async pixel transfers to their textures.
+  // TODO(epenner): Is there a better place to do this? Transfers

[greggman, 2012/12/14 06:08:06]

This seems like it really needs to be in DoCommand?

here's the issue

   BindTexture
   AsyncTexImage
   Query till true
   TexSubimage2D
   Draw

Maybe we can leave that for later?

Note: That also suggests that the other texture manipulating functions probably
need to check for async in progress. As in

   BindTexture
   AsyncTexXXX
   TexSubImage2D  <- should gen INVALID_OPERATION until
                     BindFinishedAsyncPixelTransfers has
                     been called.
   CopyTexSubImage2D as well

as in

    TextureInfo* info = GetTextureForTarget(target);
    if (info->IsBusy()) {
       SetGLError(...INVALID_OPERATION...)
       return;
    }

[epenner, 2012/12/14 21:01:34]

Does DoCommand happen at every GL command? It only needs to happen once per
flush, as transfers are marked as completed on the main thread (which can't
happen again until we yield the main thread).

+  // are marked as complete on the main thread, so we only need
+  // to process them once in a given main-thread task.
+  bool frame_buffer_dirty = false;
+  bool texture_dirty = false;
+  GetContextGroup()->texture_manager()->BindFinishedAsyncPixelTransfers(

[greggman, 2012/12/14 06:08:06]

you can just use

texture_manager()->BindFinished....

right? No need to use GetContextGroup

[epenner, 2012/12/14 21:01:34]

Done.

+      &texture_dirty, &frame_buffer_dirty);
+  // Texture unit zero might be stomped.
+  if (texture_dirty)
+    RestoreCurrentTexture2DBindings();
+  // A texture attached to frame-buffer might have changed size.
+  if (frame_buffer_dirty) {
+    clear_state_dirty_ = true;
+    // TODO(gman): If textures tracked which framebuffers they were attached to
+    // we could just mark those framebuffers as not complete.
+    framebuffer_manager()->IncFramebufferStateChangeCount();
+  }
+
   if (!framebuffer) {
     if (backbuffer_needs_clear_bits_) {
       glClearColor(0, 0, 0, (GLES2Util::GetChannelsForFormat(
           offscreen_target_color_format_) & 0x0008) != 0 ? 0 : 1);
       glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
       glClearStencil(0);
       glStencilMask(-1);
       glClearDepth(1.0f);
       glDepthMask(true);
       glDisable(GL_SCISSOR_TEST);
@@ skipping 146 matching lines @@
 }
 
 void GLES2DecoderImpl::SetMsgCallback(const MsgCallback& callback) {
   msg_callback_ = callback;
 }
 
 void GLES2DecoderImpl::SetStreamTextureManager(StreamTextureManager* manager) {
   stream_texture_manager_ = manager;
 }
 
+gfx::AsyncPixelTransferDelegate*
+    GLES2DecoderImpl::GetAsyncPixelTransferDelegate() {
+  return async_pixel_transfer_delegate_.get();
+}
+
+void GLES2DecoderImpl::SetAsyncPixelTransferDelegate(
+    gfx::AsyncPixelTransferDelegate* delegate) {
+  async_pixel_transfer_delegate_ = make_scoped_ptr(delegate);
+}
+
 bool GLES2DecoderImpl::GetServiceTextureId(uint32 client_texture_id,
                                            uint32* service_texture_id) {
   TextureManager::TextureInfo* texture =
       texture_manager()->GetTextureInfo(client_texture_id);
   if (texture) {
     *service_texture_id = texture->service_id();
     return true;
   }
   return false;
 }
@@ skipping 722 matching lines @@
   if (info->IsStreamTexture() && target != GL_TEXTURE_EXTERNAL_OES) {
     SetGLError(GL_INVALID_OPERATION,
                "glBindTexture", "illegal target for stream texture.");
     return;
   }
   LogClientServiceForInfo(info, client_id, "glBindTexture");
   if (info->target() == 0) {
     texture_manager()->SetInfoTarget(info, target);
   }
   glBindTexture(target, info->service_id());
+
   TextureUnit& unit = state_.texture_units[state_.active_texture_unit];
   unit.bind_target = target;
   switch (target) {
     case GL_TEXTURE_2D:
       unit.bound_texture_2d = info;
       break;
     case GL_TEXTURE_CUBE_MAP:
       unit.bound_texture_cube_map = info;
       break;
     case GL_TEXTURE_EXTERNAL_OES:
@@ skipping 6017 matching lines @@
     SetGLError(GL_INVALID_OPERATION,
                "glTraceEndCHROMIUM", "no trace begin found");
     return;
   }
 
   linked_ptr<GPUTrace> trace = gpu_trace_stack_.top();
   trace->EnableEndTrace();
   gpu_trace_stack_.pop();
 }
 
+bool GLES2DecoderImpl::ValidateAsyncTransfer(
+    const char* function_name,
+    TextureManager::TextureInfo* info,
+    GLenum target,
+    GLint level,
+    const void * data) {
+  // We only support async uploads to 2D textures for now.
+  if (GL_TEXTURE_2D != target) {
+    SetGLErrorInvalidEnum(function_name, target, "target");
+    return false;
+  }
+  // We only support uploads to level zero for now.
+  if (level != 0) {
+    SetGLError(GL_INVALID_VALUE, function_name, "level != 0");
+    return false;
+  }
+  // A transfer buffer must be bound, even for asyncTexImage2D.
+  if (data == NULL) {
+    SetGLError(GL_INVALID_OPERATION, function_name, "buffer == 0");
+    return false;
+  }
+  // We only support one async transfer in progress.
+  if (!info || info->AsyncTransferIsInProgress()) {
+    SetGLError(GL_INVALID_OPERATION,
+        function_name, "transfer already in progress");
+    return false;
+  }
+  return true;
+}
+
 error::Error GLES2DecoderImpl::HandleAsyncTexImage2DCHROMIUM(
     uint32 immediate_data_size, const gles2::AsyncTexImage2DCHROMIUM& c) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::HandleAsyncTexImage2DCHROMIUM");
-
-  // TODO: This is a copy of HandleTexImage2D validation. Merge
-  // as much of it as possible.
-  tex_image_2d_failed_ = true;
   GLenum target = static_cast<GLenum>(c.target);
   GLint level = static_cast<GLint>(c.level);
   GLint internal_format = static_cast<GLint>(c.internalformat);
   GLsizei width = static_cast<GLsizei>(c.width);
   GLsizei height = static_cast<GLsizei>(c.height);
   GLint border = static_cast<GLint>(c.border);
   GLenum format = static_cast<GLenum>(c.format);
   GLenum type = static_cast<GLenum>(c.type);
   uint32 pixels_shm_id = static_cast<uint32>(c.pixels_shm_id);
   uint32 pixels_shm_offset = static_cast<uint32>(c.pixels_shm_offset);
   uint32 pixels_size;
+
+  // TODO(epenner): Move this and copies of this memory validation
+  // into ValidateTexImage2D step.
   if (!GLES2Util::ComputeImageDataSizes(
       width, height, format, type, state_.unpack_alignment, &pixels_size, NULL,
       NULL)) {
     return error::kOutOfBounds;
   }
   const void* pixels = NULL;
   if (pixels_shm_id != 0 || pixels_shm_offset != 0) {
     pixels = GetSharedMemoryAs<const void*>(
         pixels_shm_id, pixels_shm_offset, pixels_size);
     if (!pixels) {
       return error::kOutOfBounds;
     }
   }
 
-  // TODO(epenner): Do this via an async task.
-  DoTexImage2D(
-      target, level, internal_format, width, height, border, format, type,
-      pixels, pixels_size);
+  // All the normal glTexSubImage2D validation.
+  if (!ValidateTexImage2D("glAsyncTexImage2D", target, level, internal_format,

[greggman, 2012/12/14 06:08:06]

s/glAsyncTexImage2D/glAsyncTexImage2DCHROMIUM/
s/glAsyncTexSubImage2D/glAsyncTexSubImage2DCHROMIUM/
?

[epenner, 2012/12/14 21:01:34]

Done.

+      width, height, border, format, type, pixels, pixels_size)) {
+    return error::kNoError;
+  }
+
+  // Extra async validation.
+  TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
+  if (!ValidateAsyncTransfer("glAsyncTexImage2D", info, target, level, pixels))
+    return error::kNoError;
+
+  // Don't allow async redefinition of a textures.
+  if (info->IsDefined()) {
+    SetGLError(GL_INVALID_OPERATION, "glAsyncTexImage2D", "already defined");
+    return error::kNoError;
+  }
+
+  // We know the memory/size is safe, so get the real shared memory since
+  // it might need to be duped to prevent use-after-free of the memory.
+  Buffer buffer = GetSharedMemoryBuffer(c.pixels_shm_id);
+  base::SharedMemory* shared_memory = buffer.shared_memory;
+  uint32 shm_size = buffer.size;
+  uint32 shm_data_offset = c.pixels_shm_offset;
+  uint32 shm_data_size = pixels_size;
+
+  // Set up the async state if needed, and make the texture
+  // immutable so the async state stays valid. The level info
+  // is set up lazily when the transfer completes.
+  DCHECK(!info->GetAsyncTransferState());
+  info->SetAsyncTransferState(
+      async_pixel_transfer_delegate_->
+          CreatePixelTransferState(info->service_id()));
+  info->SetImmutable(true);
+
+  // Issue the async call and set up the texture.
+  GLenum gl_internal_format =
+      GetTexInternalFormat(internal_format, format, type);
+  gfx::AsyncTexImage2DParams tex_params = {target, level, gl_internal_format,
+                                           width, height, border, format, type};
+  gfx::AsyncMemoryParams mem_params = {shared_memory, shm_size,
+                                       shm_data_offset, shm_data_size};
+
+  // Add a pending transfer to the texture manager, which will bind the
+  // transfer data to the texture and set the level info at the same time,
+  // after the the transfer is complete.
+  GetContextGroup()->texture_manager()->AddPendingAsyncPixelTransfer(

[greggman, 2012/12/14 06:08:06]

GetConextGroup()-> not needed?

[epenner, 2012/12/14 21:01:34]

Done.

+      info->GetAsyncTransferState()->AsWeakPtr(), info);
+
+  async_pixel_transfer_delegate_->AsyncTexImage2D(
+      info->GetAsyncTransferState(), tex_params, mem_params);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleAsyncTexSubImage2DCHROMIUM(
     uint32 immediate_data_size, const gles2::AsyncTexSubImage2DCHROMIUM& c) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::HandleAsyncTexSubImage2DCHROMIUM");
-
-  // TODO: This is a copy of HandleTexSubImage2D validation. Merge
-  // as much of it as possible.
   GLenum target = static_cast<GLenum>(c.target);
   GLint level = static_cast<GLint>(c.level);
   GLint xoffset = static_cast<GLint>(c.xoffset);
   GLint yoffset = static_cast<GLint>(c.yoffset);
   GLsizei width = static_cast<GLsizei>(c.width);
   GLsizei height = static_cast<GLsizei>(c.height);
   GLenum format = static_cast<GLenum>(c.format);
   GLenum type = static_cast<GLenum>(c.type);
+
+  // TODO(epenner): Move this and copies of this memory validation
+  // into ValidateTexSubImage2D step.
   uint32 data_size;
   if (!GLES2Util::ComputeImageDataSizes(
       width, height, format, type, state_.unpack_alignment, &data_size,
       NULL, NULL)) {
     return error::kOutOfBounds;
   }
   const void* pixels = GetSharedMemoryAs<const void*>(
       c.data_shm_id, c.data_shm_offset, data_size);
-  if (pixels == NULL) {
-    return error::kOutOfBounds;
+
+  // All the normal glTexSubImage2D validation.
+  error::Error error = error::kNoError;
+  if (!ValidateTexSubImage2D(&error, "glAsyncTexSubImage2D", target, level,
+      xoffset, yoffset, width, height, format, type, pixels)) {
+    return error;
   }
 
-  // TODO(epenner): Do this via an async task.
-  return DoTexSubImage2D(
-      target, level, xoffset, yoffset, width, height, format, type, pixels);
+  // Extra async validation.
+  TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
+  if (!ValidateAsyncTransfer(
+         "glAsyncTexSubImage2D", info, target, level, pixels))
+    return error::kNoError;
+
+  // Guarantee async textures are always 'cleared' as follows:
+  // - AsyncTexImage2D can not redefine an existing texture
+  // - AsyncTexImage2D must initialize the entire image via non-null buffer.
+  // - AsyncTexSubImage2D clears synchronously if not already cleared.
+  // - Textures become immutable after an async call.
+  // This way we know in all cases that an async texture is always clear.
+  if (!info->SafeToRenderFrom()) {
+    if (!texture_manager()->ClearTextureLevel(this, info, target, level)) {
+      SetGLError(
+          GL_OUT_OF_MEMORY, "glAsyncTexSubImage2D", "dimensions too big");
+      return error::kNoError;
+    }
+  }
+
+  // We know the memory/size is safe, so get the real shared memory since
+  // it might need to be duped to prevent use-after-free of the memory.
+  Buffer buffer = GetSharedMemoryBuffer(c.data_shm_id);
+  base::SharedMemory* shared_memory = buffer.shared_memory;
+  uint32 shm_size = buffer.size;
+  uint32 shm_data_offset = c.data_shm_offset;
+  uint32 shm_data_size = data_size;
+
+  if (!info->GetAsyncTransferState()) {
+    // Set up the async state if needed, and make the texture
+    // immutable so the async state stays valid.
+    info->SetAsyncTransferState(
+        async_pixel_transfer_delegate_->
+            CreatePixelTransferState(info->service_id()));
+    info->SetImmutable(true);
+  }
+
+  gfx::AsyncTexSubImage2DParams tex_params = {target, level, xoffset, yoffset,
+                                              width, height, format, type};
+  gfx::AsyncMemoryParams mem_params = {shared_memory, shm_size,
+                                       shm_data_offset, shm_data_size};
+  async_pixel_transfer_delegate_->AsyncTexSubImage2D(
+      info->GetAsyncTransferState(), tex_params, mem_params);
+  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