cc/test/test_web_graphics_context_3d.cc

   1 // Copyright 2013 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 "cc/test/test_web_graphics_context_3d.h"
   6
   7 #include <algorithm>
   8 #include <string>
   9
  10 #include "base/bind.h"
  11 #include "base/lazy_instance.h"
  12 #include "base/logging.h"
  13 #include "base/message_loop/message_loop.h"
  14 #include "cc/test/test_context_support.h"
  15 #include "gpu/GLES2/gl2extchromium.h"
  16 #include "testing/gtest/include/gtest/gtest.h"
  17 #include "third_party/khronos/GLES2/gl2ext.h"
  18
  19 namespace cc {
  20
  21 static unsigned s_context_id = 1;
  22
  23 const GLuint TestWebGraphicsContext3D::kExternalTextureId = 1337;
  24
  25 static base::LazyInstance<base::Lock>::Leaky
  26     g_shared_namespace_lock = LAZY_INSTANCE_INITIALIZER;
  27
  28 TestWebGraphicsContext3D::Namespace*
  29     TestWebGraphicsContext3D::shared_namespace_ = NULL;
  30
  31 TestWebGraphicsContext3D::Namespace::Namespace()
  32     : next_buffer_id(1),
  33       next_image_id(1),
  34       next_texture_id(1),
  35       next_renderbuffer_id(1) {
  36 }
  37
  38 TestWebGraphicsContext3D::Namespace::~Namespace() {
  39   g_shared_namespace_lock.Get().AssertAcquired();
  40   if (shared_namespace_ == this)
  41     shared_namespace_ = NULL;
  42 }
  43
  44 // static
  45 scoped_ptr<TestWebGraphicsContext3D> TestWebGraphicsContext3D::Create() {
  46   return make_scoped_ptr(new TestWebGraphicsContext3D());
  47 }
  48
  49 TestWebGraphicsContext3D::TestWebGraphicsContext3D()
  50     : context_id_(s_context_id++),
  51       times_bind_texture_succeeds_(-1),
  52       times_end_query_succeeds_(-1),
  53       context_lost_(false),
  54       times_map_buffer_chromium_succeeds_(-1),
  55       current_used_transfer_buffer_usage_bytes_(0),
  56       max_used_transfer_buffer_usage_bytes_(0),
  57       next_program_id_(1000),
  58       next_shader_id_(2000),
  59       next_framebuffer_id_(1),
  60       current_framebuffer_(0),
  61       max_texture_size_(2048),
  62       reshape_called_(false),
  63       width_(0),
  64       height_(0),
  65       scale_factor_(-1.f),
  66       test_support_(NULL),
  67       last_update_type_(NO_UPDATE),
  68       next_insert_sync_point_(1),
  69       last_waited_sync_point_(0),
  70       unpack_alignment_(4),
  71       bound_buffer_(0),
  72       weak_ptr_factory_(this) {
  73   CreateNamespace();
  74   set_support_image(true);
  75 }
  76
  77 TestWebGraphicsContext3D::~TestWebGraphicsContext3D() {
  78   base::AutoLock lock(g_shared_namespace_lock.Get());
  79   namespace_ = NULL;
  80 }
  81
  82 void TestWebGraphicsContext3D::CreateNamespace() {
  83   base::AutoLock lock(g_shared_namespace_lock.Get());
  84   if (shared_namespace_) {
  85     namespace_ = shared_namespace_;
  86   } else {
  87     namespace_ = new Namespace;
  88     shared_namespace_ = namespace_.get();
  89   }
  90 }
  91
  92 void TestWebGraphicsContext3D::reshapeWithScaleFactor(
  93     int width, int height, float scale_factor) {
  94   reshape_called_ = true;
  95   width_ = width;
  96   height_ = height;
  97   scale_factor_ = scale_factor;
  98 }
  99
 100 bool TestWebGraphicsContext3D::isContextLost() {
 101   return context_lost_;
 102 }
 103
 104 GLenum TestWebGraphicsContext3D::checkFramebufferStatus(
 105     GLenum target) {
 106   if (context_lost_)
 107     return GL_FRAMEBUFFER_UNDEFINED_OES;
 108   return GL_FRAMEBUFFER_COMPLETE;
 109 }
 110
 111 GLint TestWebGraphicsContext3D::getUniformLocation(
 112     GLuint program,
 113     const GLchar* name) {
 114   return 0;
 115 }
 116
 117 GLsizeiptr TestWebGraphicsContext3D::getVertexAttribOffset(
 118     GLuint index,
 119     GLenum pname) {
 120   return 0;
 121 }
 122
 123 GLboolean TestWebGraphicsContext3D::isBuffer(
 124     GLuint buffer) {
 125   return false;
 126 }
 127
 128 GLboolean TestWebGraphicsContext3D::isEnabled(
 129     GLenum cap) {
 130   return false;
 131 }
 132
 133 GLboolean TestWebGraphicsContext3D::isFramebuffer(
 134     GLuint framebuffer) {
 135   return false;
 136 }
 137
 138 GLboolean TestWebGraphicsContext3D::isProgram(
 139     GLuint program) {
 140   return false;
 141 }
 142
 143 GLboolean TestWebGraphicsContext3D::isRenderbuffer(
 144     GLuint renderbuffer) {
 145   return false;
 146 }
 147
 148 GLboolean TestWebGraphicsContext3D::isShader(
 149     GLuint shader) {
 150   return false;
 151 }
 152
 153 GLboolean TestWebGraphicsContext3D::isTexture(
 154     GLuint texture) {
 155   return false;
 156 }
 157
 158 void TestWebGraphicsContext3D::genBuffers(GLsizei count, GLuint* ids) {
 159   for (int i = 0; i < count; ++i)
 160     ids[i] = NextBufferId();
 161 }
 162
 163 void TestWebGraphicsContext3D::genFramebuffers(
 164     GLsizei count, GLuint* ids) {
 165   for (int i = 0; i < count; ++i)
 166     ids[i] = NextFramebufferId();
 167 }
 168
 169 void TestWebGraphicsContext3D::genRenderbuffers(
 170     GLsizei count, GLuint* ids) {
 171   for (int i = 0; i < count; ++i)
 172     ids[i] = NextRenderbufferId();
 173 }
 174
 175 void TestWebGraphicsContext3D::genTextures(GLsizei count, GLuint* ids) {
 176   for (int i = 0; i < count; ++i) {
 177     ids[i] = NextTextureId();
 178     DCHECK_NE(ids[i], kExternalTextureId);
 179   }
 180   base::AutoLock lock(namespace_->lock);
 181   for (int i = 0; i < count; ++i)
 182     namespace_->textures.Append(ids[i], new TestTexture());
 183 }
 184
 185 void TestWebGraphicsContext3D::deleteBuffers(GLsizei count, GLuint* ids) {
 186   for (int i = 0; i < count; ++i)
 187     RetireBufferId(ids[i]);
 188 }
 189
 190 void TestWebGraphicsContext3D::deleteFramebuffers(
 191     GLsizei count, GLuint* ids) {
 192   for (int i = 0; i < count; ++i) {
 193     if (ids[i]) {
 194       RetireFramebufferId(ids[i]);
 195       if (ids[i] == current_framebuffer_)
 196         current_framebuffer_ = 0;
 197     }
 198   }
 199 }
 200
 201 void TestWebGraphicsContext3D::deleteRenderbuffers(
 202     GLsizei count, GLuint* ids) {
 203   for (int i = 0; i < count; ++i)
 204     RetireRenderbufferId(ids[i]);
 205 }
 206
 207 void TestWebGraphicsContext3D::deleteTextures(GLsizei count, GLuint* ids) {
 208   for (int i = 0; i < count; ++i)
 209     RetireTextureId(ids[i]);
 210   base::AutoLock lock(namespace_->lock);
 211   for (int i = 0; i < count; ++i) {
 212     namespace_->textures.Remove(ids[i]);
 213     texture_targets_.UnbindTexture(ids[i]);
 214   }
 215 }
 216
 217 GLuint TestWebGraphicsContext3D::createBuffer() {
 218   GLuint id;
 219   genBuffers(1, &id);
 220   return id;
 221 }
 222
 223 GLuint TestWebGraphicsContext3D::createFramebuffer() {
 224   GLuint id;
 225   genFramebuffers(1, &id);
 226   return id;
 227 }
 228
 229 GLuint TestWebGraphicsContext3D::createRenderbuffer() {
 230   GLuint id;
 231   genRenderbuffers(1, &id);
 232   return id;
 233 }
 234
 235 GLuint TestWebGraphicsContext3D::createTexture() {
 236   GLuint id;
 237   genTextures(1, &id);
 238   return id;
 239 }
 240
 241 void TestWebGraphicsContext3D::deleteBuffer(GLuint id) {
 242   deleteBuffers(1, &id);
 243 }
 244
 245 void TestWebGraphicsContext3D::deleteFramebuffer(GLuint id) {
 246   deleteFramebuffers(1, &id);
 247 }
 248
 249 void TestWebGraphicsContext3D::deleteRenderbuffer(GLuint id) {
 250   deleteRenderbuffers(1, &id);
 251 }
 252
 253 void TestWebGraphicsContext3D::deleteTexture(GLuint id) {
 254   deleteTextures(1, &id);
 255 }
 256
 257 unsigned TestWebGraphicsContext3D::createProgram() {
 258   unsigned program = next_program_id_++ | context_id_ << 16;
 259   program_set_.insert(program);
 260   return program;
 261 }
 262
 263 GLuint TestWebGraphicsContext3D::createShader(GLenum) {
 264   unsigned shader = next_shader_id_++ | context_id_ << 16;
 265   shader_set_.insert(shader);
 266   return shader;
 267 }
 268
 269 GLuint TestWebGraphicsContext3D::createExternalTexture() {
 270   base::AutoLock lock(namespace_->lock);
 271   namespace_->textures.Append(kExternalTextureId, new TestTexture());
 272   return kExternalTextureId;
 273 }
 274
 275 void TestWebGraphicsContext3D::deleteProgram(GLuint id) {
 276   if (!program_set_.count(id))
 277     ADD_FAILURE() << "deleteProgram called on unknown program " << id;
 278   program_set_.erase(id);
 279 }
 280
 281 void TestWebGraphicsContext3D::deleteShader(GLuint id) {
 282   if (!shader_set_.count(id))
 283     ADD_FAILURE() << "deleteShader called on unknown shader " << id;
 284   shader_set_.erase(id);
 285 }
 286
 287 void TestWebGraphicsContext3D::attachShader(GLuint program, GLuint shader) {
 288   if (!program_set_.count(program))
 289     ADD_FAILURE() << "attachShader called with unknown program " << program;
 290   if (!shader_set_.count(shader))
 291     ADD_FAILURE() << "attachShader called with unknown shader " << shader;
 292 }
 293
 294 void TestWebGraphicsContext3D::useProgram(GLuint program) {
 295   if (!program)
 296     return;
 297   if (!program_set_.count(program))
 298     ADD_FAILURE() << "useProgram called on unknown program " << program;
 299 }
 300
 301 void TestWebGraphicsContext3D::bindFramebuffer(
 302     GLenum target, GLuint framebuffer) {
 303   base::AutoLock lock_for_framebuffer_access(namespace_->lock);
 304   if (framebuffer != 0 &&
 305       framebuffer_set_.find(framebuffer) == framebuffer_set_.end()) {
 306     ADD_FAILURE() << "bindFramebuffer called with unknown framebuffer";
 307   } else if (framebuffer != 0 && (framebuffer >> 16) != context_id_) {
 308     ADD_FAILURE()
 309         << "bindFramebuffer called with framebuffer from other context";
 310   } else {
 311     current_framebuffer_ = framebuffer;
 312   }
 313 }
 314
 315 void TestWebGraphicsContext3D::bindRenderbuffer(
 316       GLenum target, GLuint renderbuffer) {
 317   if (!renderbuffer)
 318     return;
 319   base::AutoLock lock_for_renderbuffer_access(namespace_->lock);
 320   if (renderbuffer != 0 &&
 321       namespace_->renderbuffer_set.find(renderbuffer) ==
 322           namespace_->renderbuffer_set.end()) {
 323     ADD_FAILURE() << "bindRenderbuffer called with unknown renderbuffer";
 324   } else if ((renderbuffer >> 16) != context_id_) {
 325     ADD_FAILURE()
 326         << "bindRenderbuffer called with renderbuffer from other context";
 327   }
 328 }
 329
 330 void TestWebGraphicsContext3D::bindTexture(
 331     GLenum target, GLuint texture_id) {
 332   if (times_bind_texture_succeeds_ >= 0) {
 333     if (!times_bind_texture_succeeds_) {
 334       loseContextCHROMIUM(GL_GUILTY_CONTEXT_RESET_ARB,
 335                           GL_INNOCENT_CONTEXT_RESET_ARB);
 336     }
 337     --times_bind_texture_succeeds_;
 338   }
 339
 340   if (!texture_id)
 341     return;
 342   base::AutoLock lock(namespace_->lock);
 343   DCHECK(namespace_->textures.ContainsId(texture_id));
 344   texture_targets_.BindTexture(target, texture_id);
 345   used_textures_.insert(texture_id);
 346 }
 347
 348 GLuint TestWebGraphicsContext3D::BoundTextureId(
 349     GLenum target) {
 350   return texture_targets_.BoundTexture(target);
 351 }
 352
 353 scoped_refptr<TestTexture> TestWebGraphicsContext3D::BoundTexture(
 354     GLenum target) {
 355   // The caller is expected to lock the namespace for texture access.
 356   namespace_->lock.AssertAcquired();
 357   return namespace_->textures.TextureForId(BoundTextureId(target));
 358 }
 359
 360 scoped_refptr<TestTexture> TestWebGraphicsContext3D::UnboundTexture(
 361     GLuint texture) {
 362   // The caller is expected to lock the namespace for texture access.
 363   namespace_->lock.AssertAcquired();
 364   return namespace_->textures.TextureForId(texture);
 365 }
 366
 367 void TestWebGraphicsContext3D::CheckTextureIsBound(GLenum target) {
 368   DCHECK(BoundTextureId(target));
 369 }
 370
 371 GLuint TestWebGraphicsContext3D::createQueryEXT() { return 1u; }
 372
 373 void TestWebGraphicsContext3D::endQueryEXT(GLenum target) {
 374   if (times_end_query_succeeds_ >= 0) {
 375     if (!times_end_query_succeeds_) {
 376       loseContextCHROMIUM(GL_GUILTY_CONTEXT_RESET_ARB,
 377                           GL_INNOCENT_CONTEXT_RESET_ARB);
 378     }
 379     --times_end_query_succeeds_;
 380   }
 381 }
 382
 383 void TestWebGraphicsContext3D::getQueryObjectuivEXT(
 384     GLuint query,
 385     GLenum pname,
 386     GLuint* params) {
 387   // If the context is lost, behave as if result is available.
 388   if (pname == GL_QUERY_RESULT_AVAILABLE_EXT)
 389     *params = 1;
 390 }
 391
 392 void TestWebGraphicsContext3D::getIntegerv(
 393     GLenum pname,
 394     GLint* value) {
 395   if (pname == GL_MAX_TEXTURE_SIZE)
 396     *value = max_texture_size_;
 397   else if (pname == GL_ACTIVE_TEXTURE)
 398     *value = GL_TEXTURE0;
 399   else if (pname == GL_UNPACK_ALIGNMENT)
 400     *value = unpack_alignment_;
 401   else if (pname == GL_FRAMEBUFFER_BINDING)
 402     *value = current_framebuffer_;
 403 }
 404
 405 void TestWebGraphicsContext3D::getProgramiv(GLuint program,
 406                                             GLenum pname,
 407                                             GLint* value) {
 408   if (pname == GL_LINK_STATUS)
 409     *value = 1;
 410 }
 411
 412 void TestWebGraphicsContext3D::getShaderiv(GLuint shader,
 413                                            GLenum pname,
 414                                            GLint* value) {
 415   if (pname == GL_COMPILE_STATUS)
 416     *value = 1;
 417 }
 418
 419 void TestWebGraphicsContext3D::getShaderPrecisionFormat(GLenum shadertype,
 420                                                         GLenum precisiontype,
 421                                                         GLint* range,
 422                                                         GLint* precision) {
 423   // Return the minimum precision requirements of the GLES2
 424   // specification.
 425   switch (precisiontype) {
 426     case GL_LOW_INT:
 427       range[0] = 8;
 428       range[1] = 8;
 429       *precision = 0;
 430       break;
 431     case GL_MEDIUM_INT:
 432       range[0] = 10;
 433       range[1] = 10;
 434       *precision = 0;
 435       break;
 436     case GL_HIGH_INT:
 437       range[0] = 16;
 438       range[1] = 16;
 439       *precision = 0;
 440       break;
 441     case GL_LOW_FLOAT:
 442       range[0] = 8;
 443       range[1] = 8;
 444       *precision = 8;
 445       break;
 446     case GL_MEDIUM_FLOAT:
 447       range[0] = 14;
 448       range[1] = 14;
 449       *precision = 10;
 450       break;
 451     case GL_HIGH_FLOAT:
 452       range[0] = 62;
 453       range[1] = 62;
 454       *precision = 16;
 455       break;
 456     default:
 457       NOTREACHED();
 458       break;
 459   }
 460 }
 461
 462 void TestWebGraphicsContext3D::genMailboxCHROMIUM(GLbyte* mailbox) {
 463   static char mailbox_name1 = '1';
 464   static char mailbox_name2 = '1';
 465   mailbox[0] = mailbox_name1;
 466   mailbox[1] = mailbox_name2;
 467   mailbox[2] = '\0';
 468   if (++mailbox_name1 == 0) {
 469     mailbox_name1 = '1';
 470     ++mailbox_name2;
 471   }
 472 }
 473
 474 GLuint TestWebGraphicsContext3D::createAndConsumeTextureCHROMIUM(
 475     GLenum target,
 476     const GLbyte* mailbox) {
 477   GLuint texture_id = createTexture();
 478   consumeTextureCHROMIUM(target, mailbox);
 479   return texture_id;
 480 }
 481
 482 void TestWebGraphicsContext3D::loseContextCHROMIUM(GLenum current,
 483                                                    GLenum other) {
 484   if (context_lost_)
 485     return;
 486   context_lost_ = true;
 487   if (!context_lost_callback_.is_null())
 488     context_lost_callback_.Run();
 489
 490   for (size_t i = 0; i < shared_contexts_.size(); ++i)
 491     shared_contexts_[i]->loseContextCHROMIUM(current, other);
 492   shared_contexts_.clear();
 493 }
 494
 495 void TestWebGraphicsContext3D::finish() {
 496   test_support_->CallAllSyncPointCallbacks();
 497 }
 498
 499 void TestWebGraphicsContext3D::flush() {
 500   test_support_->CallAllSyncPointCallbacks();
 501 }
 502
 503 GLint TestWebGraphicsContext3D::getAttribLocation(GLuint program,
 504                                                   const GLchar* name) {
 505   return 0;
 506 }
 507
 508 GLenum TestWebGraphicsContext3D::getError() { return GL_NO_ERROR; }
 509
 510 void TestWebGraphicsContext3D::bindBuffer(GLenum target,
 511                                           GLuint buffer) {
 512   bound_buffer_ = buffer;
 513   if (!bound_buffer_)
 514     return;
 515   unsigned context_id = buffer >> 16;
 516   unsigned buffer_id = buffer & 0xffff;
 517   base::AutoLock lock(namespace_->lock);
 518   DCHECK(buffer_id);
 519   DCHECK_LT(buffer_id, namespace_->next_buffer_id);
 520   DCHECK_EQ(context_id, context_id_);
 521
 522   base::ScopedPtrHashMap<unsigned, scoped_ptr<Buffer>>& buffers =
 523       namespace_->buffers;
 524   if (buffers.count(bound_buffer_) == 0)
 525     buffers.set(bound_buffer_, make_scoped_ptr(new Buffer).Pass());
 526
 527   buffers.get(bound_buffer_)->target = target;
 528 }
 529
 530 void TestWebGraphicsContext3D::bufferData(GLenum target,
 531                                           GLsizeiptr size,
 532                                           const void* data,
 533                                           GLenum usage) {
 534   base::AutoLock lock(namespace_->lock);
 535   base::ScopedPtrHashMap<unsigned, scoped_ptr<Buffer>>& buffers =
 536       namespace_->buffers;
 537   DCHECK_GT(buffers.count(bound_buffer_), 0u);
 538   DCHECK_EQ(target, buffers.get(bound_buffer_)->target);
 539   Buffer* buffer = buffers.get(bound_buffer_);
 540   if (context_lost_) {
 541     buffer->pixels = nullptr;
 542     return;
 543   }
 544
 545   size_t old_size = buffer->size;
 546
 547   buffer->pixels.reset(new uint8[size]);
 548   buffer->size = size;
 549   if (data != NULL)
 550     memcpy(buffer->pixels.get(), data, size);
 551   if (buffer->target == GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM)
 552     current_used_transfer_buffer_usage_bytes_ += buffer->size - old_size;
 553   max_used_transfer_buffer_usage_bytes_ =
 554       std::max(max_used_transfer_buffer_usage_bytes_,
 555                current_used_transfer_buffer_usage_bytes_);
 556 }
 557
 558 void TestWebGraphicsContext3D::pixelStorei(GLenum pname, GLint param) {
 559   switch (pname) {
 560     case GL_UNPACK_ALIGNMENT:
 561       // Param should be a power of two <= 8.
 562       EXPECT_EQ(0, param & (param - 1));
 563       EXPECT_GE(8, param);
 564       switch (param) {
 565         case 1:
 566         case 2:
 567         case 4:
 568         case 8:
 569           unpack_alignment_ = param;
 570           break;
 571         default:
 572           break;
 573       }
 574       break;
 575     default:
 576       break;
 577   }
 578 }
 579
 580 void* TestWebGraphicsContext3D::mapBufferCHROMIUM(GLenum target,
 581                                                   GLenum access) {
 582   base::AutoLock lock(namespace_->lock);
 583   base::ScopedPtrHashMap<unsigned, scoped_ptr<Buffer>>& buffers =
 584       namespace_->buffers;
 585   DCHECK_GT(buffers.count(bound_buffer_), 0u);
 586   DCHECK_EQ(target, buffers.get(bound_buffer_)->target);
 587   if (times_map_buffer_chromium_succeeds_ >= 0) {
 588     if (!times_map_buffer_chromium_succeeds_) {
 589       return NULL;
 590     }
 591     --times_map_buffer_chromium_succeeds_;
 592   }
 593
 594   return buffers.get(bound_buffer_)->pixels.get();
 595 }
 596
 597 GLboolean TestWebGraphicsContext3D::unmapBufferCHROMIUM(
 598     GLenum target) {
 599   base::AutoLock lock(namespace_->lock);
 600   base::ScopedPtrHashMap<unsigned, scoped_ptr<Buffer>>& buffers =
 601       namespace_->buffers;
 602   DCHECK_GT(buffers.count(bound_buffer_), 0u);
 603   DCHECK_EQ(target, buffers.get(bound_buffer_)->target);
 604   buffers.get(bound_buffer_)->pixels = nullptr;
 605   return true;
 606 }
 607
 608 GLuint TestWebGraphicsContext3D::createImageCHROMIUM(ClientBuffer buffer,
 609                                                      GLsizei width,
 610                                                      GLsizei height,
 611                                                      GLenum internalformat) {
 612   DCHECK_EQ(GL_RGBA, static_cast<int>(internalformat));
 613   GLuint image_id = NextImageId();
 614   base::AutoLock lock(namespace_->lock);
 615   base::hash_set<unsigned>& images = namespace_->images;
 616   images.insert(image_id);
 617   return image_id;
 618 }
 619
 620 void TestWebGraphicsContext3D::destroyImageCHROMIUM(
 621     GLuint id) {
 622   RetireImageId(id);
 623   base::AutoLock lock(namespace_->lock);
 624   base::hash_set<unsigned>& images = namespace_->images;
 625   if (!images.count(id))
 626     ADD_FAILURE() << "destroyImageCHROMIUM called on unknown image " << id;
 627   images.erase(id);
 628 }
 629
 630 GLuint TestWebGraphicsContext3D::createGpuMemoryBufferImageCHROMIUM(
 631     GLsizei width,
 632     GLsizei height,
 633     GLenum internalformat,
 634     GLenum usage) {
 635   DCHECK_EQ(GL_RGBA, static_cast<int>(internalformat));
 636   GLuint image_id = NextImageId();
 637   base::AutoLock lock(namespace_->lock);
 638   base::hash_set<unsigned>& images = namespace_->images;
 639   images.insert(image_id);
 640   return image_id;
 641 }
 642
 643 unsigned TestWebGraphicsContext3D::insertSyncPoint() {
 644   return next_insert_sync_point_++;
 645 }
 646
 647 void TestWebGraphicsContext3D::waitSyncPoint(unsigned sync_point) {
 648   if (sync_point)
 649     last_waited_sync_point_ = sync_point;
 650 }
 651
 652 size_t TestWebGraphicsContext3D::NumTextures() const {
 653   base::AutoLock lock(namespace_->lock);
 654   return namespace_->textures.Size();
 655 }
 656
 657 GLuint TestWebGraphicsContext3D::TextureAt(int i) const {
 658   base::AutoLock lock(namespace_->lock);
 659   return namespace_->textures.IdAt(i);
 660 }
 661
 662 GLuint TestWebGraphicsContext3D::NextTextureId() {
 663   base::AutoLock lock(namespace_->lock);
 664   GLuint texture_id = namespace_->next_texture_id++;
 665   DCHECK(texture_id < (1 << 16));
 666   texture_id |= context_id_ << 16;
 667   return texture_id;
 668 }
 669
 670 void TestWebGraphicsContext3D::RetireTextureId(GLuint id) {
 671   base::AutoLock lock(namespace_->lock);
 672   unsigned context_id = id >> 16;
 673   unsigned texture_id = id & 0xffff;
 674   DCHECK(texture_id);
 675   DCHECK_LT(texture_id, namespace_->next_texture_id);
 676   DCHECK_EQ(context_id, context_id_);
 677 }
 678
 679 GLuint TestWebGraphicsContext3D::NextBufferId() {
 680   base::AutoLock lock(namespace_->lock);
 681   GLuint buffer_id = namespace_->next_buffer_id++;
 682   DCHECK(buffer_id < (1 << 16));
 683   buffer_id |= context_id_ << 16;
 684   return buffer_id;
 685 }
 686
 687 void TestWebGraphicsContext3D::RetireBufferId(GLuint id) {
 688   base::AutoLock lock(namespace_->lock);
 689   unsigned context_id = id >> 16;
 690   unsigned buffer_id = id & 0xffff;
 691   DCHECK(buffer_id);
 692   DCHECK_LT(buffer_id, namespace_->next_buffer_id);
 693   DCHECK_EQ(context_id, context_id_);
 694 }
 695
 696 GLuint TestWebGraphicsContext3D::NextImageId() {
 697   base::AutoLock lock(namespace_->lock);
 698   GLuint image_id = namespace_->next_image_id++;
 699   DCHECK(image_id < (1 << 16));
 700   image_id |= context_id_ << 16;
 701   return image_id;
 702 }
 703
 704 void TestWebGraphicsContext3D::RetireImageId(GLuint id) {
 705   base::AutoLock lock(namespace_->lock);
 706   unsigned context_id = id >> 16;
 707   unsigned image_id = id & 0xffff;
 708   DCHECK(image_id);
 709   DCHECK_LT(image_id, namespace_->next_image_id);
 710   DCHECK_EQ(context_id, context_id_);
 711 }
 712
 713 GLuint TestWebGraphicsContext3D::NextFramebufferId() {
 714   base::AutoLock lock_for_framebuffer_access(namespace_->lock);
 715   GLuint id = next_framebuffer_id_++;
 716   DCHECK(id < (1 << 16));
 717   id |= context_id_ << 16;
 718   framebuffer_set_.insert(id);
 719   return id;
 720 }
 721
 722 void TestWebGraphicsContext3D::RetireFramebufferId(GLuint id) {
 723   base::AutoLock lock_for_framebuffer_access(namespace_->lock);
 724   DCHECK(framebuffer_set_.find(id) != framebuffer_set_.end());
 725   framebuffer_set_.erase(id);
 726 }
 727
 728 GLuint TestWebGraphicsContext3D::NextRenderbufferId() {
 729   base::AutoLock lock_for_renderbuffer_access(namespace_->lock);
 730   GLuint id = namespace_->next_renderbuffer_id++;
 731   DCHECK(id < (1 << 16));
 732   id |= context_id_ << 16;
 733   namespace_->renderbuffer_set.insert(id);
 734   return id;
 735 }
 736
 737 void TestWebGraphicsContext3D::RetireRenderbufferId(GLuint id) {
 738   base::AutoLock lock_for_renderbuffer_access(namespace_->lock);
 739   DCHECK(namespace_->renderbuffer_set.find(id) !=
 740          namespace_->renderbuffer_set.end());
 741   namespace_->renderbuffer_set.erase(id);
 742 }
 743
 744 void TestWebGraphicsContext3D::SetMaxTransferBufferUsageBytes(
 745     size_t max_transfer_buffer_usage_bytes) {
 746   test_capabilities_.max_transfer_buffer_usage_bytes =
 747       max_transfer_buffer_usage_bytes;
 748 }
 749
 750 TestWebGraphicsContext3D::TextureTargets::TextureTargets() {
 751   // Initialize default bindings.
 752   bound_textures_[GL_TEXTURE_2D] = 0;
 753   bound_textures_[GL_TEXTURE_EXTERNAL_OES] = 0;
 754   bound_textures_[GL_TEXTURE_RECTANGLE_ARB] = 0;
 755 }
 756
 757 TestWebGraphicsContext3D::TextureTargets::~TextureTargets() {}
 758
 759 void TestWebGraphicsContext3D::TextureTargets::BindTexture(
 760     GLenum target,
 761     GLuint id) {
 762   // Make sure this is a supported target by seeing if it was bound to before.
 763   DCHECK(bound_textures_.find(target) != bound_textures_.end());
 764   bound_textures_[target] = id;
 765 }
 766
 767 void TestWebGraphicsContext3D::texParameteri(GLenum target,
 768                                              GLenum pname,
 769                                              GLint param) {
 770   CheckTextureIsBound(target);
 771   base::AutoLock lock_for_texture_access(namespace_->lock);
 772   scoped_refptr<TestTexture> texture = BoundTexture(target);
 773   DCHECK(texture->IsValidParameter(pname));
 774   texture->params[pname] = param;
 775 }
 776
 777 void TestWebGraphicsContext3D::getTexParameteriv(GLenum target,
 778                                                  GLenum pname,
 779                                                  GLint* value) {
 780   CheckTextureIsBound(target);
 781   base::AutoLock lock_for_texture_access(namespace_->lock);
 782   scoped_refptr<TestTexture> texture = BoundTexture(target);
 783   DCHECK(texture->IsValidParameter(pname));
 784   TestTexture::TextureParametersMap::iterator it = texture->params.find(pname);
 785   if (it != texture->params.end())
 786     *value = it->second;
 787 }
 788
 789 void TestWebGraphicsContext3D::TextureTargets::UnbindTexture(
 790     GLuint id) {
 791   // Bind zero to any targets that the id is bound to.
 792   for (TargetTextureMap::iterator it = bound_textures_.begin();
 793        it != bound_textures_.end();
 794        it++) {
 795     if (it->second == id)
 796       it->second = 0;
 797   }
 798 }
 799
 800 GLuint TestWebGraphicsContext3D::TextureTargets::BoundTexture(
 801     GLenum target) {
 802   DCHECK(bound_textures_.find(target) != bound_textures_.end());
 803   return bound_textures_[target];
 804 }
 805
 806 TestWebGraphicsContext3D::Buffer::Buffer() : target(0), size(0) {}
 807
 808 TestWebGraphicsContext3D::Buffer::~Buffer() {}
 809
 810 TestWebGraphicsContext3D::Image::Image() {}
 811
 812 TestWebGraphicsContext3D::Image::~Image() {}
 813
 814 }  // namespace cc