Redesigned CommandBuffer and NPDevice3D interfaces

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 84 matching lines @@
       if (put >= parser_put) {
         // we're on the top side, check we are below the limit.
         EXPECT_GE(kNumCommandEntries, limit);
       } else {
         // we're on the bottom side, check we are below get.
         EXPECT_GT(parser_get, limit);
       }
     }
   }
 
+  int32 GetGetOffset() {
+    return command_buffer_->GetState().get_offset;
+  }
+
+  int32 GetPutOffset() {
+    return command_buffer_->GetState().put_offset;
+  }
+
+  parse_error::ParseError GetError() {
+    return command_buffer_->GetState().error;
+  }
+
   CommandBufferOffset get_helper_put() { return helper_->put_; }
 
   base::AtExitManager at_exit_manager_;
   MessageLoop message_loop_;
   scoped_ptr<AsyncAPIMock> api_mock_;
   scoped_ptr<CommandBufferService> command_buffer_;
   CommandParser* parser_;
   scoped_ptr<CommandBufferHelper> helper_;
   Sequence sequence_;
 };
 
 // Checks that commands in the buffer are properly executed, and that the
 // status/error stay valid.
 TEST_F(CommandBufferHelperTest, TestCommandProcessing) {
   // Check initial state of the engine - it should have been configured by the
   // helper.
   EXPECT_TRUE(parser_ != NULL);
-  EXPECT_FALSE(command_buffer_->GetErrorStatus());
-  EXPECT_EQ(parse_error::kParseNoError, command_buffer_->ResetParseError());
-  EXPECT_EQ(0, command_buffer_->GetGetOffset());
+  EXPECT_EQ(parse_error::kParseNoError, GetError());
+  EXPECT_EQ(0, GetGetOffset());
 
   // Add 3 commands through the helper
   AddCommandWithExpect(parse_error::kParseNoError, 1, 0, NULL);
 
   CommandBufferEntry args1[2];
   args1[0].value_uint32 = 3;
   args1[1].value_float = 4.f;
   AddCommandWithExpect(parse_error::kParseNoError, 2, 2, args1);
 
   CommandBufferEntry args2[2];
   args2[0].value_uint32 = 5;
   args2[1].value_float = 6.f;
   AddCommandWithExpect(parse_error::kParseNoError, 3, 2, args2);
 
   helper_->Flush();
   // Check that the engine has work to do now.
   EXPECT_FALSE(parser_->IsEmpty());
 
   // Wait until it's done.
   helper_->Finish();
   // Check that the engine has no more work to do.
   EXPECT_TRUE(parser_->IsEmpty());
 
   // 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());
+  EXPECT_EQ(parse_error::kParseNoError, GetError());
 }
 
 // Checks that commands in the buffer are properly executed when wrapping the
 // buffer, and that the status/error stay valid.
 TEST_F(CommandBufferHelperTest, TestCommandWrapping) {
   // Add 5 commands of size 3 through the helper to make sure we do wrap.
   CommandBufferEntry args1[2];
   args1[0].value_uint32 = 3;
   args1[1].value_float = 4.f;
 
   for (unsigned int i = 0; i < 5; ++i) {
     AddCommandWithExpect(parse_error::kParseNoError, i + 1, 2, args1);
   }
 
   helper_->Finish();
   // 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());
-}
-
-
-// Checks that commands in the buffer are properly executed, even if they
-// generate a recoverable error. Check that the error status is properly set,
-// and reset when queried.
-TEST_F(CommandBufferHelperTest, TestRecoverableError) {
-  CommandBufferEntry args[2];
-  args[0].value_uint32 = 3;
-  args[1].value_float = 4.f;
-
-  // Create a command buffer with 3 commands, 2 of them generating errors
-  AddCommandWithExpect(parse_error::kParseNoError, 1, 2, args);
-  AddCommandWithExpect(parse_error::kParseUnknownCommand, 2, 2, args);
-  AddCommandWithExpect(parse_error::kParseInvalidArguments, 3, 2,
-                       args);
-
-  helper_->Finish();
-  // Check that the commands did happen.
-  Mock::VerifyAndClearExpectations(api_mock_.get());
-
-  // Check that the error status was set to the first error.
-  EXPECT_EQ(parse_error::kParseUnknownCommand,
-            command_buffer_->ResetParseError());
-  // Check that the error status was reset after the query.
-  EXPECT_EQ(parse_error::kParseNoError, command_buffer_->ResetParseError());
+  EXPECT_EQ(parse_error::kParseNoError, GetError());
 }
 
 // Checks that asking for available entries work, and that the parser
 // effectively won't use that space.
 TEST_F(CommandBufferHelperTest, TestAvailableEntries) {
   CommandBufferEntry args[2];
   args[0].value_uint32 = 3;
   args[1].value_float = 4.f;
 
   // Add 2 commands through the helper - 8 entries
@@ skipping 11 matching lines @@
   // Add more commands.
   AddCommandWithExpect(parse_error::kParseNoError, 5, 2, args);
 
   // Wait until everything is done done.
   helper_->Finish();
 
   // 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());
+  EXPECT_EQ(parse_error::kParseNoError, GetError());
 }
 
 // Checks that the InsertToken/WaitForToken work.
 TEST_F(CommandBufferHelperTest, TestToken) {
   CommandBufferEntry args[2];
   args[0].value_uint32 = 3;
   args[1].value_float = 4.f;
 
   // Add a first command.
   AddCommandWithExpect(parse_error::kParseNoError, 3, 2, args);
   // keep track of the buffer position.
   CommandBufferOffset command1_put = get_helper_put();
   int32 token = helper_->InsertToken();
 
   EXPECT_CALL(*api_mock_.get(), DoCommand(cmd::kSetToken, 1, _))
       .WillOnce(DoAll(Invoke(api_mock_.get(), &AsyncAPIMock::SetToken),
                       Return(parse_error::kParseNoError)));
   // Add another command.
   AddCommandWithExpect(parse_error::kParseNoError, 4, 2, args);
   helper_->WaitForToken(token);
   // check that the get pointer is beyond the first command.
-  EXPECT_LE(command1_put, command_buffer_->GetGetOffset());
+  EXPECT_LE(command1_put, GetGetOffset());
   helper_->Finish();
 
   // 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());
+  EXPECT_EQ(parse_error::kParseNoError, GetError());
 }
 
 }  // namespace gpu