Add commands Jump, Call and Return...

gpu/command_buffer/client/cmd_buffer_helper_test.cc

 // Copyright (c) 2009 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.
 
 // Tests for the Command Buffer Helper.
 
 #include "base/at_exit.h"
 #include "base/message_loop.h"
 #include "gpu/command_buffer/client/cmd_buffer_helper.h"
 #include "gpu/command_buffer/service/mocks.h"
@@ skipping 17 matching lines @@
 
 // Test fixture for CommandBufferHelper test - Creates a CommandBufferHelper,
 // using a CommandBufferEngine with a mock AsyncAPIInterface for its interface
 // (calling it directly, not through the RPC mechanism).
 class CommandBufferHelperTest : public testing::Test {
  protected:
   virtual void SetUp() {
     api_mock_.reset(new AsyncAPIMock);
     // ignore noops in the mock - we don't want to inspect the internals of the
     // helper.
-    EXPECT_CALL(*api_mock_, DoCommand(0, 0, _))
+    EXPECT_CALL(*api_mock_, DoCommand(0, _, _))
         .WillRepeatedly(Return(parse_error::kParseNoError));
 
     command_buffer_.reset(new CommandBufferService);
     command_buffer_->Initialize(kNumCommandEntries);
     Buffer ring_buffer = command_buffer_->GetRingBuffer();
 
     parser_ = new CommandParser(ring_buffer.ptr,
                                 ring_buffer.size,
                                 0,
                                 ring_buffer.size,
@@ skipping 14 matching lines @@
   virtual void TearDown() {
     // If the GPUProcessor posts any tasks, this forces them to run.
     MessageLoop::current()->RunAllPending();
     helper_.release();
   }
 
   // Adds a command to the buffer through the helper, while adding it as an
   // expected call on the API mock.
   void AddCommandWithExpect(parse_error::ParseError _return,
                             unsigned int command,
-                            unsigned int arg_count,
+                            int arg_count,
                             CommandBufferEntry *args) {
-    helper_->AddCommand(command, arg_count, args);
+    CommandHeader header;
+    header.size = arg_count + 1;
+    header.command = command;
+    CommandBufferEntry* cmds = helper_->GetSpace(arg_count + 1);
+    CommandBufferOffset put = 0;
+    cmds[put++].value_header = header;
+    for (int ii = 0; ii < arg_count; ++ii) {
+      cmds[put++] = args[ii];
+    }
+
     EXPECT_CALL(*api_mock_, DoCommand(command, arg_count,
         Truly(AsyncAPIMock::IsArgs(arg_count, args))))
         .InSequence(sequence_)
         .WillOnce(Return(_return));
   }
 
   // Checks that the buffer from put to put+size is free in the parser.
   void CheckFreeSpace(CommandBufferOffset put, unsigned int size) {
     CommandBufferOffset parser_put = parser_->put();
     CommandBufferOffset parser_get = parser_->get();
@@ skipping 171 matching lines @@
 
   // Check that the commands did happen.
   Mock::VerifyAndClearExpectations(api_mock_.get());
 
   // Check the error status.
   EXPECT_FALSE(command_buffer_->GetErrorStatus());
   EXPECT_EQ(parse_error::kParseNoError, command_buffer_->ResetParseError());
 }
 
 }  // namespace gpu