Fine tuning glGetInternalformativ.

gpu/command_buffer/service/gles2_cmd_decoder_unittest.cc

 // Copyright (c) 2012 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_unittest.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 26 matching lines @@
 using ::testing::AtLeast;
 using ::testing::DoAll;
 using ::testing::InSequence;
 using ::testing::Invoke;
 using ::testing::MatcherCast;
 using ::testing::Mock;
 using ::testing::Pointee;
 using ::testing::Return;
 using ::testing::SaveArg;
 using ::testing::SetArrayArgument;
-using ::testing::SetArgumentPointee;
 using ::testing::SetArgPointee;
 using ::testing::StrEq;
 using ::testing::StrictMock;
 
 namespace gpu {
 namespace gles2 {
 
 using namespace cmds;
 
 void GLES2DecoderRGBBackbufferTest::SetUp() {
@@ skipping 217 matching lines @@
 }
 
 TEST_P(GLES2DecoderTest, IsTexture) {
   EXPECT_FALSE(DoIsTexture(client_texture_id_));
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   EXPECT_TRUE(DoIsTexture(client_texture_id_));
   DoDeleteTexture(client_texture_id_, kServiceTextureId);
   EXPECT_FALSE(DoIsTexture(client_texture_id_));
 }
 
+TEST_P(GLES2DecoderTest, GetInternalformativValidArgs) {
+  const GLint kNumSampleCounts = 8;
+  EXPECT_CALL(*gl_, GetError())
+      .WillOnce(Return(GL_NO_ERROR))
+      .WillOnce(Return(GL_NO_ERROR))
+      .WillOnce(Return(GL_NO_ERROR))
+      .WillOnce(Return(GL_NO_ERROR))
+      .RetiresOnSaturation();
+  typedef cmds::GetInternalformativ::Result Result;
+  Result* result = static_cast<Result*>(shared_memory_address_);
+  EXPECT_CALL(*gl_, GetInternalformativ(GL_RENDERBUFFER, GL_RGBA4,
+                                        GL_NUM_SAMPLE_COUNTS, 1, _))
+      .WillOnce(SetArgPointee<4>(kNumSampleCounts))
+      .RetiresOnSaturation();
+  EXPECT_CALL(*gl_, GetInternalformativ(GL_RENDERBUFFER, GL_RGBA4,
+                                        GL_SAMPLES, kNumSampleCounts,
+                                        result->GetData()))
+      .Times(1)
+      .RetiresOnSaturation();
+  result->size = 0;
+  cmds::GetInternalformativ cmd;
+  cmd.Init(GL_RENDERBUFFER, GL_RGBA4, GL_SAMPLES, kNumSampleCounts,
+           shared_memory_id_, shared_memory_offset_);
+  decoder_->set_unsafe_es3_apis_enabled(true);
+  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(kNumSampleCounts, result->GetNumResults());
+  EXPECT_EQ(GL_NO_ERROR, GetGLError());
+  decoder_->set_unsafe_es3_apis_enabled(false);
+  EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));
+}
+
+TEST_P(GLES2DecoderTest, GetInternalformativValidArgsBufSizeTooSmall) {
+  const GLint kNumSampleCounts = 8;
+  const GLint kBufSize = kNumSampleCounts - 2;
+  EXPECT_CALL(*gl_, GetError())
+      .WillOnce(Return(GL_NO_ERROR))
+      .WillOnce(Return(GL_NO_ERROR))
+      .WillOnce(Return(GL_NO_ERROR))
+      .WillOnce(Return(GL_NO_ERROR))
+      .RetiresOnSaturation();
+  typedef cmds::GetInternalformativ::Result Result;
+  Result* result = static_cast<Result*>(shared_memory_address_);
+  EXPECT_CALL(*gl_, GetInternalformativ(GL_RENDERBUFFER, GL_RGBA4,
+                                        GL_NUM_SAMPLE_COUNTS, 1, _))
+      .WillOnce(SetArgPointee<4>(kNumSampleCounts))
+      .RetiresOnSaturation();
+  EXPECT_CALL(*gl_, GetInternalformativ(GL_RENDERBUFFER, GL_RGBA4,
+                                        GL_SAMPLES, kBufSize,
+                                        result->GetData()))
+      .Times(1)
+      .RetiresOnSaturation();
+  result->size = 0;
+  cmds::GetInternalformativ cmd;
+  cmd.Init(GL_RENDERBUFFER, GL_RGBA4, GL_SAMPLES, kBufSize,
+           shared_memory_id_, shared_memory_offset_);
+  decoder_->set_unsafe_es3_apis_enabled(true);
+  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(kBufSize, result->GetNumResults());
+  EXPECT_EQ(GL_NO_ERROR, GetGLError());
+  decoder_->set_unsafe_es3_apis_enabled(false);
+  EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));
+}
+
+TEST_P(GLES2DecoderTest, GetInternalformativValidArgsBufSizeTooBig) {
+  const GLint kNumSampleCounts = 8;
+  const GLint kBufSize = kNumSampleCounts + 2;
+  EXPECT_CALL(*gl_, GetError())
+      .WillOnce(Return(GL_NO_ERROR))
+      .WillOnce(Return(GL_NO_ERROR))
+      .WillOnce(Return(GL_NO_ERROR))
+      .WillOnce(Return(GL_NO_ERROR))
+      .RetiresOnSaturation();
+  typedef cmds::GetInternalformativ::Result Result;
+  Result* result = static_cast<Result*>(shared_memory_address_);
+  EXPECT_CALL(*gl_, GetInternalformativ(GL_RENDERBUFFER, GL_RGBA4,
+                                        GL_NUM_SAMPLE_COUNTS, 1, _))
+      .WillOnce(SetArgPointee<4>(kNumSampleCounts))
+      .RetiresOnSaturation();
+  EXPECT_CALL(*gl_, GetInternalformativ(GL_RENDERBUFFER, GL_RGBA4,
+                                        GL_SAMPLES, kNumSampleCounts,
+                                        result->GetData()))
+      .Times(1)
+      .RetiresOnSaturation();
+  result->size = 0;
+  cmds::GetInternalformativ cmd;
+  cmd.Init(GL_RENDERBUFFER, GL_RGBA4, GL_SAMPLES, kBufSize,
+           shared_memory_id_, shared_memory_offset_);
+  decoder_->set_unsafe_es3_apis_enabled(true);
+  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(kNumSampleCounts, result->GetNumResults());
+  EXPECT_EQ(GL_NO_ERROR, GetGLError());
+  decoder_->set_unsafe_es3_apis_enabled(false);
+  EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));
+}
+
 TEST_P(GLES2DecoderTest, ClientWaitSyncValid) {
   typedef cmds::ClientWaitSync::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
   cmds::ClientWaitSync cmd;
   uint32_t v32_0 = 0, v32_1 = 0;
   GLES2Util::MapUint64ToTwoUint32(0, &v32_0, &v32_1);
   cmd.Init(client_sync_id_, GL_SYNC_FLUSH_COMMANDS_BIT, v32_0, v32_1,
            shared_memory_id_, shared_memory_offset_);
   EXPECT_CALL(*gl_,
               ClientWaitSync(reinterpret_cast<GLsync>(kServiceSyncId),
@@ skipping 159 matching lines @@
   // Test id = 0 fails.
   begin_cmd.Init(
       GL_ANY_SAMPLES_PASSED_EXT, 0, kSharedMemoryId, kSharedMemoryOffset);
   EXPECT_EQ(error::kNoError, ExecuteCmd(begin_cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 
   GenHelper<GenQueriesEXTImmediate>(kNewClientId);
 
   // Test valid parameters work.
   EXPECT_CALL(*gl_, GenQueries(1, _))
-      .WillOnce(SetArgumentPointee<1>(kNewServiceId))
+      .WillOnce(SetArgPointee<1>(kNewServiceId))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, BeginQuery(GL_ANY_SAMPLES_PASSED_EXT, kNewServiceId))
       .Times(1)
       .RetiresOnSaturation();
 
   // Query object should not be created untill BeginQueriesEXT.
   QueryManager* query_manager = decoder_->GetQueryManager();
   ASSERT_TRUE(query_manager != NULL);
   QueryManager::Query* query = query_manager->GetQuery(kNewClientId);
   EXPECT_TRUE(query == NULL);
@@ skipping 70 matching lines @@
   init.bind_generates_resource = true;
   test->InitDecoder(init);
   ::testing::StrictMock< ::gfx::MockGLInterface>* gl = test->GetGLMock();
 
   BeginQueryEXT begin_cmd;
 
   test->GenHelper<GenQueriesEXTImmediate>(client_id);
 
   if (query_type.is_gl) {
     EXPECT_CALL(*gl, GenQueries(1, _))
-        .WillOnce(SetArgumentPointee<1>(service_id))
+        .WillOnce(SetArgPointee<1>(service_id))
         .RetiresOnSaturation();
     EXPECT_CALL(*gl, BeginQuery(query_type.type, service_id))
         .Times(1)
         .RetiresOnSaturation();
   }
 
   // Test bad shared memory fails
   begin_cmd.Init(query_type.type, client_id, shm_id, shm_offset);
   error::Error error1 = test->ExecuteCmd(begin_cmd);
 
@@ skipping 20 matching lines @@
 #endif
   }
 
   EndQueryEXT end_cmd;
   end_cmd.Init(query_type.type, 1);
   error::Error error2 = test->ExecuteCmd(end_cmd);
 
   if (query_type.is_gl) {
     EXPECT_CALL(
         *gl, GetQueryObjectuiv(service_id, GL_QUERY_RESULT_AVAILABLE_EXT, _))
-        .WillOnce(SetArgumentPointee<2>(1))
+        .WillOnce(SetArgPointee<2>(1))
         .RetiresOnSaturation();
     EXPECT_CALL(*gl, GetQueryObjectuiv(service_id, GL_QUERY_RESULT_EXT, _))
-        .WillOnce(SetArgumentPointee<2>(1))
+        .WillOnce(SetArgPointee<2>(1))
         .RetiresOnSaturation();
   }
   if (query_type.type == GL_COMMANDS_COMPLETED_CHROMIUM) {
 #if DCHECK_IS_ON()
     EXPECT_CALL(*gl, IsSync(kGlSync))
         .WillOnce(Return(GL_TRUE))
         .RetiresOnSaturation();
 #endif
     EXPECT_CALL(*gl, ClientWaitSync(kGlSync, _, _))
         .WillOnce(Return(GL_ALREADY_SIGNALED))
@@ skipping 679 matching lines @@
 INSTANTIATE_TEST_CASE_P(Service,
                         GLES2DecoderRGBBackbufferTest,
                         ::testing::Bool());
 
 INSTANTIATE_TEST_CASE_P(Service, GLES2DecoderDoCommandsTest, ::testing::Bool());
 
 INSTANTIATE_TEST_CASE_P(Service, GLES3DecoderTest, ::testing::Bool());
 
 }  // namespace gles2
 }  // namespace gpu