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

gpu/command_buffer/service/buffer_manager_unittest.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 "gpu/command_buffer/service/error_state_mock.h"
 #include "gpu/command_buffer/service/feature_info.h"
-#include "gpu/command_buffer/service/gles2_cmd_decoder_mock.h"
 #include "gpu/command_buffer/service/mocks.h"
 #include "gpu/command_buffer/service/test_helper.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gl/gl_mock.h"
 
 using ::testing::_;
 using ::testing::Return;
 using ::testing::StrictMock;
 
 namespace gpu {
 namespace gles2 {
 
 class BufferManagerTestBase : public testing::Test {
  protected:
   void SetUpBase(
       MemoryTracker* memory_tracker,
       FeatureInfo* feature_info,
       const char* extensions) {
     gl_.reset(new ::testing::StrictMock< ::gfx::MockGLInterface>());
     ::gfx::GLInterface::SetGLInterface(gl_.get());
     if (feature_info) {
       TestHelper::SetupFeatureInfoInitExpectations(gl_.get(), extensions);
       feature_info->Initialize(NULL);
     }
-    decoder_.reset(new MockGLES2Decoder());
+    error_state_.reset(new MockErrorState());
     manager_.reset(new BufferManager(memory_tracker, feature_info));
   }
 
   virtual void TearDown() {
     manager_->Destroy(false);
     manager_.reset();
     ::gfx::GLInterface::SetGLInterface(NULL);
-    decoder_.reset();
+    error_state_.reset();
     gl_.reset();
   }
 
   GLenum GetTarget(const Buffer* buffer) const {
     return buffer->target();
   }
 
   void DoBufferData(
       Buffer* buffer, GLsizeiptr size, GLenum usage, const GLvoid* data,
       GLenum error) {
     TestHelper::DoBufferData(
-        gl_.get(), decoder_.get(), manager_.get(),
+        gl_.get(), error_state_.get(), manager_.get(),
         buffer, size, usage, data, error);
   }
 
   bool DoBufferSubData(
       Buffer* buffer, GLintptr offset, GLsizeiptr size,
       const GLvoid* data) {
     bool success = true;
     if (!buffer->CheckRange(offset, size)) {
-      EXPECT_CALL(*decoder_, SetGLError(_, _, GL_INVALID_VALUE, _, _))
-          .Times(1)
-          .RetiresOnSaturation();
+      EXPECT_CALL(*error_state_, SetGLError(_, _, GL_INVALID_VALUE, _, _))
+         .Times(1)
+         .RetiresOnSaturation();
       success = false;
     } else if (!buffer->IsClientSideArray()) {
       EXPECT_CALL(*gl_, BufferSubData(
           buffer->target(), offset, size, _))
           .Times(1)
           .RetiresOnSaturation();
     }
     manager_->DoBufferSubData(
-        decoder_.get(), buffer, offset, size, data);
+        error_state_.get(), buffer, offset, size, data);
     return success;
   }
 
   // Use StrictMock to make 100% sure we know how GL will be called.
   scoped_ptr< ::testing::StrictMock< ::gfx::MockGLInterface> > gl_;
   scoped_ptr<BufferManager> manager_;
-  scoped_ptr<MockGLES2Decoder> decoder_;
+  scoped_ptr<MockErrorState> error_state_;
 };
 
 class BufferManagerTest : public BufferManagerTestBase {
  protected:
   virtual void SetUp() {
     SetUpBase(NULL, NULL, "");
   }
 };
 
 class BufferManagerMemoryTrackerTest : public BufferManagerTestBase {
@@ skipping 295 matching lines @@
   EXPECT_TRUE(buffer->IsClientSideArray());
   EXPECT_EQ(0, memcmp(data, buffer->GetRange(0, sizeof(data)), sizeof(data)));
   DoBufferData(buffer, sizeof(data), GL_DYNAMIC_DRAW, data, GL_NO_ERROR);
   EXPECT_FALSE(buffer->IsClientSideArray());
 }
 
 }  // namespace gles2
 }  // namespace gpu