Validate UniformBlocks being backed by sufficient data

gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.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_base.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 24 matching lines @@
 using ::testing::AtMost;
 using ::testing::DoAll;
 using ::testing::InSequence;
 using ::testing::Invoke;
 using ::testing::InvokeWithoutArgs;
 using ::testing::MatcherCast;
 using ::testing::Pointee;
 using ::testing::Return;
 using ::testing::SetArrayArgument;
 using ::testing::SetArgPointee;
-using ::testing::SetArgumentPointee;
 using ::testing::StrEq;
 using ::testing::StrictMock;
 using ::testing::WithArg;
 
 namespace {
 
 void NormalizeInitState(gpu::gles2::GLES2DecoderTestBase::InitState* init) {
   CHECK(init);
   const char* kVAOExtensions[] = {
       "GL_OES_vertex_array_object",
@@ skipping 176 matching lines @@
   // expectations.
   EXPECT_CALL(*mock_decoder_, DoCommands(_, _, _, _)).WillRepeatedly(
       Invoke(mock_decoder_.get(), &MockGLES2Decoder::FakeDoCommands));
 
   EXPECT_TRUE(group_->Initialize(mock_decoder_.get(), init.context_type,
                                  DisallowedFeatures()));
 
   if (init.context_type == CONTEXT_TYPE_WEBGL2 ||
       init.context_type == CONTEXT_TYPE_OPENGLES3) {
     EXPECT_CALL(*gl_, GetIntegerv(GL_MAX_COLOR_ATTACHMENTS, _))
-        .WillOnce(SetArgumentPointee<1>(kMaxColorAttachments))
+        .WillOnce(SetArgPointee<1>(kMaxColorAttachments))
         .RetiresOnSaturation();
     EXPECT_CALL(*gl_, GetIntegerv(GL_MAX_DRAW_BUFFERS, _))
-        .WillOnce(SetArgumentPointee<1>(kMaxDrawBuffers))
+        .WillOnce(SetArgPointee<1>(kMaxDrawBuffers))
         .RetiresOnSaturation();
 
     EXPECT_CALL(*gl_, GenTransformFeedbacks(1, _))
-        .WillOnce(SetArgumentPointee<1>(kServiceDefaultTransformFeedbackId))
+        .WillOnce(SetArgPointee<1>(kServiceDefaultTransformFeedbackId))
         .RetiresOnSaturation();
     EXPECT_CALL(*gl_, BindTransformFeedback(GL_TRANSFORM_FEEDBACK,
                                             kServiceDefaultTransformFeedbackId))
         .Times(1)
         .RetiresOnSaturation();
   }
 
   if (group_->feature_info()->feature_flags().native_vertex_array_object) {
     EXPECT_CALL(*gl_, GenVertexArraysOES(1, _))
-        .WillOnce(SetArgumentPointee<1>(kServiceVertexArrayId))
+        .WillOnce(SetArgPointee<1>(kServiceVertexArrayId))
         .RetiresOnSaturation();
     EXPECT_CALL(*gl_, BindVertexArrayOES(_)).Times(1).RetiresOnSaturation();
   }
 
   if (group_->feature_info()->workarounds().init_vertex_attributes)
     AddExpectationsForVertexAttribManager();
 
   AddExpectationsForBindVertexArrayOES();
 
   if (!group_->feature_info()->gl_version_info().BehavesLikeGLES()) {
@@ skipping 72 matching lines @@
       .RetiresOnSaturation();
 
   EXPECT_CALL(*gl_, BindFramebufferEXT(GL_FRAMEBUFFER, 0))
       .Times(1)
       .RetiresOnSaturation();
 
   if (group_->feature_info()->gl_version_info().is_desktop_core_profile) {
     EXPECT_CALL(*gl_, GetFramebufferAttachmentParameterivEXT(
                           GL_FRAMEBUFFER, GL_BACK_LEFT,
                           GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE, _))
-        .WillOnce(SetArgumentPointee<3>(normalized_init.has_alpha ? 8 : 0))
+        .WillOnce(SetArgPointee<3>(normalized_init.has_alpha ? 8 : 0))
         .RetiresOnSaturation();
     EXPECT_CALL(*gl_, GetFramebufferAttachmentParameterivEXT(
                           GL_FRAMEBUFFER, GL_DEPTH,
                           GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE, _))
-        .WillOnce(SetArgumentPointee<3>(normalized_init.has_depth ? 24 : 0))
+        .WillOnce(SetArgPointee<3>(normalized_init.has_depth ? 24 : 0))
         .RetiresOnSaturation();
     EXPECT_CALL(*gl_, GetFramebufferAttachmentParameterivEXT(
                           GL_FRAMEBUFFER, GL_STENCIL,
                           GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE, _))
-        .WillOnce(SetArgumentPointee<3>(normalized_init.has_stencil ? 8 : 0))
+        .WillOnce(SetArgPointee<3>(normalized_init.has_stencil ? 8 : 0))
         .RetiresOnSaturation();
   } else {
     EXPECT_CALL(*gl_, GetIntegerv(GL_ALPHA_BITS, _))
-        .WillOnce(SetArgumentPointee<1>(normalized_init.has_alpha ? 8 : 0))
+        .WillOnce(SetArgPointee<1>(normalized_init.has_alpha ? 8 : 0))
         .RetiresOnSaturation();
     EXPECT_CALL(*gl_, GetIntegerv(GL_DEPTH_BITS, _))
-        .WillOnce(SetArgumentPointee<1>(normalized_init.has_depth ? 24 : 0))
+        .WillOnce(SetArgPointee<1>(normalized_init.has_depth ? 24 : 0))
         .RetiresOnSaturation();
     EXPECT_CALL(*gl_, GetIntegerv(GL_STENCIL_BITS, _))
-        .WillOnce(SetArgumentPointee<1>(normalized_init.has_stencil ? 8 : 0))
+        .WillOnce(SetArgPointee<1>(normalized_init.has_stencil ? 8 : 0))
         .RetiresOnSaturation();
   }
 
   if (!group_->feature_info()->gl_version_info().BehavesLikeGLES()) {
     EXPECT_CALL(*gl_, Enable(GL_VERTEX_PROGRAM_POINT_SIZE))
         .Times(1)
         .RetiresOnSaturation();
 
     EXPECT_CALL(*gl_, Enable(GL_POINT_SPRITE))
         .Times(1)
@@ skipping 90 matching lines @@
   EXPECT_CALL(*context_, MakeCurrent(surface_.get())).WillOnce(Return(true));
   if (context_->WasAllocatedUsingRobustnessExtension()) {
     EXPECT_CALL(*gl_, GetGraphicsResetStatusARB())
         .WillOnce(Return(GL_NO_ERROR));
   }
   decoder_->MakeCurrent();
   decoder_->set_engine(engine_.get());
   decoder_->BeginDecoding();
 
   EXPECT_CALL(*gl_, GenBuffersARB(_, _))
-      .WillOnce(SetArgumentPointee<1>(kServiceBufferId))
+      .WillOnce(SetArgPointee<1>(kServiceBufferId))
       .RetiresOnSaturation();
   GenHelper<cmds::GenBuffersImmediate>(client_buffer_id_);
   EXPECT_CALL(*gl_, GenFramebuffersEXT(_, _))
-      .WillOnce(SetArgumentPointee<1>(kServiceFramebufferId))
+      .WillOnce(SetArgPointee<1>(kServiceFramebufferId))
       .RetiresOnSaturation();
   GenHelper<cmds::GenFramebuffersImmediate>(client_framebuffer_id_);
   EXPECT_CALL(*gl_, GenRenderbuffersEXT(_, _))
-      .WillOnce(SetArgumentPointee<1>(kServiceRenderbufferId))
+      .WillOnce(SetArgPointee<1>(kServiceRenderbufferId))
       .RetiresOnSaturation();
   GenHelper<cmds::GenRenderbuffersImmediate>(client_renderbuffer_id_);
   EXPECT_CALL(*gl_, GenTextures(_, _))
-      .WillOnce(SetArgumentPointee<1>(kServiceTextureId))
+      .WillOnce(SetArgPointee<1>(kServiceTextureId))
       .RetiresOnSaturation();
   GenHelper<cmds::GenTexturesImmediate>(client_texture_id_);
   EXPECT_CALL(*gl_, GenBuffersARB(_, _))
-      .WillOnce(SetArgumentPointee<1>(kServiceElementBufferId))
+      .WillOnce(SetArgPointee<1>(kServiceElementBufferId))
       .RetiresOnSaturation();
   GenHelper<cmds::GenBuffersImmediate>(client_element_buffer_id_);
   GenHelper<cmds::GenQueriesEXTImmediate>(client_query_id_);
 
   DoCreateProgram(client_program_id_, kServiceProgramId);
   DoCreateShader(GL_VERTEX_SHADER, client_shader_id_, kServiceShaderId);
 
   // Unsafe commands.
   bool reset_unsafe_es3_apis_enabled = false;
   if (!decoder_->unsafe_es3_apis_enabled()) {
     decoder_->set_unsafe_es3_apis_enabled(true);
     reset_unsafe_es3_apis_enabled = true;
   }
 
   const gl::GLVersionInfo* version = context_->GetVersionInfo();
   if (version->IsAtLeastGL(3, 3) || version->IsAtLeastGLES(3, 0)) {
     EXPECT_CALL(*gl_, GenSamplers(_, _))
-        .WillOnce(SetArgumentPointee<1>(kServiceSamplerId))
+        .WillOnce(SetArgPointee<1>(kServiceSamplerId))
         .RetiresOnSaturation();
     GenHelper<cmds::GenSamplersImmediate>(client_sampler_id_);
   }
   if (version->IsAtLeastGL(4, 0) || version->IsAtLeastGLES(3, 0)) {
     EXPECT_CALL(*gl_, GenTransformFeedbacks(_, _))
-        .WillOnce(SetArgumentPointee<1>(kServiceTransformFeedbackId))
+        .WillOnce(SetArgPointee<1>(kServiceTransformFeedbackId))
         .RetiresOnSaturation();
     GenHelper<cmds::GenTransformFeedbacksImmediate>(
         client_transformfeedback_id_);
   }
 
   if (init.extensions.find("GL_ARB_sync ") != std::string::npos ||
       version->IsAtLeastGL(3, 2) || version->IsAtLeastGLES(3, 0)) {
     DoFenceSync(client_sync_id_, kServiceSyncId);
   }
 
@@ skipping 894 matching lines @@
       .Times(1)
       .RetiresOnSaturation();
   cmds::VertexAttribDivisorANGLE cmd;
   cmd.Init(index, divisor);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
 void GLES2DecoderTestBase::AddExpectationsForGenVertexArraysOES(){
   if (group_->feature_info()->feature_flags().native_vertex_array_object) {
       EXPECT_CALL(*gl_, GenVertexArraysOES(1, _))
-          .WillOnce(SetArgumentPointee<1>(kServiceVertexArrayId))
+          .WillOnce(SetArgPointee<1>(kServiceVertexArrayId))
           .RetiresOnSaturation();
   }
 }
 
 void GLES2DecoderTestBase::AddExpectationsForDeleteVertexArraysOES(){
   if (group_->feature_info()->feature_flags().native_vertex_array_object) {
       EXPECT_CALL(*gl_, DeleteVertexArraysOES(1, _))
           .Times(1)
           .RetiresOnSaturation();
   }
@@ skipping 351 matching lines @@
       kOutputVariable1ColorName, kOutputVariable1Index,
   }};
   static TestHelper::ProgramOutputInfo kProgramOutputsESSL3[] = {{
       kOutputVariable1NameESSL3, kOutputVariable1Size, kOutputVariable1Type,
       kOutputVariable1ColorName, kOutputVariable1Index,
   }};
   TestHelper::ProgramOutputInfo* program_outputs =
       shader_language_version_ == 100 ? kProgramOutputsESSL1
                                       : kProgramOutputsESSL3;
   const size_t kNumProgramOutputs = 1;
+  const int kNumUniformBlocks = 2;
+  const int kUniformBlockBinding[] = { 0, 1 };
+  const int kUniformBlockDataSize[] = { 32, 16 };
 
   {
     InSequence s;
 
     EXPECT_CALL(*gl_,
                 AttachShader(program_service_id, vertex_shader_service_id))
         .Times(1)
         .RetiresOnSaturation();
     EXPECT_CALL(*gl_,
                 AttachShader(program_service_id, fragment_shader_service_id))
@@ skipping 27 matching lines @@
                               nullptr, nullptr, nullptr, nullptr,
                               &frag_output_variable_list, nullptr);
 
   cmds::AttachShader attach_cmd;
   attach_cmd.Init(program_client_id, vertex_shader_client_id);
   EXPECT_EQ(error::kNoError, ExecuteCmd(attach_cmd));
 
   attach_cmd.Init(program_client_id, fragment_shader_client_id);
   EXPECT_EQ(error::kNoError, ExecuteCmd(attach_cmd));
 
+  if (shader_language_version_ == 300) {
+    EXPECT_CALL(*gl_, GetProgramiv(
+        program_service_id, GL_ACTIVE_UNIFORM_BLOCKS, _))
+        .WillOnce(SetArgPointee<2>(kNumUniformBlocks))
+        .RetiresOnSaturation();
+    for (int ii = 0; ii < kNumUniformBlocks; ++ii) {
+      EXPECT_CALL(*gl_,
+                  GetActiveUniformBlockiv(program_service_id, ii,
+                                          GL_UNIFORM_BLOCK_BINDING, _))
+          .WillOnce(SetArgPointee<3>(kUniformBlockBinding[ii]))
+          .RetiresOnSaturation();
+      EXPECT_CALL(*gl_,
+                  GetActiveUniformBlockiv(program_service_id, ii,
+                                          GL_UNIFORM_BLOCK_DATA_SIZE, _))
+          .WillOnce(SetArgPointee<3>(kUniformBlockDataSize[ii]))
+          .RetiresOnSaturation();
+    }
+  }
+
   cmds::LinkProgram link_cmd;
   link_cmd.Init(program_client_id);
 
   EXPECT_EQ(error::kNoError, ExecuteCmd(link_cmd));
 }
 
 void GLES2DecoderTestBase::DoEnableDisable(GLenum cap, bool enable) {
   SetupExpectationsForEnableDisable(cap, enable);
   if (enable) {
     cmds::Enable cmd;
@@ skipping 222 matching lines @@
   SetupDefaultProgram();
 }
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "gpu/command_buffer/service/gles2_cmd_decoder_unittest_0_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu