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

gpu/command_buffer/service/buffer_manager.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/buffer_manager.h"
 #include <limits>
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
+#include "gpu/command_buffer/service/error_state.h"
 #include "gpu/command_buffer/service/feature_info.h"
-#include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "gpu/command_buffer/service/memory_tracking.h"
 #include "ui/gl/gl_bindings.h"
 
 namespace gpu {
 namespace gles2 {
 
 BufferManager::BufferManager(
     MemoryTracker* memory_tracker,
     FeatureInfo* feature_info)
     : memory_tracker_(
@@ skipping 224 matching lines @@
   memory_tracker_->TrackMemFree(buffer->size());
   bool is_client_side_array = IsUsageClientSideArray(usage);
   bool shadow = buffer->target() == GL_ELEMENT_ARRAY_BUFFER ||
                 allow_buffers_on_multiple_targets_ ||
                 is_client_side_array;
   buffer->SetInfo(size, usage, shadow, data, is_client_side_array);
   memory_tracker_->TrackMemAlloc(buffer->size());
 }
 
 void BufferManager::DoBufferData(
-    GLES2Decoder* decoder,
+    ErrorState* error_state,
     Buffer* buffer,
     GLsizeiptr size,
     GLenum usage,
     const GLvoid* data) {
   // Clear the buffer to 0 if no initial data was passed in.
   scoped_ptr<int8[]> zero;
   if (!data) {
     zero.reset(new int8[size]);
     memset(zero.get(), 0, size);
     data = zero.get();
   }
 
-  GLESDECODER_COPY_REAL_GL_ERRORS_TO_WRAPPER(decoder, "glBufferData");
+  ERRORSTATE_COPY_REAL_GL_ERRORS_TO_WRAPPER(error_state, "glBufferData");
   if (IsUsageClientSideArray(usage)) {
     glBufferData(buffer->target(), 0, NULL, usage);
   } else {
     glBufferData(buffer->target(), size, data, usage);
   }
-  GLenum error = GLESDECODER_PEEK_GL_ERROR(decoder, "glBufferData");
+  GLenum error = ERRORSTATE_PEEK_GL_ERROR(error_state, "glBufferData");
   if (error == GL_NO_ERROR) {
     SetInfo(buffer, size, usage, data);
   } else {
     SetInfo(buffer, 0, usage, NULL);
   }
 }
 
 void BufferManager::DoBufferSubData(
-    GLES2Decoder* decoder,
+    ErrorState* error_state,
     Buffer* buffer,
     GLintptr offset,
     GLsizeiptr size,
     const GLvoid* data) {
   if (!buffer->SetRange(offset, size, data)) {
-    GLESDECODER_SET_GL_ERROR(
-        decoder, GL_INVALID_VALUE, "glBufferSubData", "out of range");
+    ERRORSTATE_SET_GL_ERROR(
+        error_state, GL_INVALID_VALUE, "glBufferSubData", "out of range");
     return;
   }
 
   if (!buffer->IsClientSideArray()) {
     glBufferSubData(buffer->target(), offset, size, data);
   }
 }
 
 bool BufferManager::SetTarget(Buffer* buffer, GLenum target) {
   // Check that we are not trying to bind it to a different target.
   if (buffer->target() != 0 && buffer->target() != target &&
       !allow_buffers_on_multiple_targets_) {
     return false;
   }
   if (buffer->target() == 0) {
     buffer->set_target(target);
   }
   return true;
 }
 
 }  // namespace gles2
 }  // namespace gpu