WebGraphicsContext3DCommandBufferImpl cleanup, Canvas2D thottling fix, GpuScheduler fix.

gpu/command_buffer/service/gpu_scheduler_unittest.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 "base/mac/scoped_nsautorelease_pool.h"
 #include "base/message_loop.h"
 #include "gpu/command_buffer/common/command_buffer_mock.h"
 #include "gpu/command_buffer/service/gpu_scheduler.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder_mock.h"
@@ skipping 26 matching lines @@
 
     command_buffer_.reset(new MockCommandBuffer);
     ON_CALL(*command_buffer_.get(), GetRingBuffer())
       .WillByDefault(Return(shared_memory_buffer_));
 
     CommandBuffer::State default_state;
     default_state.num_entries = kRingBufferEntries;
     ON_CALL(*command_buffer_.get(), GetState())
       .WillByDefault(Return(default_state));
 
-    async_api_.reset(new StrictMock<AsyncAPIMock>);
+    async_api_.reset(new StrictMock<SpecializedAsyncAPIMock>);

[jamesr, 2011/06/03 19:09:32]

what's so special about this mock?  in what way is it more specialized than any
other mock?

[jbates, 2011/06/03 21:27:32]

Isn't that similar to asking in what way is the AsyncAPI class Async? You have
to look at its definition to find out in both cases :P It is a specialized
subclass of the mock: it overrides the method that the mock provides and
specializes it. Anyway, I made the class name longer since this tripped up both
reviewers.

 
     decoder_ = new gles2::MockGLES2Decoder();
 
     parser_ = new CommandParser(buffer_,
                                 kRingBufferEntries,
                                 0,
                                 kRingBufferEntries,
                                 0,
                                 async_api_.get());
 
@@ skipping 96 matching lines @@
 
   CommandBuffer::State state;
   state.put_offset = 0;
   EXPECT_CALL(*command_buffer_, GetState())
     .WillRepeatedly(Return(state));
 
   scheduler_->PutChanged(true);
 }
 
 TEST_F(GpuSchedulerTest, PostsTaskToFinishRemainingCommands) {
+  unsigned int pauseCmd = SpecializedAsyncAPIMock::kTestPauseCommand;
   CommandHeader* header = reinterpret_cast<CommandHeader*>(&buffer_[0]);
   header[0].command = 7;
   header[0].size = 2;
   buffer_[1] = 123;
-  header[2].command = 8;
+  header[2].command = pauseCmd;
   header[2].size = 1;
   header[3].command = 9;
   header[3].size = 1;
 
   CommandBuffer::State state;
 
   state.put_offset = 4;
   EXPECT_CALL(*command_buffer_, GetState())
     .WillRepeatedly(Return(state));
 
   EXPECT_CALL(*async_api_, DoCommand(7, 1, &buffer_[0]))
     .WillOnce(Return(error::kNoError));
   EXPECT_CALL(*command_buffer_, SetGetOffset(2));
 
-  EXPECT_CALL(*async_api_, DoCommand(8, 0, &buffer_[2]))
+  EXPECT_CALL(*async_api_, DoCommand(pauseCmd, 0, &buffer_[2]))
     .WillOnce(Return(error::kNoError));
   EXPECT_CALL(*command_buffer_, SetGetOffset(3));
 
   scheduler_->PutChanged(true);
 
   // ProcessCommands is called a second time when the pending task is run.
 
   state.put_offset = 4;
   EXPECT_CALL(*command_buffer_, GetState())
     .WillRepeatedly(Return(state));
@@ skipping 55 matching lines @@
 
   EXPECT_EQ(kRingBufferSize, scheduler_->GetSharedMemoryBuffer(7).size);
 }
 
 TEST_F(GpuSchedulerTest, SetTokenForwardsToCommandBuffer) {
   EXPECT_CALL(*command_buffer_, SetToken(7));
   scheduler_->set_token(7);
 }
 
 }  // namespace gpu