src/gpu/command_buffer/service/test_helper.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "gpu/command_buffer/service/test_helper.h"
   6
   7 #include <algorithm>
   8 #include <string>
   9
  10 #include "base/strings/string_number_conversions.h"
  11 #include "base/strings/string_tokenizer.h"
  12 #include "gpu/command_buffer/common/types.h"
  13 #include "gpu/command_buffer/service/buffer_manager.h"
  14 #include "gpu/command_buffer/service/error_state_mock.h"
  15 #include "gpu/command_buffer/service/gl_utils.h"
  16 #include "gpu/command_buffer/service/gpu_switches.h"
  17 #include "gpu/command_buffer/service/program_manager.h"
  18 #include "gpu/command_buffer/service/texture_manager.h"
  19 #include "testing/gtest/include/gtest/gtest.h"
  20 #include "ui/gl/gl_mock.h"
  21
  22 using ::testing::_;
  23 using ::testing::DoAll;
  24 using ::testing::InSequence;
  25 using ::testing::MatcherCast;
  26 using ::testing::Pointee;
  27 using ::testing::Return;
  28 using ::testing::SetArrayArgument;
  29 using ::testing::SetArgumentPointee;
  30 using ::testing::StrEq;
  31 using ::testing::StrictMock;
  32
  33 namespace gpu {
  34 namespace gles2 {
  35
  36 // GCC requires these declarations, but MSVC requires they not be present
  37 #ifndef COMPILER_MSVC
  38 const GLuint TestHelper::kServiceBlackTexture2dId;
  39 const GLuint TestHelper::kServiceDefaultTexture2dId;
  40 const GLuint TestHelper::kServiceBlackTextureCubemapId;
  41 const GLuint TestHelper::kServiceDefaultTextureCubemapId;
  42 const GLuint TestHelper::kServiceBlackExternalTextureId;
  43 const GLuint TestHelper::kServiceDefaultExternalTextureId;
  44 const GLuint TestHelper::kServiceBlackRectangleTextureId;
  45 const GLuint TestHelper::kServiceDefaultRectangleTextureId;
  46
  47 const GLint TestHelper::kMaxSamples;
  48 const GLint TestHelper::kMaxRenderbufferSize;
  49 const GLint TestHelper::kMaxTextureSize;
  50 const GLint TestHelper::kMaxCubeMapTextureSize;
  51 const GLint TestHelper::kNumVertexAttribs;
  52 const GLint TestHelper::kNumTextureUnits;
  53 const GLint TestHelper::kMaxTextureImageUnits;
  54 const GLint TestHelper::kMaxVertexTextureImageUnits;
  55 const GLint TestHelper::kMaxFragmentUniformVectors;
  56 const GLint TestHelper::kMaxFragmentUniformComponents;
  57 const GLint TestHelper::kMaxVaryingVectors;
  58 const GLint TestHelper::kMaxVaryingFloats;
  59 const GLint TestHelper::kMaxVertexUniformVectors;
  60 const GLint TestHelper::kMaxVertexUniformComponents;
  61 #endif
  62
  63 void TestHelper::SetupTextureInitializationExpectations(
  64     ::gfx::MockGLInterface* gl, GLenum target) {
  65   InSequence sequence;
  66
  67   bool needs_initialization = (target != GL_TEXTURE_EXTERNAL_OES);
  68   bool needs_faces = (target == GL_TEXTURE_CUBE_MAP);
  69
  70   static GLuint texture_2d_ids[] = {
  71     kServiceBlackTexture2dId,
  72     kServiceDefaultTexture2dId };
  73   static GLuint texture_cube_map_ids[] = {
  74     kServiceBlackTextureCubemapId,
  75     kServiceDefaultTextureCubemapId };
  76   static GLuint texture_external_oes_ids[] = {
  77     kServiceBlackExternalTextureId,
  78     kServiceDefaultExternalTextureId };
  79   static GLuint texture_rectangle_arb_ids[] = {
  80     kServiceBlackRectangleTextureId,
  81     kServiceDefaultRectangleTextureId };
  82
  83   const GLuint* texture_ids = NULL;
  84   switch (target) {
  85     case GL_TEXTURE_2D:
  86       texture_ids = &texture_2d_ids[0];
  87       break;
  88     case GL_TEXTURE_CUBE_MAP:
  89       texture_ids = &texture_cube_map_ids[0];
  90       break;
  91     case GL_TEXTURE_EXTERNAL_OES:
  92       texture_ids = &texture_external_oes_ids[0];
  93       break;
  94     case GL_TEXTURE_RECTANGLE_ARB:
  95       texture_ids = &texture_rectangle_arb_ids[0];
  96       break;
  97     default:
  98       NOTREACHED();
  99   }
 100
 101   int array_size = 2;
 102
 103   EXPECT_CALL(*gl, GenTextures(array_size, _))
 104       .WillOnce(SetArrayArgument<1>(texture_ids,
 105                                     texture_ids + array_size))
 106           .RetiresOnSaturation();
 107   for (int ii = 0; ii < array_size; ++ii) {
 108     EXPECT_CALL(*gl, BindTexture(target, texture_ids[ii]))
 109         .Times(1)
 110         .RetiresOnSaturation();
 111     if (needs_initialization) {
 112       if (needs_faces) {
 113         static GLenum faces[] = {
 114           GL_TEXTURE_CUBE_MAP_POSITIVE_X,
 115           GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
 116           GL_TEXTURE_CUBE_MAP_POSITIVE_Y,
 117           GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
 118           GL_TEXTURE_CUBE_MAP_POSITIVE_Z,
 119           GL_TEXTURE_CUBE_MAP_NEGATIVE_Z,
 120         };
 121         for (size_t ii = 0; ii < arraysize(faces); ++ii) {
 122           EXPECT_CALL(*gl, TexImage2D(faces[ii], 0, GL_RGBA, 1, 1, 0, GL_RGBA,
 123                                       GL_UNSIGNED_BYTE, _))
 124               .Times(1)
 125               .RetiresOnSaturation();
 126         }
 127       } else {
 128         EXPECT_CALL(*gl, TexImage2D(target, 0, GL_RGBA, 1, 1, 0, GL_RGBA,
 129                                     GL_UNSIGNED_BYTE, _))
 130             .Times(1)
 131             .RetiresOnSaturation();
 132       }
 133     }
 134   }
 135   EXPECT_CALL(*gl, BindTexture(target, 0))
 136       .Times(1)
 137       .RetiresOnSaturation();
 138 }
 139
 140 void TestHelper::SetupTextureManagerInitExpectations(
 141     ::gfx::MockGLInterface* gl,
 142     const char* extensions) {
 143   InSequence sequence;
 144
 145   SetupTextureInitializationExpectations(gl, GL_TEXTURE_2D);
 146   SetupTextureInitializationExpectations(gl, GL_TEXTURE_CUBE_MAP);
 147
 148   bool ext_image_external = false;
 149   bool arb_texture_rectangle = false;
 150   base::CStringTokenizer t(extensions, extensions + strlen(extensions), " ");
 151   while (t.GetNext()) {
 152     if (t.token() == "GL_OES_EGL_image_external") {
 153       ext_image_external = true;
 154       break;
 155     }
 156     if (t.token() == "GL_ARB_texture_rectangle") {
 157       arb_texture_rectangle = true;
 158       break;
 159     }
 160   }
 161
 162   if (ext_image_external) {
 163     SetupTextureInitializationExpectations(gl, GL_TEXTURE_EXTERNAL_OES);
 164   }
 165   if (arb_texture_rectangle) {
 166     SetupTextureInitializationExpectations(gl, GL_TEXTURE_RECTANGLE_ARB);
 167   }
 168 }
 169
 170 void TestHelper::SetupTextureDestructionExpectations(
 171     ::gfx::MockGLInterface* gl, GLenum target) {
 172   GLuint texture_id = 0;
 173   switch (target) {
 174     case GL_TEXTURE_2D:
 175       texture_id = kServiceDefaultTexture2dId;
 176       break;
 177     case GL_TEXTURE_CUBE_MAP:
 178       texture_id = kServiceDefaultTextureCubemapId;
 179       break;
 180     case GL_TEXTURE_EXTERNAL_OES:
 181       texture_id = kServiceDefaultExternalTextureId;
 182       break;
 183     case GL_TEXTURE_RECTANGLE_ARB:
 184       texture_id = kServiceDefaultRectangleTextureId;
 185       break;
 186     default:
 187       NOTREACHED();
 188   }
 189
 190   EXPECT_CALL(*gl, DeleteTextures(1, Pointee(texture_id)))
 191       .Times(1)
 192       .RetiresOnSaturation();
 193 }
 194
 195 void TestHelper::SetupTextureManagerDestructionExpectations(
 196     ::gfx::MockGLInterface* gl,
 197     const char* extensions) {
 198   SetupTextureDestructionExpectations(gl, GL_TEXTURE_2D);
 199   SetupTextureDestructionExpectations(gl, GL_TEXTURE_CUBE_MAP);
 200
 201   bool ext_image_external = false;
 202   bool arb_texture_rectangle = false;
 203   base::CStringTokenizer t(extensions, extensions + strlen(extensions), " ");
 204   while (t.GetNext()) {
 205     if (t.token() == "GL_OES_EGL_image_external") {
 206       ext_image_external = true;
 207       break;
 208     }
 209     if (t.token() == "GL_ARB_texture_rectangle") {
 210       arb_texture_rectangle = true;
 211       break;
 212     }
 213   }
 214
 215   if (ext_image_external) {
 216     SetupTextureDestructionExpectations(gl, GL_TEXTURE_EXTERNAL_OES);
 217   }
 218   if (arb_texture_rectangle) {
 219     SetupTextureDestructionExpectations(gl, GL_TEXTURE_RECTANGLE_ARB);
 220   }
 221
 222   EXPECT_CALL(*gl, DeleteTextures(4, _))
 223       .Times(1)
 224       .RetiresOnSaturation();
 225 }
 226
 227 void TestHelper::SetupContextGroupInitExpectations(
 228       ::gfx::MockGLInterface* gl,
 229       const DisallowedFeatures& disallowed_features,
 230       const char* extensions,
 231       const char* gl_version) {
 232   InSequence sequence;
 233
 234   SetupFeatureInfoInitExpectationsWithGLVersion(gl, extensions, "", gl_version);
 235
 236   std::string l_version(StringToLowerASCII(std::string(gl_version)));
 237   bool is_es3 = (l_version.substr(0, 12) == "opengl es 3.");
 238
 239   EXPECT_CALL(*gl, GetIntegerv(GL_MAX_RENDERBUFFER_SIZE, _))
 240       .WillOnce(SetArgumentPointee<1>(kMaxRenderbufferSize))
 241       .RetiresOnSaturation();
 242   if (strstr(extensions, "GL_EXT_framebuffer_multisample") ||
 243       strstr(extensions, "GL_EXT_multisampled_render_to_texture") || is_es3) {
 244     EXPECT_CALL(*gl, GetIntegerv(GL_MAX_SAMPLES, _))
 245         .WillOnce(SetArgumentPointee<1>(kMaxSamples))
 246         .RetiresOnSaturation();
 247   } else if (strstr(extensions, "GL_IMG_multisampled_render_to_texture")) {
 248     EXPECT_CALL(*gl, GetIntegerv(GL_MAX_SAMPLES_IMG, _))
 249         .WillOnce(SetArgumentPointee<1>(kMaxSamples))
 250         .RetiresOnSaturation();
 251   }
 252   EXPECT_CALL(*gl, GetIntegerv(GL_MAX_VERTEX_ATTRIBS, _))
 253       .WillOnce(SetArgumentPointee<1>(kNumVertexAttribs))
 254       .RetiresOnSaturation();
 255   EXPECT_CALL(*gl, GetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, _))
 256       .WillOnce(SetArgumentPointee<1>(kNumTextureUnits))
 257       .RetiresOnSaturation();
 258   EXPECT_CALL(*gl, GetIntegerv(GL_MAX_TEXTURE_SIZE, _))
 259       .WillOnce(SetArgumentPointee<1>(kMaxTextureSize))
 260       .RetiresOnSaturation();
 261   EXPECT_CALL(*gl, GetIntegerv(GL_MAX_CUBE_MAP_TEXTURE_SIZE, _))
 262       .WillOnce(SetArgumentPointee<1>(kMaxCubeMapTextureSize))
 263       .RetiresOnSaturation();
 264   EXPECT_CALL(*gl, GetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, _))
 265       .WillOnce(SetArgumentPointee<1>(kMaxTextureImageUnits))
 266       .RetiresOnSaturation();
 267   EXPECT_CALL(*gl, GetIntegerv(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS, _))
 268       .WillOnce(SetArgumentPointee<1>(kMaxVertexTextureImageUnits))
 269       .RetiresOnSaturation();
 270   EXPECT_CALL(*gl, GetIntegerv(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, _))
 271       .WillOnce(SetArgumentPointee<1>(kMaxFragmentUniformComponents))
 272       .RetiresOnSaturation();
 273   EXPECT_CALL(*gl, GetIntegerv(GL_MAX_VARYING_FLOATS, _))
 274       .WillOnce(SetArgumentPointee<1>(kMaxVaryingFloats))
 275       .RetiresOnSaturation();
 276   EXPECT_CALL(*gl, GetIntegerv(GL_MAX_VERTEX_UNIFORM_COMPONENTS, _))
 277       .WillOnce(SetArgumentPointee<1>(kMaxVertexUniformComponents))
 278       .RetiresOnSaturation();
 279
 280   SetupTextureManagerInitExpectations(gl, extensions);
 281 }
 282
 283 void TestHelper::SetupFeatureInfoInitExpectations(
 284       ::gfx::MockGLInterface* gl, const char* extensions) {
 285   SetupFeatureInfoInitExpectationsWithGLVersion(gl, extensions, "", "");
 286 }
 287
 288 void TestHelper::SetupFeatureInfoInitExpectationsWithGLVersion(
 289      ::gfx::MockGLInterface* gl,
 290      const char* extensions,
 291      const char* gl_renderer,
 292      const char* gl_version) {
 293   InSequence sequence;
 294
 295   EXPECT_CALL(*gl, GetString(GL_EXTENSIONS))
 296       .WillOnce(Return(reinterpret_cast<const uint8*>(extensions)))
 297       .RetiresOnSaturation();
 298   EXPECT_CALL(*gl, GetString(GL_RENDERER))
 299       .WillOnce(Return(reinterpret_cast<const uint8*>(gl_renderer)))
 300       .RetiresOnSaturation();
 301   EXPECT_CALL(*gl, GetString(GL_VERSION))
 302       .WillOnce(Return(reinterpret_cast<const uint8*>(gl_version)))
 303       .RetiresOnSaturation();
 304
 305   std::string l_version(StringToLowerASCII(std::string(gl_version)));
 306   bool is_es3 = (l_version.substr(0, 12) == "opengl es 3.");
 307
 308   if (strstr(extensions, "GL_ARB_texture_float") ||
 309       (is_es3 && strstr(extensions, "GL_EXT_color_buffer_float"))) {
 310     static const GLuint gl_ids[] = {101, 102};
 311     const GLsizei width = 16;
 312     EXPECT_CALL(*gl, GetIntegerv(GL_FRAMEBUFFER_BINDING, _))
 313         .WillOnce(SetArgumentPointee<1>(gl_ids[0]))
 314         .RetiresOnSaturation();
 315     EXPECT_CALL(*gl, GetIntegerv(GL_TEXTURE_BINDING_2D, _))
 316         .WillOnce(SetArgumentPointee<1>(gl_ids[0]))
 317         .RetiresOnSaturation();
 318     EXPECT_CALL(*gl, GenTextures(1, _))
 319         .WillOnce(SetArrayArgument<1>(gl_ids + 1, gl_ids + 2))
 320         .RetiresOnSaturation();
 321     EXPECT_CALL(*gl, GenFramebuffersEXT(1, _))
 322         .WillOnce(SetArrayArgument<1>(gl_ids + 1, gl_ids + 2))
 323         .RetiresOnSaturation();
 324     EXPECT_CALL(*gl, BindTexture(GL_TEXTURE_2D, gl_ids[1]))
 325         .Times(1)
 326         .RetiresOnSaturation();
 327     EXPECT_CALL(*gl, TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
 328         GL_NEAREST))
 329         .Times(1)
 330         .RetiresOnSaturation();
 331     EXPECT_CALL(*gl, TexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, width, width, 0,
 332         GL_RGBA, GL_FLOAT, _))
 333         .Times(1)
 334         .RetiresOnSaturation();
 335     EXPECT_CALL(*gl, BindFramebufferEXT(GL_FRAMEBUFFER, gl_ids[1]))
 336         .Times(1)
 337         .RetiresOnSaturation();
 338     EXPECT_CALL(*gl, FramebufferTexture2DEXT(GL_FRAMEBUFFER,
 339         GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, gl_ids[1], 0))
 340         .Times(1)
 341         .RetiresOnSaturation();
 342     EXPECT_CALL(*gl, CheckFramebufferStatusEXT(GL_FRAMEBUFFER))
 343         .WillOnce(Return(GL_FRAMEBUFFER_COMPLETE))
 344         .RetiresOnSaturation();
 345     EXPECT_CALL(*gl, TexImage2D(GL_TEXTURE_2D, 0, GL_RGB32F, width, width, 0,
 346         GL_RGB, GL_FLOAT, _))
 347         .Times(1)
 348         .RetiresOnSaturation();
 349     if (is_es3) {
 350       EXPECT_CALL(*gl, CheckFramebufferStatusEXT(GL_FRAMEBUFFER))
 351           .WillOnce(Return(GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT))
 352           .RetiresOnSaturation();
 353     } else {
 354       EXPECT_CALL(*gl, CheckFramebufferStatusEXT(GL_FRAMEBUFFER))
 355           .WillOnce(Return(GL_FRAMEBUFFER_COMPLETE))
 356           .RetiresOnSaturation();
 357     }
 358     EXPECT_CALL(*gl, DeleteFramebuffersEXT(1, _))
 359         .Times(1)
 360         .RetiresOnSaturation();
 361     EXPECT_CALL(*gl, DeleteTextures(1, _))
 362         .Times(1)
 363         .RetiresOnSaturation();
 364     EXPECT_CALL(*gl, BindFramebufferEXT(GL_FRAMEBUFFER, gl_ids[0]))
 365         .Times(1)
 366         .RetiresOnSaturation();
 367     EXPECT_CALL(*gl, BindTexture(GL_TEXTURE_2D, gl_ids[0]))
 368         .Times(1)
 369         .RetiresOnSaturation();
 370     if (DCHECK_IS_ON()) {
 371       EXPECT_CALL(*gl, GetError())
 372           .WillOnce(Return(GL_NO_ERROR))
 373           .RetiresOnSaturation();
 374     }
 375   }
 376 }
 377
 378 void TestHelper::SetupExpectationsForClearingUniforms(
 379     ::gfx::MockGLInterface* gl, UniformInfo* uniforms, size_t num_uniforms) {
 380   for (size_t ii = 0; ii < num_uniforms; ++ii) {
 381     const UniformInfo& info = uniforms[ii];
 382     switch (info.type) {
 383     case GL_FLOAT:
 384       EXPECT_CALL(*gl, Uniform1fv(info.real_location, info.size, _))
 385           .Times(1)
 386           .RetiresOnSaturation();
 387       break;
 388     case GL_FLOAT_VEC2:
 389       EXPECT_CALL(*gl, Uniform2fv(info.real_location, info.size, _))
 390           .Times(1)
 391           .RetiresOnSaturation();
 392       break;
 393     case GL_FLOAT_VEC3:
 394       EXPECT_CALL(*gl, Uniform3fv(info.real_location, info.size, _))
 395           .Times(1)
 396           .RetiresOnSaturation();
 397       break;
 398     case GL_FLOAT_VEC4:
 399       EXPECT_CALL(*gl, Uniform4fv(info.real_location, info.size, _))
 400           .Times(1)
 401           .RetiresOnSaturation();
 402       break;
 403     case GL_INT:
 404     case GL_BOOL:
 405     case GL_SAMPLER_2D:
 406     case GL_SAMPLER_CUBE:
 407     case GL_SAMPLER_EXTERNAL_OES:
 408     case GL_SAMPLER_3D_OES:
 409     case GL_SAMPLER_2D_RECT_ARB:
 410       EXPECT_CALL(*gl, Uniform1iv(info.real_location, info.size, _))
 411           .Times(1)
 412           .RetiresOnSaturation();
 413       break;
 414     case GL_INT_VEC2:
 415     case GL_BOOL_VEC2:
 416       EXPECT_CALL(*gl, Uniform2iv(info.real_location, info.size, _))
 417           .Times(1)
 418           .RetiresOnSaturation();
 419       break;
 420     case GL_INT_VEC3:
 421     case GL_BOOL_VEC3:
 422       EXPECT_CALL(*gl, Uniform3iv(info.real_location, info.size, _))
 423           .Times(1)
 424           .RetiresOnSaturation();
 425       break;
 426     case GL_INT_VEC4:
 427     case GL_BOOL_VEC4:
 428       EXPECT_CALL(*gl, Uniform4iv(info.real_location, info.size, _))
 429           .Times(1)
 430           .RetiresOnSaturation();
 431       break;
 432     case GL_FLOAT_MAT2:
 433       EXPECT_CALL(*gl, UniformMatrix2fv(
 434           info.real_location, info.size, false, _))
 435           .Times(1)
 436           .RetiresOnSaturation();
 437       break;
 438     case GL_FLOAT_MAT3:
 439       EXPECT_CALL(*gl, UniformMatrix3fv(
 440           info.real_location, info.size, false, _))
 441           .Times(1)
 442           .RetiresOnSaturation();
 443       break;
 444     case GL_FLOAT_MAT4:
 445       EXPECT_CALL(*gl, UniformMatrix4fv(
 446           info.real_location, info.size, false, _))
 447           .Times(1)
 448           .RetiresOnSaturation();
 449       break;
 450     default:
 451       NOTREACHED();
 452       break;
 453     }
 454   }
 455 }
 456
 457 void TestHelper::SetupProgramSuccessExpectations(
 458     ::gfx::MockGLInterface* gl,
 459     AttribInfo* attribs, size_t num_attribs,
 460     UniformInfo* uniforms, size_t num_uniforms,
 461     GLuint service_id) {
 462   EXPECT_CALL(*gl,
 463       GetProgramiv(service_id, GL_LINK_STATUS, _))
 464       .WillOnce(SetArgumentPointee<2>(1))
 465       .RetiresOnSaturation();
 466   EXPECT_CALL(*gl,
 467       GetProgramiv(service_id, GL_INFO_LOG_LENGTH, _))
 468       .WillOnce(SetArgumentPointee<2>(0))
 469       .RetiresOnSaturation();
 470   EXPECT_CALL(*gl,
 471       GetProgramiv(service_id, GL_ACTIVE_ATTRIBUTES, _))
 472       .WillOnce(SetArgumentPointee<2>(num_attribs))
 473       .RetiresOnSaturation();
 474   size_t max_attrib_len = 0;
 475   for (size_t ii = 0; ii < num_attribs; ++ii) {
 476     size_t len = strlen(attribs[ii].name) + 1;
 477     max_attrib_len = std::max(max_attrib_len, len);
 478   }
 479   EXPECT_CALL(*gl,
 480       GetProgramiv(service_id, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, _))
 481       .WillOnce(SetArgumentPointee<2>(max_attrib_len))
 482       .RetiresOnSaturation();
 483
 484   for (size_t ii = 0; ii < num_attribs; ++ii) {
 485     const AttribInfo& info = attribs[ii];
 486     EXPECT_CALL(*gl,
 487         GetActiveAttrib(service_id, ii,
 488                         max_attrib_len, _, _, _, _))
 489         .WillOnce(DoAll(
 490             SetArgumentPointee<3>(strlen(info.name)),
 491             SetArgumentPointee<4>(info.size),
 492             SetArgumentPointee<5>(info.type),
 493             SetArrayArgument<6>(info.name,
 494                                 info.name + strlen(info.name) + 1)))
 495         .RetiresOnSaturation();
 496     if (!ProgramManager::IsInvalidPrefix(info.name, strlen(info.name))) {
 497       EXPECT_CALL(*gl, GetAttribLocation(service_id, StrEq(info.name)))
 498           .WillOnce(Return(info.location))
 499           .RetiresOnSaturation();
 500     }
 501   }
 502   EXPECT_CALL(*gl,
 503       GetProgramiv(service_id, GL_ACTIVE_UNIFORMS, _))
 504       .WillOnce(SetArgumentPointee<2>(num_uniforms))
 505       .RetiresOnSaturation();
 506
 507   size_t max_uniform_len = 0;
 508   for (size_t ii = 0; ii < num_uniforms; ++ii) {
 509     size_t len = strlen(uniforms[ii].name) + 1;
 510     max_uniform_len = std::max(max_uniform_len, len);
 511   }
 512   EXPECT_CALL(*gl,
 513       GetProgramiv(service_id, GL_ACTIVE_UNIFORM_MAX_LENGTH, _))
 514       .WillOnce(SetArgumentPointee<2>(max_uniform_len))
 515       .RetiresOnSaturation();
 516   for (size_t ii = 0; ii < num_uniforms; ++ii) {
 517     const UniformInfo& info = uniforms[ii];
 518     EXPECT_CALL(*gl,
 519         GetActiveUniform(service_id, ii,
 520                          max_uniform_len, _, _, _, _))
 521         .WillOnce(DoAll(
 522             SetArgumentPointee<3>(strlen(info.name)),
 523             SetArgumentPointee<4>(info.size),
 524             SetArgumentPointee<5>(info.type),
 525             SetArrayArgument<6>(info.name,
 526                                 info.name + strlen(info.name) + 1)))
 527         .RetiresOnSaturation();
 528   }
 529
 530   for (int pass = 0; pass < 2; ++pass) {
 531     for (size_t ii = 0; ii < num_uniforms; ++ii) {
 532       const UniformInfo& info = uniforms[ii];
 533       if (ProgramManager::IsInvalidPrefix(info.name, strlen(info.name))) {
 534         continue;
 535       }
 536       if (pass == 0) {
 537         EXPECT_CALL(*gl, GetUniformLocation(service_id, StrEq(info.name)))
 538             .WillOnce(Return(info.real_location))
 539             .RetiresOnSaturation();
 540       }
 541       if ((pass == 0 && info.desired_location >= 0) ||
 542           (pass == 1 && info.desired_location < 0)) {
 543         if (info.size > 1) {
 544           std::string base_name = info.name;
 545           size_t array_pos = base_name.rfind("[0]");
 546           if (base_name.size() > 3 && array_pos == base_name.size() - 3) {
 547             base_name = base_name.substr(0, base_name.size() - 3);
 548           }
 549           for (GLsizei jj = 1; jj < info.size; ++jj) {
 550             std::string element_name(
 551                 std::string(base_name) + "[" + base::IntToString(jj) + "]");
 552             EXPECT_CALL(*gl, GetUniformLocation(
 553                 service_id, StrEq(element_name)))
 554                 .WillOnce(Return(info.real_location + jj * 2))
 555                 .RetiresOnSaturation();
 556           }
 557         }
 558       }
 559     }
 560   }
 561 }
 562
 563 void TestHelper::SetupShader(
 564     ::gfx::MockGLInterface* gl,
 565     AttribInfo* attribs, size_t num_attribs,
 566     UniformInfo* uniforms, size_t num_uniforms,
 567     GLuint service_id) {
 568   InSequence s;
 569
 570   EXPECT_CALL(*gl,
 571       LinkProgram(service_id))
 572       .Times(1)
 573       .RetiresOnSaturation();
 574
 575   SetupProgramSuccessExpectations(
 576       gl, attribs, num_attribs, uniforms, num_uniforms, service_id);
 577 }
 578
 579 void TestHelper::DoBufferData(
 580     ::gfx::MockGLInterface* gl, MockErrorState* error_state,
 581     BufferManager* manager, Buffer* buffer, GLsizeiptr size, GLenum usage,
 582     const GLvoid* data, GLenum error) {
 583   EXPECT_CALL(*error_state, CopyRealGLErrorsToWrapper(_, _, _))
 584       .Times(1)
 585       .RetiresOnSaturation();
 586   if (manager->IsUsageClientSideArray(usage)) {
 587     EXPECT_CALL(*gl, BufferData(
 588         buffer->target(), 0, _, usage))
 589         .Times(1)
 590         .RetiresOnSaturation();
 591   } else {
 592     EXPECT_CALL(*gl, BufferData(
 593         buffer->target(), size, _, usage))
 594         .Times(1)
 595         .RetiresOnSaturation();
 596   }
 597   EXPECT_CALL(*error_state, PeekGLError(_, _, _))
 598       .WillOnce(Return(error))
 599       .RetiresOnSaturation();
 600   manager->DoBufferData(error_state, buffer, size, usage, data);
 601 }
 602
 603 void TestHelper::SetTexParameterWithExpectations(
 604     ::gfx::MockGLInterface* gl, MockErrorState* error_state,
 605     TextureManager* manager, TextureRef* texture_ref,
 606     GLenum pname, GLint value, GLenum error) {
 607   if (error == GL_NO_ERROR) {
 608     if (pname != GL_TEXTURE_POOL_CHROMIUM) {
 609       EXPECT_CALL(*gl, TexParameteri(texture_ref->texture()->target(),
 610                                      pname, value))
 611           .Times(1)
 612           .RetiresOnSaturation();
 613     }
 614   } else if (error == GL_INVALID_ENUM) {
 615     EXPECT_CALL(*error_state, SetGLErrorInvalidEnum(_, _, _, value, _))
 616         .Times(1)
 617         .RetiresOnSaturation();
 618   } else {
 619     EXPECT_CALL(*error_state, SetGLErrorInvalidParam(_, _, error, _, _, _))
 620         .Times(1)
 621         .RetiresOnSaturation();
 622   }
 623   manager->SetParameter("", error_state, texture_ref, pname, value);
 624 }
 625
 626 ScopedGLImplementationSetter::ScopedGLImplementationSetter(
 627     gfx::GLImplementation implementation)
 628     : old_implementation_(gfx::GetGLImplementation()) {
 629   gfx::SetGLImplementation(implementation);
 630 }
 631
 632 ScopedGLImplementationSetter::~ScopedGLImplementationSetter() {
 633   gfx::SetGLImplementation(old_implementation_);
 634 }
 635
 636 }  // namespace gles2
 637 }  // namespace gpu
 638