Clean up of GLES2 Command Decoder by moving some of the error state into a separate class.

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>
 #include <map>
 #include <stack>
 #include <string>
 #include <vector>
 
 #include "base/at_exit.h"
 #include "base/atomicops.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #if defined(OS_MACOSX)
 #include "base/mac/scoped_cftyperef.h"
 #endif
 #include "base/memory/scoped_ptr.h"
 #include "base/string_number_conversions.h"
-#include "base/stringprintf.h"
 #include "build/build_config.h"
 #define GLES2_GPU_SERVICE 1
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/common/debug_marker_manager.h"
 #include "gpu/command_buffer/common/id_allocator.h"
 #include "gpu/command_buffer/service/buffer_manager.h"
 #include "gpu/command_buffer/service/cmd_buffer_engine.h"
 #include "gpu/command_buffer/service/context_group.h"
 #include "gpu/command_buffer/service/context_state.h"
+#include "gpu/command_buffer/service/error_state.h"
 #include "gpu/command_buffer/service/feature_info.h"
 #include "gpu/command_buffer/service/framebuffer_manager.h"
 #include "gpu/command_buffer/service/gl_utils.h"
 #include "gpu/command_buffer/service/gles2_cmd_copy_texture_chromium.h"
 #include "gpu/command_buffer/service/gles2_cmd_validation.h"
 #include "gpu/command_buffer/service/gpu_switches.h"
 #include "gpu/command_buffer/service/gpu_tracer.h"
 #include "gpu/command_buffer/service/image_manager.h"
-#include "gpu/command_buffer/service/logger.h"
 #include "gpu/command_buffer/service/mailbox_manager.h"
 #include "gpu/command_buffer/service/memory_tracking.h"
 #include "gpu/command_buffer/service/program_manager.h"
 #include "gpu/command_buffer/service/query_manager.h"
 #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"
@@ skipping 64 matching lines @@
                                range, precision);
   }
 }
 
 }  // namespace
 
 class GLES2DecoderImpl;
 
 // Local versions of the SET_GL_ERROR macros
 #define LOCAL_SET_GL_ERROR(error, function_name, msg) \
-    GLESDECODER_SET_GL_ERROR(this, error, function_name, msg)
+    ERRORSTATE_SET_GL_ERROR(state_.GetErrorState(), error, function_name, msg)
 #define LOCAL_SET_GL_ERROR_INVALID_ENUM(function_name, value, label) \
-    GLESDECODER_SET_GL_ERROR_INVALID_ENUM(this, function_name, value, label)
+    ERRORSTATE_SET_GL_ERROR_INVALID_ENUM(state_.GetErrorState(), \
+                                         function_name, value, label)
 #define LOCAL_SET_GL_ERROR_INVALID_PARAM(error, function_name, pname) \
-    GLESDECODER_SET_GL_ERROR_INVALID_PARAM(this, error, function_name, pname)
+    ERRORSTATE_SET_GL_ERROR_INVALID_PARAM(state_.GetErrorState(), error, \
+                                          function_name, pname)
 #define LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER(function_name) \
-    GLESDECODER_COPY_REAL_GL_ERRORS_TO_WRAPPER(this, function_name)
+    ERRORSTATE_COPY_REAL_GL_ERRORS_TO_WRAPPER(state_.GetErrorState(), \
+                                              function_name)
 #define LOCAL_PEEK_GL_ERROR(function_name) \
-    GLESDECODER_PEEK_GL_ERROR(this, function_name)
+    ERRORSTATE_PEEK_GL_ERROR(state_.GetErrorState(), function_name)
 #define LOCAL_CLEAR_REAL_GL_ERRORS(function_name) \
-    GLESDECODER_CLEARREAL_GL_ERRORS(this, function_name)
+    ERRORSTATE_CLEAR_REAL_GL_ERRORS(state_.GetErrorState(), function_name)
 #define LOCAL_PERFORMANCE_WARNING(msg) \
     PerformanceWarning(__FILE__, __LINE__, msg)
 #define LOCAL_RENDER_WARNING(msg) \
     RenderWarning(__FILE__, __LINE__, msg)
 
 // Check that certain assumptions the code makes are true. There are places in
 // the code where shared memory is passed direclty to GL. Example, glUniformiv,
 // glShaderSource. The command buffer code assumes GLint and GLsizei (and maybe
 // a few others) are 32bits. If they are not 32bits the code will have to change
 // to call those GL functions with service side memory and then copy the results
@@ skipping 402 matching lines @@
          gfx::GetGLImplementation() == gfx::kGLImplementationEGLGLES2;
 #else
   return testing_force_is_angle_;
 #endif
 }
 
 // This class implements GLES2Decoder so we don't have to expose all the GLES2
 // cmd stuff to outside this class.
 class GLES2DecoderImpl : public GLES2Decoder {
  public:
-  static const int kMaxLogMessages = 256;
-
   // Used by PrepForSetUniformByLocation to validate types.
   struct BaseUniformInfo {
     const GLenum* const valid_types;
     size_t num_valid_types;
   };
 
   explicit GLES2DecoderImpl(ContextGroup* group);
   virtual ~GLES2DecoderImpl();
 
   // Overridden from AsyncAPIInterface.
@@ skipping 57 matching lines @@
     return vertex_array_manager_.get();
   }
   virtual bool ProcessPendingQueries() OVERRIDE;
   virtual bool HasMoreIdleWork() OVERRIDE;
   virtual void PerformIdleWork() OVERRIDE;
 
   virtual void SetResizeCallback(
       const base::Callback<void(gfx::Size)>& callback) OVERRIDE;
 
   virtual Logger* GetLogger() OVERRIDE;
+  virtual ErrorState * GetErrorState() OVERRIDE;

[greggman, 2013/04/17 00:15:29]

nit: no space before '*'

[kloveless, 2013/04/17 14:58:01]

Done.

 
   virtual void SetShaderCacheCallback(
       const ShaderCacheCallback& callback) OVERRIDE;
   virtual void SetWaitSyncPointCallback(
       const WaitSyncPointCallback& callback) OVERRIDE;
 
   virtual void SetStreamTextureManager(StreamTextureManager* manager) OVERRIDE;
 
   virtual gfx::AsyncPixelTransferDelegate*
       GetAsyncPixelTransferDelegate() OVERRIDE;
   virtual void SetAsyncPixelTransferDelegate(
       gfx::AsyncPixelTransferDelegate* delegate) OVERRIDE;
   void ProcessFinishedAsyncTransfers();
 
   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;
 
   // Restores the current state to the user's settings.
   void RestoreCurrentFramebufferBindings();
   void RestoreCurrentRenderbufferBindings();
   void RestoreCurrentTexture2DBindings();
 
@@ skipping 728 matching lines @@
   void DoValidateProgram(GLuint program_client_id);
 
   void DoInsertEventMarkerEXT(GLsizei length, const GLchar* marker);
   void DoPushGroupMarkerEXT(GLsizei length, const GLchar* group);
   void DoPopGroupMarkerEXT(void);
 
   // Gets the number of values that will be returned by glGetXXX. Returns
   // false if pname is unknown.
   bool GetNumValuesReturnedForGLGet(GLenum pname, GLsizei* num_values);
 
-  virtual void SetGLError(
-      const char* filename,
-      int line,
-      unsigned error,
-      const char* function_name,
-      const char* msg) OVERRIDE;
-  virtual void SetGLErrorInvalidEnum(
-      const char* filename,
-      int line,
-      const char* function_name,
-      unsigned value,
-      const char* label) OVERRIDE;
-  // Generates a GL error for a bad parameter.
-  virtual void SetGLErrorInvalidParam(
-      const char* filename,
-      int line,
-      unsigned error,
-      const char* function_name,
-      unsigned pname,
-      int param) OVERRIDE;
-
-  virtual unsigned PeekGLError(
-      const char* filename, int line, const char* function_name) OVERRIDE;
-  virtual void CopyRealGLErrorsToWrapper(
-      const char* filename, int line, const char* function_name) OVERRIDE;
-  virtual void ClearRealGLErrors(
-      const char* filename, int line, const char* function_name) OVERRIDE;
-
   // Checks if the current program and vertex attributes are valid for drawing.
   bool IsDrawValid(
       const char* function_name, GLuint max_vertex_accessed, GLsizei primcount);
 
   // Returns true if successful, simulated will be true if attrib0 was
   // simulated.
   bool SimulateAttrib0(
       const char* function_name, GLuint max_vertex_accessed, bool* simulated);
   void RestoreStateForAttrib(GLuint attrib);
 
@@ skipping 207 matching lines @@
   // All the state for this context.
   ContextState state_;
 
   // A parent decoder can access this decoders saved offscreen frame buffer.
   // The parent pointer is reset if the parent is destroyed.
   base::WeakPtr<GLES2DecoderImpl> parent_;
 
   // Current width and height of the offscreen frame buffer.
   gfx::Size offscreen_size_;
 
-  // Current GL error bits.
-  uint32 error_bits_;
-
   // Util to help with GL.
   GLES2Util util_;
 
   // unpack flip y as last set by glPixelStorei
   bool unpack_flip_y_;
 
   // unpack (un)premultiply alpha as last set by glPixelStorei
   bool unpack_premultiply_alpha_;
   bool unpack_unpremultiply_alpha_;
 
@@ skipping 64 matching lines @@
   // 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_;
 
-  // The last error message set.
-  std::string last_error_;
-
   // The current decoder error.
   error::Error current_decoder_error_;
 
   bool use_shader_translator_;
   scoped_refptr<ShaderTranslator> vertex_translator_;
   scoped_refptr<ShaderTranslator> fragment_translator_;
 
   DisallowedFeatures disallowed_features_;
 
   // Cached from ContextGroup
@@ skipping 43 matching lines @@
 
   scoped_ptr<GPUTracer> gpu_tracer_;
 
   DISALLOW_COPY_AND_ASSIGN(GLES2DecoderImpl);
 };
 
 ScopedGLErrorSuppressor::ScopedGLErrorSuppressor(
     const char* function_name, GLES2DecoderImpl* decoder)
     : function_name_(function_name),
       decoder_(decoder) {
-  GLESDECODER_COPY_REAL_GL_ERRORS_TO_WRAPPER(decoder_, function_name_);
+  ERRORSTATE_COPY_REAL_GL_ERRORS_TO_WRAPPER(decoder_->GetErrorState(),
+                                            function_name_);
 }
 
 ScopedGLErrorSuppressor::~ScopedGLErrorSuppressor() {
-  GLESDECODER_CLEAR_REAL_GL_ERRORS(decoder_, function_name_);
+  ERRORSTATE_CLEAR_REAL_GL_ERRORS(decoder_->GetErrorState(), function_name_);
 }
 
 ScopedTexture2DBinder::ScopedTexture2DBinder(GLES2DecoderImpl* decoder,
                                              GLuint id)
     : decoder_(decoder) {
   ScopedGLErrorSuppressor suppressor(
       "ScopedTexture2DBinder::ctor", decoder_);
 
   // TODO(apatrick): Check if there are any other states that need to be reset
   // before binding a new texture.
@@ skipping 362 matching lines @@
 }
 
 GLES2Decoder* GLES2Decoder::Create(ContextGroup* group) {
   return new GLES2DecoderImpl(group);
 }
 
 GLES2DecoderImpl::GLES2DecoderImpl(ContextGroup* group)
     : GLES2Decoder(),
       group_(group),
       logger_(&debug_marker_manager_),
-      state_(group_->feature_info()),
-      error_bits_(0),
+      state_(group_->feature_info(), &logger_),
       unpack_flip_y_(false),
       unpack_premultiply_alpha_(false),
       unpack_unpremultiply_alpha_(false),
       attrib_0_buffer_id_(0),
       attrib_0_buffer_matches_value_(true),
       attrib_0_size_(0),
       fixed_attrib_buffer_id_(0),
       fixed_attrib_buffer_size_(0),
       clear_state_dirty_(true),
       offscreen_target_color_format_(0),
@@ skipping 865 matching lines @@
         GL_RGBA,
         offscreen_size_.width(),
         offscreen_size_.height(),
         1,  // depth
         0,  // border
         GL_RGBA,
         GL_UNSIGNED_BYTE,
         true);
     parent_texture_manager->SetParameter(
         "UpdateParentTextureInfo",
-        this,
+        GetErrorState(),
         offscreen_saved_color_texture_info_,
         GL_TEXTURE_MAG_FILTER,
         GL_NEAREST);
     parent_texture_manager->SetParameter(
         "UpdateParentTextureInfo",
-        this,
+        GetErrorState(),
         offscreen_saved_color_texture_info_,
         GL_TEXTURE_MIN_FILTER,
         GL_NEAREST);
     parent_texture_manager->SetParameter(
         "UpdateParentTextureInfo",
-        this,
+        GetErrorState(),
         offscreen_saved_color_texture_info_,
         GL_TEXTURE_WRAP_S,
         GL_CLAMP_TO_EDGE);
     parent_texture_manager->SetParameter(
         "UpdateParentTextureInfo",
-        this,
+        GetErrorState(),
         offscreen_saved_color_texture_info_,
         GL_TEXTURE_WRAP_T,
         GL_CLAMP_TO_EDGE);
   } else {
     offscreen_saved_color_texture_info_ = NULL;
   }
 }
 
 void GLES2DecoderImpl::SetResizeCallback(
     const base::Callback<void(gfx::Size)>& callback) {
   resize_callback_ = callback;
 }
 
 Logger* GLES2DecoderImpl::GetLogger() {
   return &logger_;
 }
 
+ErrorState * GLES2DecoderImpl::GetErrorState() {

[dsinclair, 2013/04/17 00:39:09]

nit: no space before *

[kloveless, 2013/04/17 14:58:01]

Done.

+  return state_.GetErrorState();
+}
+
 void GLES2DecoderImpl::SetShaderCacheCallback(
     const ShaderCacheCallback& callback) {
   shader_cache_callback_ = callback;
 }
 
 void GLES2DecoderImpl::SetWaitSyncPointCallback(
     const WaitSyncPointCallback& callback) {
   wait_sync_point_callback_ = callback;
 }
 
@@ skipping 2101 matching lines @@
 
 void GLES2DecoderImpl::DoTexParameterf(
     GLenum target, GLenum pname, GLfloat param) {
   Texture* texture = GetTextureInfoForTarget(target);
   if (!texture) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glTexParameterf", "unknown texture");
     return;
   }
 
   texture_manager()->SetParameter(
-      "glTexParameterf", this, texture, pname, static_cast<GLint>(param));
+      "glTexParameterf", GetErrorState(), texture, pname,
+      static_cast<GLint>(param));
 }
 
 void GLES2DecoderImpl::DoTexParameteri(
     GLenum target, GLenum pname, GLint param) {
   Texture* texture = GetTextureInfoForTarget(target);
   if (!texture) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glTexParameteri", "unknown texture");
     return;
   }
 
   texture_manager()->SetParameter(
-      "glTexParameteri", this, texture, pname, param);
+      "glTexParameteri", GetErrorState(), texture, pname, param);
 }
 
 void GLES2DecoderImpl::DoTexParameterfv(
     GLenum target, GLenum pname, const GLfloat* params) {
   Texture* texture = GetTextureInfoForTarget(target);
   if (!texture) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glTexParameterfv", "unknown texture");
     return;
   }
 
   texture_manager()->SetParameter(
-      "glTexParameterfv", this, texture, pname, static_cast<GLint>(params[0]));
+      "glTexParameterfv", GetErrorState(), texture, pname,
+      static_cast<GLint>(params[0]));
 }
 
 void GLES2DecoderImpl::DoTexParameteriv(
   GLenum target, GLenum pname, const GLint* params) {
   Texture* texture = GetTextureInfoForTarget(target);
   if (!texture) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE, "glTexParameteriv", "unknown texture");
     return;
   }
 
   texture_manager()->SetParameter(
-      "glTexParameteriv", this, texture, pname, *params);
+      "glTexParameteriv", GetErrorState(), texture, pname, *params);
 }
 
 bool GLES2DecoderImpl::CheckCurrentProgram(const char* function_name) {
   if (!state_.current_program) {
     // The program does not exist.
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION, function_name, "no program in use");
     return false;
   }
   if (!state_.current_program->InUse()) {
@@ skipping 390 matching lines @@
     program_manager()->UnuseProgram(shader_manager(), state_.current_program);
   }
   state_.current_program = program;
   LogClientServiceMapping("glUseProgram", program_id, service_id);
   glUseProgram(service_id);
   if (state_.current_program) {
     program_manager()->UseProgram(state_.current_program);
   }
 }
 
-uint32 GLES2DecoderImpl::GetGLError() {
-  // Check the GL error first, then our wrapped error.
-  GLenum error = glGetError();
-  if (error == GL_NO_ERROR && error_bits_ != 0) {
-    for (uint32 mask = 1; mask != 0; mask = mask << 1) {
-      if ((error_bits_ & mask) != 0) {
-        error = GLES2Util::GLErrorBitToGLError(mask);
-        break;
-      }
-    }
-  }
-
-  if (error != GL_NO_ERROR) {
-    // There was an error, clear the corresponding wrapped error.
-    error_bits_ &= ~GLES2Util::GLErrorToErrorBit(error);
-  }
-  return error;
-}
-
-unsigned GLES2DecoderImpl::PeekGLError(
-    const char* filename, int line, const char* function_name) {
-  GLenum error = glGetError();
-  if (error != GL_NO_ERROR) {
-    SetGLError(filename, line, error, function_name, "");
-  }
-  return error;
-}
-
-void GLES2DecoderImpl::SetGLError(
-    const char* filename, int line,
-    unsigned error, const char* function_name, const char* msg) {
-  if (msg) {
-    last_error_ = msg;
-    logger_.LogMessage(filename, line,
-               logger_.GetLogPrefix() + ": " + std::string("GL ERROR :") +
-               GLES2Util::GetStringEnum(error) + " : " +
-               function_name + ": " + msg);
-  }
-  error_bits_ |= GLES2Util::GLErrorToErrorBit(error);
-}
-
-void GLES2DecoderImpl::SetGLErrorInvalidEnum(
-    const char* filename, int line,
-    const char* function_name, unsigned value, const char* label) {
-  SetGLError(filename, line, GL_INVALID_ENUM, function_name,
-             (std::string(label) + " was " +
-              GLES2Util::GetStringEnum(value)).c_str());
-}
-
-void GLES2DecoderImpl::SetGLErrorInvalidParam(
-    const char* filename,
-    int line,
-    unsigned error,
-    const char* function_name,
-    unsigned pname,
-    int param) {
-  if (error == GL_INVALID_ENUM) {
-    SetGLError(
-        filename, line, GL_INVALID_ENUM, function_name,
-        (std::string("trying to set ") +
-         GLES2Util::GetStringEnum(pname) + " to " +
-         GLES2Util::GetStringEnum(param)).c_str());
-  } else {
-    SetGLError(
-        filename, line, error, function_name,
-        (std::string("trying to set ") +
-         GLES2Util::GetStringEnum(pname) + " to " +
-         base::StringPrintf("%d", param)).c_str());
-  }
-}
-
 void GLES2DecoderImpl::RenderWarning(
     const char* filename, int line, const std::string& msg) {
   logger_.LogMessage(filename, line, std::string("RENDER WARNING: ") + msg);
 }
 
 void GLES2DecoderImpl::PerformanceWarning(
     const char* filename, int line, const std::string& msg) {
-  logger_.LogMessage(filename, line, std::string("PERFORMANCE WARNING: ")
-                     + msg);
+  logger_.LogMessage(filename, line,
+                     std::string("PERFORMANCE WARNING: ") + msg);
 }
 
 void GLES2DecoderImpl::ForceCompileShaderIfPending(Shader* shader) {
   if (shader->compilation_status() ==
       Shader::PENDING_DEFERRED_COMPILE) {
     ShaderTranslator* translator = NULL;
     if (use_shader_translator_) {
       translator = shader->shader_type() == GL_VERTEX_SHADER ?
           vertex_translator_.get() : fragment_translator_.get();
     }
     // We know there will be no errors, because we only defer compilation on
     // shaders that were previously compiled successfully.
     program_manager()->ForceCompileShader(shader->deferred_compilation_source(),
                                           shader,
                                           translator,
                                           feature_info_);
   }
 }
 
-void GLES2DecoderImpl::CopyRealGLErrorsToWrapper(
-    const char* filename, int line, const char* function_name) {
-  GLenum error;
-  while ((error = glGetError()) != GL_NO_ERROR) {
-    SetGLError(filename, line, error, function_name,
-               "<- error from previous GL command");
-  }
-}
-
-void GLES2DecoderImpl::ClearRealGLErrors(
-    const char* filename, int line, const char* function_name) {
-  GLenum error;
-  while ((error = glGetError()) != GL_NO_ERROR) {
-    if (error != GL_OUT_OF_MEMORY) {
-      // GL_OUT_OF_MEMORY can legally happen on lost device.
-      logger_.LogMessage(filename, line,
-                 logger_.GetLogPrefix() + ": " + std::string("GL ERROR :") +
-                 GLES2Util::GetStringEnum(error) + " : " +
-                 function_name + ": was unhandled");
-      NOTREACHED() << "GL error " << error << " was unhandled.";
-    }
-  }
-}
-
 bool GLES2DecoderImpl::SetBlackTextureForNonRenderableTextures() {
   DCHECK(state_.current_program);
   // Only check if there are some unrenderable textures.
   if (!texture_manager()->HaveUnrenderableTextures()) {
     return false;
   }
   bool textures_set = false;
   const Program::SamplerIndices& sampler_indices =
      state_.current_program->sampler_indices();
   for (size_t ii = 0; ii < sampler_indices.size(); ++ii) {
@@ skipping 1544 matching lines @@
   if (!buffer) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glBufferData", "unknown buffer");
     return;
   }
 
   if (!EnsureGPUMemoryAvailable(size)) {
     LOCAL_SET_GL_ERROR(GL_OUT_OF_MEMORY, "glBufferData", "out of memory");
     return;
   }
 
-  buffer_manager()->DoBufferData(this, buffer, size, usage, data);
+  buffer_manager()->DoBufferData(GetErrorState(), buffer, size, usage, data);
 }
 
 error::Error GLES2DecoderImpl::HandleBufferData(
     uint32 immediate_data_size, const cmds::BufferData& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLsizeiptr size = static_cast<GLsizeiptr>(c.size);
   uint32 data_shm_id = static_cast<uint32>(c.data_shm_id);
   uint32 data_shm_offset = static_cast<uint32>(c.data_shm_offset);
   GLenum usage = static_cast<GLenum>(c.usage);
   const void* data = NULL;
@@ skipping 22 matching lines @@
 }
 
 void GLES2DecoderImpl::DoBufferSubData(
   GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid * data) {
   Buffer* buffer = GetBufferInfoForTarget(target);
   if (!buffer) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glBufferSubData", "unknown buffer");
     return;
   }
 
-  buffer_manager()->DoBufferSubData(this, buffer, offset, size, data);
+  buffer_manager()->DoBufferSubData(GetErrorState(), buffer, offset, size,
+                                    data);
 }
 
 bool GLES2DecoderImpl::ClearLevel(
     unsigned service_id,
     unsigned bind_target,
     unsigned target,
     int level,
     unsigned format,
     unsigned type,
     int width,
@@ skipping 3067 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