Rework FlushSync to return early if commands have been processed since the last update

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 74 matching lines @@
   CommandParser* parser_;
   scoped_ptr<AsyncAPIMock> async_api_;
   scoped_ptr<GpuScheduler> scheduler_;
 };
 
 TEST_F(GpuSchedulerTest, SchedulerDoesNothingIfRingBufferIsEmpty) {
   CommandBuffer::State state;
 
   state.put_offset = 0;
   EXPECT_CALL(*command_buffer_, GetState())
-    .WillOnce(Return(state));
+    .WillRepeatedly(Return(state));
   EXPECT_CALL(*command_buffer_, SetGetOffset(0));
 
   EXPECT_CALL(*command_buffer_, SetParseError(_))
     .Times(0);
 
-  scheduler_->ProcessCommands();
+  scheduler_->PutChanged(true);
 }
 
 TEST_F(GpuSchedulerTest, ProcessesOneCommand) {
   CommandHeader* header = reinterpret_cast<CommandHeader*>(&buffer_[0]);
   header[0].command = 7;
   header[0].size = 2;
   buffer_[1] = 123;
 
   CommandBuffer::State state;
 
   state.put_offset = 2;
   EXPECT_CALL(*command_buffer_, GetState())
-    .WillOnce(Return(state));
+    .WillRepeatedly(Return(state));
   EXPECT_CALL(*command_buffer_, SetGetOffset(2));
 
   EXPECT_CALL(*async_api_, DoCommand(7, 1, &buffer_[0]))
     .WillOnce(Return(error::kNoError));
 
   EXPECT_CALL(*command_buffer_, SetParseError(_))
     .Times(0);
 
-  scheduler_->ProcessCommands();
+  scheduler_->PutChanged(true);
 }
 
 TEST_F(GpuSchedulerTest, ProcessesTwoCommands) {
   CommandHeader* header = reinterpret_cast<CommandHeader*>(&buffer_[0]);
   header[0].command = 7;
   header[0].size = 2;
   buffer_[1] = 123;
   header[2].command = 8;
   header[2].size = 1;
 
   CommandBuffer::State state;
 
   state.put_offset = 3;
   EXPECT_CALL(*command_buffer_, GetState())
-    .WillOnce(Return(state));
+    .WillRepeatedly(Return(state));
   EXPECT_CALL(*command_buffer_, SetGetOffset(3));
 
   EXPECT_CALL(*async_api_, DoCommand(7, 1, &buffer_[0]))
     .WillOnce(Return(error::kNoError));
 
   EXPECT_CALL(*async_api_, DoCommand(8, 0, &buffer_[2]))
     .WillOnce(Return(error::kNoError));
 
-  scheduler_->ProcessCommands();
+  scheduler_->PutChanged(true);
 }
 
 TEST_F(GpuSchedulerTest, SchedulerSetsTheGLContext) {
   EXPECT_CALL(*decoder_, MakeCurrent())
     .WillOnce(Return(true))
     .WillOnce(Return(true));
 
   CommandBuffer::State state;
   state.put_offset = 0;
   EXPECT_CALL(*command_buffer_, GetState())
-    .WillOnce(Return(state));
+    .WillRepeatedly(Return(state));
 
   EXPECT_CALL(*command_buffer_, SetGetOffset(0));
 
-  scheduler_->ProcessCommands();
+  scheduler_->PutChanged(true);
 }
 
 TEST_F(GpuSchedulerTest, PostsTaskToFinishRemainingCommands) {
   CommandHeader* header = reinterpret_cast<CommandHeader*>(&buffer_[0]);
   header[0].command = 7;
   header[0].size = 2;
   buffer_[1] = 123;
   header[2].command = 8;
   header[2].size = 1;
   header[3].command = 9;
   header[3].size = 1;
 
   CommandBuffer::State state;
 
   state.put_offset = 4;
   EXPECT_CALL(*command_buffer_, GetState())
-    .WillOnce(Return(state));
+    .WillRepeatedly(Return(state));
 
   EXPECT_CALL(*async_api_, DoCommand(7, 1, &buffer_[0]))
     .WillOnce(Return(error::kNoError));
 
   EXPECT_CALL(*async_api_, DoCommand(8, 0, &buffer_[2]))
     .WillOnce(Return(error::kNoError));
 
   EXPECT_CALL(*command_buffer_, SetGetOffset(3));
 
-  scheduler_->ProcessCommands();
+  scheduler_->PutChanged(true);
 
   // ProcessCommands is called a second time when the pending task is run.
 
   state.put_offset = 4;
   EXPECT_CALL(*command_buffer_, GetState())
-    .WillOnce(Return(state));
+    .WillRepeatedly(Return(state));
 
   EXPECT_CALL(*async_api_, DoCommand(9, 0, &buffer_[3]))
     .WillOnce(Return(error::kNoError));
 
   EXPECT_CALL(*command_buffer_, SetGetOffset(4));
 
   MessageLoop::current()->RunAllPending();
 }
 
 TEST_F(GpuSchedulerTest, SetsErrorCodeOnCommandBuffer) {
   CommandHeader* header = reinterpret_cast<CommandHeader*>(&buffer_[0]);
   header[0].command = 7;
   header[0].size = 1;
 
   CommandBuffer::State state;
 
   state.put_offset = 1;
   EXPECT_CALL(*command_buffer_, GetState())
-    .WillOnce(Return(state));
+    .WillRepeatedly(Return(state));
 
   EXPECT_CALL(*async_api_, DoCommand(7, 0, &buffer_[0]))
     .WillOnce(Return(
         error::kUnknownCommand));
 
   EXPECT_CALL(*command_buffer_,
       SetParseError(error::kUnknownCommand));
 
-  scheduler_->ProcessCommands();
+  scheduler_->PutChanged(true);
 }
 
 TEST_F(GpuSchedulerTest, ProcessCommandsDoesNothingAfterError) {
   CommandBuffer::State state;
   state.error = error::kGenericError;
 
   EXPECT_CALL(*command_buffer_, GetState())
-    .WillOnce(Return(state));
+    .WillRepeatedly(Return(state));
 
-  scheduler_->ProcessCommands();
+  scheduler_->PutChanged(true);
 }
 
 TEST_F(GpuSchedulerTest, CanGetAddressOfSharedMemory) {
   EXPECT_CALL(*command_buffer_.get(), GetTransferBuffer(7))
     .WillOnce(Return(shared_memory_buffer_));
 
   EXPECT_EQ(&buffer_[0], scheduler_->GetSharedMemoryBuffer(7).ptr);
 }
 
 ACTION_P2(SetPointee, address, value) {
   *address = value;
 }
 
 TEST_F(GpuSchedulerTest, CanGetSizeOfSharedMemory) {
   EXPECT_CALL(*command_buffer_.get(), GetTransferBuffer(7))
     .WillOnce(Return(shared_memory_buffer_));
 
   EXPECT_EQ(kRingBufferSize, scheduler_->GetSharedMemoryBuffer(7).size);
 }
 
 TEST_F(GpuSchedulerTest, SetTokenForwardsToCommandBuffer) {
   EXPECT_CALL(*command_buffer_, SetToken(7));
   scheduler_->set_token(7);
 }
 
 }  // namespace gpu