Consolidate test contexts and remove unused ones

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"
 
 using WebKit::WGC3Dboolean;
 using WebKit::WGC3Dchar;
 using WebKit::WGC3Denum;
 using WebKit::WGC3Dint;
 using WebKit::WGC3Dsizei;
 using WebKit::WGC3Dsizeiptr;
 using WebKit::WGC3Duint;
 using WebKit::WebGLId;
 using WebKit::WebGraphicsContext3D;
 
 namespace cc {
 
 static const WebGLId kFramebufferId = 1;
-static const WebGLId kProgramId = 2;
-static const WebGLId kRenderbufferId = 3;
-static const WebGLId kShaderId = 4;
+static const WebGLId kRenderbufferId = 2;
 
 static unsigned s_context_id = 1;
 
 const WebGLId TestWebGraphicsContext3D::kExternalTextureId = 1337;
 
 static base::LazyInstance<base::Lock>::Leaky
     g_shared_namespace_lock = LAZY_INSTANCE_INITIALIZER;
 
 TestWebGraphicsContext3D::Namespace*
     TestWebGraphicsContext3D::shared_namespace_ = NULL;
@@ skipping 20 matching lines @@
       context_id_(s_context_id++),
       times_make_current_succeeds_(-1),
       times_bind_texture_succeeds_(-1),
       times_end_query_succeeds_(-1),
       times_gen_mailbox_succeeds_(-1),
       context_lost_(false),
       times_map_image_chromium_succeeds_(-1),
       times_map_buffer_chromium_succeeds_(-1),
       context_lost_callback_(NULL),
       swap_buffers_callback_(NULL),
+      next_program_id_(1000),
+      next_shader_id_(2000),
       max_texture_size_(2048),
+      reshape_called_(false),
       width_(0),
       height_(0),
+      scale_factor_(-1.f),
       test_support_(NULL),
+      last_update_type_(NoUpdate),
       bound_buffer_(0),
       weak_ptr_factory_(this) {
   CreateNamespace();
   test_capabilities_.swapbuffers_complete_callback = true;
 }
 
 TestWebGraphicsContext3D::~TestWebGraphicsContext3D() {
   base::AutoLock lock(g_shared_namespace_lock.Get());
   namespace_ = NULL;
 }
@@ skipping 18 matching lines @@
       loseContextCHROMIUM(GL_GUILTY_CONTEXT_RESET_ARB,
                           GL_INNOCENT_CONTEXT_RESET_ARB);
     }
     --times_make_current_succeeds_;
   }
   return !context_lost_;
 }
 
 void TestWebGraphicsContext3D::reshapeWithScaleFactor(
     int width, int height, float scale_factor) {
+  reshape_called_ = true;
   width_ = width;
   height_ = height;
+  scale_factor_ = scale_factor;
 }
 
 bool TestWebGraphicsContext3D::isContextLost() {
   return context_lost_;
 }
 
 WGC3Denum TestWebGraphicsContext3D::getGraphicsResetStatusARB() {
   return context_lost_ ? GL_UNKNOWN_CONTEXT_RESET_ARB : GL_NO_ERROR;
 }
 
@@ skipping 147 matching lines @@
 }
 
 void TestWebGraphicsContext3D::deleteRenderbuffer(WebGLId id) {
   deleteRenderbuffers(1, &id);
 }
 
 void TestWebGraphicsContext3D::deleteTexture(WebGLId id) {
   deleteTextures(1, &id);
 }
 
-WebGLId TestWebGraphicsContext3D::createProgram() {
-  return kProgramId | context_id_ << 16;
+unsigned TestWebGraphicsContext3D::createProgram() {
+  unsigned program = next_program_id_++ | context_id_ << 16;
+  program_set_.insert(program);
+  return program;
 }
 
 WebGLId TestWebGraphicsContext3D::createShader(WGC3Denum) {
-  return kShaderId | context_id_ << 16;
+  unsigned shader = next_shader_id_++ | context_id_ << 16;
+  shader_set_.insert(shader);
+  return shader;
 }
 
 WebGLId TestWebGraphicsContext3D::createExternalTexture() {
   base::AutoLock lock(namespace_->lock);
   namespace_->textures.Append(kExternalTextureId, new TestTexture());
   return kExternalTextureId;
 }
 
 void TestWebGraphicsContext3D::deleteProgram(WebGLId id) {
-  DCHECK_EQ(kProgramId | context_id_ << 16, id);
+  if (!program_set_.count(id))
+    ADD_FAILURE() << "deleteProgram called on unknown program " << id;
+  program_set_.erase(id);
 }
 
 void TestWebGraphicsContext3D::deleteShader(WebGLId id) {
-  DCHECK_EQ(kShaderId | context_id_ << 16, id);
+  if (!shader_set_.count(id))
+    ADD_FAILURE() << "deleteShader called on unknown shader " << id;
+  shader_set_.erase(id);
 }
 
 void TestWebGraphicsContext3D::attachShader(WebGLId program, WebGLId shader) {
-  DCHECK_EQ(kProgramId | context_id_ << 16, program);
-  DCHECK_EQ(kShaderId | context_id_ << 16, shader);
+  if (!program_set_.count(program))
+    ADD_FAILURE() << "attachShader called with unknown program " << program;
+  if (!shader_set_.count(shader))
+    ADD_FAILURE() << "attachShader called with unknown shader " << shader;
 }
 
 void TestWebGraphicsContext3D::useProgram(WebGLId program) {
   if (!program)
     return;
-  DCHECK_EQ(kProgramId | context_id_ << 16, program);
+  if (!program_set_.count(program))
+    ADD_FAILURE() << "useProgram called on unknown program " << program;
 }
 
 void TestWebGraphicsContext3D::bindFramebuffer(
     WGC3Denum target, WebGLId framebuffer) {
   if (!framebuffer)
     return;
   DCHECK_EQ(kFramebufferId | context_id_ << 16, framebuffer);
 }
 
 void TestWebGraphicsContext3D::bindRenderbuffer(
@@ skipping 96 matching lines @@
   shared_contexts_.clear();
 }
 
 void TestWebGraphicsContext3D::setSwapBuffersCompleteCallbackCHROMIUM(
     WebGraphicsSwapBuffersCompleteCallbackCHROMIUM* callback) {
   if (test_capabilities_.swapbuffers_complete_callback)
     swap_buffers_callback_ = callback;
 }
 
 void TestWebGraphicsContext3D::prepareTexture() {
+  update_rect_ = gfx::Rect(width_, height_);
+  last_update_type_ = PrepareTexture;
+
   // TODO(jamesr): This should implemented as ContextSupport::SwapBuffers().
   if (swap_buffers_callback_) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(&TestWebGraphicsContext3D::SwapBuffersComplete,
                               weak_ptr_factory_.GetWeakPtr()));
   }
   test_support_->CallAllSyncPointCallbacks();
 }
 
+void TestWebGraphicsContext3D::postSubBufferCHROMIUM(
+    int x, int y, int width, int height) {
+  update_rect_ = gfx::Rect(x, y, width, height);
+  last_update_type_ = PostSubBuffer;
+}
+
 void TestWebGraphicsContext3D::finish() {
   test_support_->CallAllSyncPointCallbacks();
 }
 
 void TestWebGraphicsContext3D::flush() {
   test_support_->CallAllSyncPointCallbacks();
 }
 
 void TestWebGraphicsContext3D::SwapBuffersComplete() {
   if (swap_buffers_callback_)
@@ skipping 226 matching lines @@
 
 TestWebGraphicsContext3D::Buffer::Buffer() : target(0), size(0) {}
 
 TestWebGraphicsContext3D::Buffer::~Buffer() {}
 
 TestWebGraphicsContext3D::Image::Image() {}
 
 TestWebGraphicsContext3D::Image::~Image() {}
 
 }  // namespace cc