Roll Chrome into Mojo.

cc/test/test_web_graphics_context_3d.cc

 // Copyright 2013 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 "cc/test/test_web_graphics_context_3d.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "cc/test/test_context_support.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
 
 namespace cc {
 
-static const GLuint kFramebufferId = 1;
-static const GLuint kRenderbufferId = 2;
-
 static unsigned s_context_id = 1;
 
 const GLuint TestWebGraphicsContext3D::kExternalTextureId = 1337;
 
 static base::LazyInstance<base::Lock>::Leaky
     g_shared_namespace_lock = LAZY_INSTANCE_INITIALIZER;
 
 TestWebGraphicsContext3D::Namespace*
     TestWebGraphicsContext3D::shared_namespace_ = NULL;
 
 TestWebGraphicsContext3D::Namespace::Namespace()
     : next_buffer_id(1),
       next_image_id(1),
-      next_texture_id(1) {
+      next_texture_id(1),
+      next_renderbuffer_id(1) {
 }
 
 TestWebGraphicsContext3D::Namespace::~Namespace() {
   g_shared_namespace_lock.Get().AssertAcquired();
   if (shared_namespace_ == this)
     shared_namespace_ = NULL;
 }
 
 // static
 scoped_ptr<TestWebGraphicsContext3D> TestWebGraphicsContext3D::Create() {
   return make_scoped_ptr(new TestWebGraphicsContext3D());
 }
 
 TestWebGraphicsContext3D::TestWebGraphicsContext3D()
     : context_id_(s_context_id++),
       times_bind_texture_succeeds_(-1),
       times_end_query_succeeds_(-1),
       context_lost_(false),
       times_map_buffer_chromium_succeeds_(-1),
       current_used_transfer_buffer_usage_bytes_(0),
       max_used_transfer_buffer_usage_bytes_(0),
       next_program_id_(1000),
       next_shader_id_(2000),
+      next_framebuffer_id_(1),
+      current_framebuffer_(0),
       max_texture_size_(2048),
       reshape_called_(false),
       width_(0),
       height_(0),
       scale_factor_(-1.f),
       test_support_(NULL),
       last_update_type_(NoUpdate),
       next_insert_sync_point_(1),
       last_waited_sync_point_(0),
       unpack_alignment_(4),
@@ skipping 84 matching lines @@
 }
 
 void TestWebGraphicsContext3D::genBuffers(GLsizei count, GLuint* ids) {
   for (int i = 0; i < count; ++i)
     ids[i] = NextBufferId();
 }
 
 void TestWebGraphicsContext3D::genFramebuffers(
     GLsizei count, GLuint* ids) {
   for (int i = 0; i < count; ++i)
-    ids[i] = kFramebufferId | context_id_ << 16;
+    ids[i] = NextFramebufferId();
 }
 
 void TestWebGraphicsContext3D::genRenderbuffers(
     GLsizei count, GLuint* ids) {
   for (int i = 0; i < count; ++i)
-    ids[i] = kRenderbufferId | context_id_ << 16;
+    ids[i] = NextRenderbufferId();
 }
 
 void TestWebGraphicsContext3D::genTextures(GLsizei count, GLuint* ids) {
   for (int i = 0; i < count; ++i) {
     ids[i] = NextTextureId();
     DCHECK_NE(ids[i], kExternalTextureId);
   }
   base::AutoLock lock(namespace_->lock);
   for (int i = 0; i < count; ++i)
     namespace_->textures.Append(ids[i], new TestTexture());
 }
 
 void TestWebGraphicsContext3D::deleteBuffers(GLsizei count, GLuint* ids) {
   for (int i = 0; i < count; ++i)
     RetireBufferId(ids[i]);
 }
 
 void TestWebGraphicsContext3D::deleteFramebuffers(
     GLsizei count, GLuint* ids) {
-  for (int i = 0; i < count; ++i)
-    DCHECK_EQ(kFramebufferId | context_id_ << 16, ids[i]);
+  for (int i = 0; i < count; ++i) {
+    if (ids[i]) {
+      RetireFramebufferId(ids[i]);
+      if (ids[i] == current_framebuffer_)
+        current_framebuffer_ = 0;
+    }
+  }
 }
 
 void TestWebGraphicsContext3D::deleteRenderbuffers(
     GLsizei count, GLuint* ids) {
   for (int i = 0; i < count; ++i)
-    DCHECK_EQ(kRenderbufferId | context_id_ << 16, ids[i]);
+    RetireRenderbufferId(ids[i]);
 }
 
 void TestWebGraphicsContext3D::deleteTextures(GLsizei count, GLuint* ids) {
   for (int i = 0; i < count; ++i)
     RetireTextureId(ids[i]);
   base::AutoLock lock(namespace_->lock);
   for (int i = 0; i < count; ++i) {
     namespace_->textures.Remove(ids[i]);
     texture_targets_.UnbindTexture(ids[i]);
   }
@@ skipping 78 matching lines @@
 
 void TestWebGraphicsContext3D::useProgram(GLuint program) {
   if (!program)
     return;
   if (!program_set_.count(program))
     ADD_FAILURE() << "useProgram called on unknown program " << program;
 }
 
 void TestWebGraphicsContext3D::bindFramebuffer(
     GLenum target, GLuint framebuffer) {
-  if (!framebuffer)
-    return;
-  DCHECK_EQ(kFramebufferId | context_id_ << 16, framebuffer);
+  base::AutoLock lock_for_framebuffer_access(namespace_->lock);
+  if (framebuffer != 0 &&
+      framebuffer_set_.find(framebuffer) == framebuffer_set_.end()) {
+    ADD_FAILURE() << "bindFramebuffer called with unknown framebuffer";
+  } else if (framebuffer != 0 && (framebuffer >> 16) != context_id_) {
+    ADD_FAILURE()
+        << "bindFramebuffer called with framebuffer from other context";
+  } else {
+    current_framebuffer_ = framebuffer;
+  }
 }
 
 void TestWebGraphicsContext3D::bindRenderbuffer(
       GLenum target, GLuint renderbuffer) {
   if (!renderbuffer)
     return;
-  DCHECK_EQ(kRenderbufferId | context_id_ << 16, renderbuffer);
+  base::AutoLock lock_for_renderbuffer_access(namespace_->lock);
+  if (renderbuffer != 0 &&
+      namespace_->renderbuffer_set.find(renderbuffer) ==
+          namespace_->renderbuffer_set.end()) {
+    ADD_FAILURE() << "bindRenderbuffer called with unknown renderbuffer";
+  } else if ((renderbuffer >> 16) != context_id_) {
+    ADD_FAILURE()
+        << "bindRenderbuffer called with renderbuffer from other context";
+  }
 }
 
 void TestWebGraphicsContext3D::bindTexture(
     GLenum target, GLuint texture_id) {
   if (times_bind_texture_succeeds_ >= 0) {
     if (!times_bind_texture_succeeds_) {
       loseContextCHROMIUM(GL_GUILTY_CONTEXT_RESET_ARB,
                           GL_INNOCENT_CONTEXT_RESET_ARB);
     }
     --times_bind_texture_succeeds_;
@@ skipping 46 matching lines @@
 
 void TestWebGraphicsContext3D::getIntegerv(
     GLenum pname,
     GLint* value) {
   if (pname == GL_MAX_TEXTURE_SIZE)
     *value = max_texture_size_;
   else if (pname == GL_ACTIVE_TEXTURE)
     *value = GL_TEXTURE0;
   else if (pname == GL_UNPACK_ALIGNMENT)
     *value = unpack_alignment_;
+  else if (pname == GL_FRAMEBUFFER_BINDING)
+    *value = current_framebuffer_;
 }
 
 void TestWebGraphicsContext3D::getProgramiv(GLuint program,
                                             GLenum pname,
                                             GLint* value) {
   if (pname == GL_LINK_STATUS)
     *value = 1;
 }
 
 void TestWebGraphicsContext3D::getShaderiv(GLuint shader,
@@ skipping 284 matching lines @@
 
 void TestWebGraphicsContext3D::RetireImageId(GLuint id) {
   base::AutoLock lock(namespace_->lock);
   unsigned context_id = id >> 16;
   unsigned image_id = id & 0xffff;
   DCHECK(image_id);
   DCHECK_LT(image_id, namespace_->next_image_id);
   DCHECK_EQ(context_id, context_id_);
 }
 
+GLuint TestWebGraphicsContext3D::NextFramebufferId() {
+  base::AutoLock lock_for_framebuffer_access(namespace_->lock);
+  GLuint id = next_framebuffer_id_++;
+  DCHECK(id < (1 << 16));
+  id |= context_id_ << 16;
+  framebuffer_set_.insert(id);
+  return id;
+}
+
+void TestWebGraphicsContext3D::RetireFramebufferId(GLuint id) {
+  base::AutoLock lock_for_framebuffer_access(namespace_->lock);
+  DCHECK(framebuffer_set_.find(id) != framebuffer_set_.end());
+  framebuffer_set_.erase(id);
+}
+
+GLuint TestWebGraphicsContext3D::NextRenderbufferId() {
+  base::AutoLock lock_for_renderbuffer_access(namespace_->lock);
+  GLuint id = namespace_->next_renderbuffer_id++;
+  DCHECK(id < (1 << 16));
+  id |= context_id_ << 16;
+  namespace_->renderbuffer_set.insert(id);
+  return id;
+}
+
+void TestWebGraphicsContext3D::RetireRenderbufferId(GLuint id) {
+  base::AutoLock lock_for_renderbuffer_access(namespace_->lock);
+  DCHECK(namespace_->renderbuffer_set.find(id) !=
+         namespace_->renderbuffer_set.end());
+  namespace_->renderbuffer_set.erase(id);
+}
+
 void TestWebGraphicsContext3D::SetMaxTransferBufferUsageBytes(
     size_t max_transfer_buffer_usage_bytes) {
   test_capabilities_.max_transfer_buffer_usage_bytes =
       max_transfer_buffer_usage_bytes;
 }
 
 TestWebGraphicsContext3D::TextureTargets::TextureTargets() {
   // Initialize default bindings.
   bound_textures_[GL_TEXTURE_2D] = 0;
   bound_textures_[GL_TEXTURE_EXTERNAL_OES] = 0;
@@ skipping 51 matching lines @@
 
 TestWebGraphicsContext3D::Buffer::Buffer() : target(0), size(0) {}
 
 TestWebGraphicsContext3D::Buffer::~Buffer() {}
 
 TestWebGraphicsContext3D::Image::Image() {}
 
 TestWebGraphicsContext3D::Image::~Image() {}
 
 }  // namespace cc