Optimize GLES2DecoderImpl::ApplyDirtyState.

gpu/command_buffer/service/gles2_cmd_decoder_unittest_attribs.cc

 // Copyright 2014 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/gles2_cmd_decoder.h"
 
 #include "base/command_line.h"
 #include "base/strings/string_number_conversions.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
@@ skipping 36 matching lines @@
 using ::testing::SetArgumentPointee;
 using ::testing::SetArgPointee;
 using ::testing::StrEq;
 using ::testing::StrictMock;
 
 namespace gpu {
 namespace gles2 {
 
 using namespace cmds;
 
-TEST_F(GLES2DecoderWithShaderTest, GetVertexAttribPointervSucceeds) {
+TEST_P(GLES2DecoderWithShaderTest, GetVertexAttribPointervSucceeds) {
   const float dummy = 0;
   const GLuint kOffsetToTestFor = sizeof(dummy) * 4;
   const GLuint kIndexToTest = 1;
   GetVertexAttribPointerv::Result* result =
       static_cast<GetVertexAttribPointerv::Result*>(shared_memory_address_);
   result->size = 0;
   const GLuint* result_value = result->GetData();
   // Test that initial value is 0.
   GetVertexAttribPointerv cmd;
   cmd.Init(kIndexToTest,
            GL_VERTEX_ATTRIB_ARRAY_POINTER,
            shared_memory_id_,
            shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(sizeof(*result_value), result->size);
   EXPECT_EQ(0u, *result_value);
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
   // Set the value and see that we get it.
   SetupVertexBuffer();
   DoVertexAttribPointer(kIndexToTest, 2, GL_FLOAT, 0, kOffsetToTestFor);
   result->size = 0;
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(sizeof(*result_value), result->size);
   EXPECT_EQ(kOffsetToTestFor, *result_value);
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_F(GLES2DecoderWithShaderTest, GetVertexAttribPointervBadArgsFails) {
+TEST_P(GLES2DecoderWithShaderTest, GetVertexAttribPointervBadArgsFails) {
   const GLuint kIndexToTest = 1;
   GetVertexAttribPointerv::Result* result =
       static_cast<GetVertexAttribPointerv::Result*>(shared_memory_address_);
   result->size = 0;
   const GLuint* result_value = result->GetData();
   // Test pname invalid fails.
   GetVertexAttribPointerv cmd;
   cmd.Init(kIndexToTest,
            GL_VERTEX_ATTRIB_ARRAY_POINTER + 1,
            shared_memory_id_,
@@ skipping 22 matching lines @@
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 
   // Test memory offset bad fails.
   cmd.Init(kIndexToTest,
            GL_VERTEX_ATTRIB_ARRAY_POINTER,
            shared_memory_id_,
            kInvalidSharedMemoryOffset);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 }
 
-TEST_F(GLES2DecoderWithShaderTest, BindBufferToDifferentTargetFails) {
+TEST_P(GLES2DecoderWithShaderTest, BindBufferToDifferentTargetFails) {
   // Bind the buffer to GL_ARRAY_BUFFER
   DoBindBuffer(GL_ARRAY_BUFFER, client_buffer_id_, kServiceBufferId);
   // Attempt to rebind to GL_ELEMENT_ARRAY_BUFFER
   // NOTE: Real GLES2 does not have this restriction but WebGL and we do.
   // This can be restriction can be removed at runtime.
   EXPECT_CALL(*gl_, BindBuffer(_, _)).Times(0);
   BindBuffer cmd;
   cmd.Init(GL_ELEMENT_ARRAY_BUFFER, client_buffer_id_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
-TEST_F(GLES2DecoderWithShaderTest, VertexAttribPointer) {
+TEST_P(GLES2DecoderWithShaderTest, VertexAttribPointer) {
   SetupVertexBuffer();
   static const GLenum types[] = {
       GL_BYTE,  GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT,
       GL_FLOAT, GL_FIXED,         GL_INT,   GL_UNSIGNED_INT,
   };
   static const GLsizei sizes[] = {
       1, 1, 2, 2, 4, 4, 4, 4,
   };
   static const GLuint indices[] = {
       0, 1, kNumVertexAttribs - 1, kNumVertexAttribs,
@@ skipping 225 matching lines @@
   }
 
   void BindVertexArrayOESValidArgsNewId() {
     BindVertexArrayOES cmd;
     cmd.Init(kNewClientId);
     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
     EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
   }
 };
 
+INSTANTIATE_TEST_CASE_P(Service,
+                        GLES2DecoderVertexArraysOESTest,
+                        ::testing::Bool());
+
 class GLES2DecoderEmulatedVertexArraysOESTest
     : public GLES2DecoderVertexArraysOESTest {
  public:
   GLES2DecoderEmulatedVertexArraysOESTest() {}
 
   virtual void SetUp() {
     InitState init;
     init.gl_version = "3.0";
     init.bind_generates_resource = true;
     InitDecoder(init);
     SetupDefaultProgram();
 
     AddExpectationsForGenVertexArraysOES();
     GenHelper<GenVertexArraysOESImmediate>(client_vertexarray_id_);
 
     vertex_array_deleted_manually_ = false;
   }
 };
 
+INSTANTIATE_TEST_CASE_P(Service,
+                        GLES2DecoderEmulatedVertexArraysOESTest,
+                        ::testing::Bool());
+
 // Test vertex array objects with native support
-TEST_F(GLES2DecoderVertexArraysOESTest, GenVertexArraysOESValidArgs) {
+TEST_P(GLES2DecoderVertexArraysOESTest, GenVertexArraysOESValidArgs) {
   GenVertexArraysOESValidArgs();
 }
-TEST_F(GLES2DecoderEmulatedVertexArraysOESTest, GenVertexArraysOESValidArgs) {
+TEST_P(GLES2DecoderEmulatedVertexArraysOESTest, GenVertexArraysOESValidArgs) {
   GenVertexArraysOESValidArgs();
 }
 
-TEST_F(GLES2DecoderVertexArraysOESTest, GenVertexArraysOESInvalidArgs) {
+TEST_P(GLES2DecoderVertexArraysOESTest, GenVertexArraysOESInvalidArgs) {
   GenVertexArraysOESInvalidArgs();
 }
-TEST_F(GLES2DecoderEmulatedVertexArraysOESTest, ) {
+TEST_P(GLES2DecoderEmulatedVertexArraysOESTest, ) {
   GenVertexArraysOESInvalidArgs();
 }
 
-TEST_F(GLES2DecoderVertexArraysOESTest, GenVertexArraysOESImmediateValidArgs) {
+TEST_P(GLES2DecoderVertexArraysOESTest, GenVertexArraysOESImmediateValidArgs) {
   GenVertexArraysOESImmediateValidArgs();
 }
-TEST_F(GLES2DecoderEmulatedVertexArraysOESTest,
+TEST_P(GLES2DecoderEmulatedVertexArraysOESTest,
        GenVertexArraysOESImmediateValidArgs) {
   GenVertexArraysOESImmediateValidArgs();
 }
 
-TEST_F(GLES2DecoderVertexArraysOESTest,
+TEST_P(GLES2DecoderVertexArraysOESTest,
        GenVertexArraysOESImmediateInvalidArgs) {
   GenVertexArraysOESImmediateInvalidArgs();
 }
-TEST_F(GLES2DecoderEmulatedVertexArraysOESTest,
+TEST_P(GLES2DecoderEmulatedVertexArraysOESTest,
        GenVertexArraysOESImmediateInvalidArgs) {
   GenVertexArraysOESImmediateInvalidArgs();
 }
 
-TEST_F(GLES2DecoderVertexArraysOESTest, DeleteVertexArraysOESValidArgs) {
+TEST_P(GLES2DecoderVertexArraysOESTest, DeleteVertexArraysOESValidArgs) {
   DeleteVertexArraysOESValidArgs();
 }
-TEST_F(GLES2DecoderEmulatedVertexArraysOESTest,
+TEST_P(GLES2DecoderEmulatedVertexArraysOESTest,
        DeleteVertexArraysOESValidArgs) {
   DeleteVertexArraysOESValidArgs();
 }
 
-TEST_F(GLES2DecoderVertexArraysOESTest, DeleteVertexArraysOESInvalidArgs) {
+TEST_P(GLES2DecoderVertexArraysOESTest, DeleteVertexArraysOESInvalidArgs) {
   DeleteVertexArraysOESInvalidArgs();
 }
-TEST_F(GLES2DecoderEmulatedVertexArraysOESTest,
+TEST_P(GLES2DecoderEmulatedVertexArraysOESTest,
        DeleteVertexArraysOESInvalidArgs) {
   DeleteVertexArraysOESInvalidArgs();
 }
 
-TEST_F(GLES2DecoderVertexArraysOESTest,
+TEST_P(GLES2DecoderVertexArraysOESTest,
        DeleteVertexArraysOESImmediateValidArgs) {
   DeleteVertexArraysOESImmediateValidArgs();
 }
-TEST_F(GLES2DecoderEmulatedVertexArraysOESTest,
+TEST_P(GLES2DecoderEmulatedVertexArraysOESTest,
        DeleteVertexArraysOESImmediateValidArgs) {
   DeleteVertexArraysOESImmediateValidArgs();
 }
 
-TEST_F(GLES2DecoderVertexArraysOESTest,
+TEST_P(GLES2DecoderVertexArraysOESTest,
        DeleteVertexArraysOESImmediateInvalidArgs) {
   DeleteVertexArraysOESImmediateInvalidArgs();
 }
-TEST_F(GLES2DecoderEmulatedVertexArraysOESTest,
+TEST_P(GLES2DecoderEmulatedVertexArraysOESTest,
        DeleteVertexArraysOESImmediateInvalidArgs) {
   DeleteVertexArraysOESImmediateInvalidArgs();
 }
 
-TEST_F(GLES2DecoderVertexArraysOESTest,
+TEST_P(GLES2DecoderVertexArraysOESTest,
        DeleteBoundVertexArraysOESImmediateValidArgs) {
   DeleteBoundVertexArraysOESImmediateValidArgs();
 }
-TEST_F(GLES2DecoderEmulatedVertexArraysOESTest,
+TEST_P(GLES2DecoderEmulatedVertexArraysOESTest,
        DeleteBoundVertexArraysOESImmediateValidArgs) {
   DeleteBoundVertexArraysOESImmediateValidArgs();
 }
 
-TEST_F(GLES2DecoderVertexArraysOESTest, IsVertexArrayOESValidArgs) {
+TEST_P(GLES2DecoderVertexArraysOESTest, IsVertexArrayOESValidArgs) {
   IsVertexArrayOESValidArgs();
 }
-TEST_F(GLES2DecoderEmulatedVertexArraysOESTest, IsVertexArrayOESValidArgs) {
+TEST_P(GLES2DecoderEmulatedVertexArraysOESTest, IsVertexArrayOESValidArgs) {
   IsVertexArrayOESValidArgs();
 }
 
-TEST_F(GLES2DecoderVertexArraysOESTest,
+TEST_P(GLES2DecoderVertexArraysOESTest,
        IsVertexArrayOESInvalidArgsBadSharedMemoryId) {
   IsVertexArrayOESInvalidArgsBadSharedMemoryId();
 }
-TEST_F(GLES2DecoderEmulatedVertexArraysOESTest,
+TEST_P(GLES2DecoderEmulatedVertexArraysOESTest,
        IsVertexArrayOESInvalidArgsBadSharedMemoryId) {
   IsVertexArrayOESInvalidArgsBadSharedMemoryId();
 }
 
-TEST_F(GLES2DecoderVertexArraysOESTest, BindVertexArrayOESValidArgs) {
+TEST_P(GLES2DecoderVertexArraysOESTest, BindVertexArrayOESValidArgs) {
   BindVertexArrayOESValidArgs();
 }
-TEST_F(GLES2DecoderEmulatedVertexArraysOESTest, BindVertexArrayOESValidArgs) {
+TEST_P(GLES2DecoderEmulatedVertexArraysOESTest, BindVertexArrayOESValidArgs) {
   BindVertexArrayOESValidArgs();
 }
 
-TEST_F(GLES2DecoderVertexArraysOESTest, BindVertexArrayOESValidArgsNewId) {
+TEST_P(GLES2DecoderVertexArraysOESTest, BindVertexArrayOESValidArgsNewId) {
   BindVertexArrayOESValidArgsNewId();
 }
-TEST_F(GLES2DecoderEmulatedVertexArraysOESTest,
+TEST_P(GLES2DecoderEmulatedVertexArraysOESTest,
        BindVertexArrayOESValidArgsNewId) {
   BindVertexArrayOESValidArgsNewId();
 }
 
-TEST_F(GLES2DecoderTest, BufferDataGLError) {
+TEST_P(GLES2DecoderTest, BufferDataGLError) {
   GLenum target = GL_ARRAY_BUFFER;
   GLsizeiptr size = 4;
   DoBindBuffer(GL_ARRAY_BUFFER, client_buffer_id_, kServiceBufferId);
   BufferManager* manager = group().buffer_manager();
   Buffer* buffer = manager->GetBuffer(client_buffer_id_);
   ASSERT_TRUE(buffer != NULL);
   EXPECT_EQ(0, buffer->size());
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_OUT_OF_MEMORY))
@@ skipping 11 matching lines @@
 // TODO(gman): BufferData
 
 // TODO(gman): BufferDataImmediate
 
 // TODO(gman): BufferSubData
 
 // TODO(gman): BufferSubDataImmediate
 
 }  // namespace gles2
 }  // namespace gpu