Convert cc resource system over to GLES2Interface

cc/resources/resource_provider_unittest.cc

 // Copyright 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 "cc/resources/resource_provider.h"
 
 #include <algorithm>
 #include <map>
 
 #include "base/bind.h"
 #include "base/containers/hash_tables.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "cc/base/scoped_ptr_deque.h"
 #include "cc/output/output_surface.h"
 #include "cc/resources/returned_resource.h"
 #include "cc/resources/shared_bitmap_manager.h"
 #include "cc/resources/single_release_callback.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/fake_output_surface_client.h"
 #include "cc/test/test_texture.h"
 #include "cc/test/test_web_graphics_context_3d.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include "third_party/WebKit/public/platform/WebGraphicsContext3D.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
 #include "ui/gfx/rect.h"
 
 using testing::Mock;
 using testing::NiceMock;
 using testing::Return;
 using testing::SetArgPointee;
 using testing::StrictMock;
 using testing::_;
-using blink::WGC3Dbyte;
-using blink::WGC3Denum;
-using blink::WGC3Dint;
-using blink::WGC3Dsizei;
-using blink::WGC3Duint;
-using blink::WebGLId;
 
 namespace cc {
 namespace {
 
 static void EmptyReleaseCallback(unsigned sync_point, bool lost_resource) {}
 
 static void SharedMemoryReleaseCallback(scoped_ptr<base::SharedMemory> memory,
                                         unsigned sync_point,
                                         bool lost_resource) {}
 
@@ skipping 23 matching lines @@
   scoped_ptr<base::SharedMemory> shared_memory(new base::SharedMemory);
   CHECK(shared_memory->CreateAndMapAnonymous(4 * size.GetArea()));
   uint32_t* pixels = reinterpret_cast<uint32_t*>(shared_memory->memory());
   CHECK(pixels);
   std::fill_n(pixels, size.GetArea(), value);
   return shared_memory.Pass();
 }
 
 class TextureStateTrackingContext : public TestWebGraphicsContext3D {
  public:
-  MOCK_METHOD2(bindTexture, void(WGC3Denum target, WebGLId texture));
-  MOCK_METHOD3(texParameteri,
-               void(WGC3Denum target, WGC3Denum pname, WGC3Dint param));
+  MOCK_METHOD2(bindTexture, void(GLenum target, GLuint texture));
+  MOCK_METHOD3(texParameteri, void(GLenum target, GLenum pname, GLint param));
   MOCK_METHOD1(waitSyncPoint, void(unsigned sync_point));
   MOCK_METHOD0(insertSyncPoint, unsigned(void));
-  MOCK_METHOD2(produceTextureCHROMIUM, void(WGC3Denum target,
-                                            const WGC3Dbyte* mailbox));
-  MOCK_METHOD2(consumeTextureCHROMIUM, void(WGC3Denum target,
-                                            const WGC3Dbyte* mailbox));
+  MOCK_METHOD2(produceTextureCHROMIUM,
+               void(GLenum target, const GLbyte* mailbox));
+  MOCK_METHOD2(consumeTextureCHROMIUM,
+               void(GLenum target, const GLbyte* mailbox));
 
   // Force all textures to be consecutive numbers starting at "1",
   // so we easily can test for them.
-  virtual blink::WebGLId NextTextureId() OVERRIDE {
+  virtual GLuint NextTextureId() OVERRIDE {
     base::AutoLock lock(namespace_->lock);
     return namespace_->next_texture_id++;
   }
-  virtual void RetireTextureId(blink::WebGLId) OVERRIDE {
-  }
+  virtual void RetireTextureId(GLuint) OVERRIDE {}
 };
 
 // Shared data between multiple ResourceProviderContext. This contains mailbox
 // contents as well as information about sync points.
 class ContextSharedData {
  public:
   static scoped_ptr<ContextSharedData> Create() {
     return make_scoped_ptr(new ContextSharedData());
   }
 
   unsigned InsertSyncPoint() { return next_sync_point_++; }
 
-  void GenMailbox(WGC3Dbyte* mailbox) {
-    memset(mailbox, 0, sizeof(WGC3Dbyte[64]));
+  void GenMailbox(GLbyte* mailbox) {
+    memset(mailbox, 0, sizeof(GLbyte[64]));
     memcpy(mailbox, &next_mailbox_, sizeof(next_mailbox_));
     ++next_mailbox_;
   }
 
-  void ProduceTexture(const WGC3Dbyte* mailbox_name,
+  void ProduceTexture(const GLbyte* mailbox_name,
                       unsigned sync_point,
                       scoped_refptr<TestTexture> texture) {
     unsigned mailbox = 0;
     memcpy(&mailbox, mailbox_name, sizeof(mailbox));
     ASSERT_TRUE(mailbox && mailbox < next_mailbox_);
     textures_[mailbox] = texture;
     ASSERT_LT(sync_point_for_mailbox_[mailbox], sync_point);
     sync_point_for_mailbox_[mailbox] = sync_point;
   }
 
-  scoped_refptr<TestTexture> ConsumeTexture(const WGC3Dbyte* mailbox_name,
+  scoped_refptr<TestTexture> ConsumeTexture(const GLbyte* mailbox_name,
                                             unsigned sync_point) {
     unsigned mailbox = 0;
     memcpy(&mailbox, mailbox_name, sizeof(mailbox));
     DCHECK(mailbox && mailbox < next_mailbox_);
 
     // If the latest sync point the context has waited on is before the sync
     // point for when the mailbox was set, pretend we never saw that
     // ProduceTexture.
     if (sync_point_for_mailbox_[mailbox] > sync_point) {
       NOTREACHED();
@@ skipping 31 matching lines @@
           (*it)->mailbox, sync_point, (*it)->texture);
     }
     pending_produce_textures_.clear();
     return sync_point;
   }
 
   virtual void waitSyncPoint(unsigned sync_point) OVERRIDE {
     last_waited_sync_point_ = std::max(sync_point, last_waited_sync_point_);
   }
 
-  virtual void texStorage2DEXT(WGC3Denum target,
-                               WGC3Dint levels,
-                               WGC3Duint internalformat,
-                               WGC3Dint width,
-                               WGC3Dint height) OVERRIDE {
+  virtual void texStorage2DEXT(GLenum target,
+                               GLint levels,
+                               GLuint internalformat,
+                               GLint width,
+                               GLint height) OVERRIDE {
     CheckTextureIsBound(target);
     ASSERT_EQ(static_cast<unsigned>(GL_TEXTURE_2D), target);
     ASSERT_EQ(1, levels);
-    WGC3Denum format = GL_RGBA;
+    GLenum format = GL_RGBA;
     switch (internalformat) {
       case GL_RGBA8_OES:
         break;
       case GL_BGRA8_EXT:
         format = GL_BGRA_EXT;
         break;
       default:
         NOTREACHED();
     }
     AllocateTexture(gfx::Size(width, height), format);
   }
 
-  virtual void texImage2D(WGC3Denum target,
-                          WGC3Dint level,
-                          WGC3Denum internalformat,
-                          WGC3Dsizei width,
-                          WGC3Dsizei height,
-                          WGC3Dint border,
-                          WGC3Denum format,
-                          WGC3Denum type,
+  virtual void texImage2D(GLenum target,
+                          GLint level,
+                          GLenum internalformat,
+                          GLsizei width,
+                          GLsizei height,
+                          GLint border,
+                          GLenum format,
+                          GLenum type,
                           const void* pixels) OVERRIDE {
     CheckTextureIsBound(target);
     ASSERT_EQ(static_cast<unsigned>(GL_TEXTURE_2D), target);
     ASSERT_FALSE(level);
     ASSERT_EQ(internalformat, format);
     ASSERT_FALSE(border);
     ASSERT_EQ(static_cast<unsigned>(GL_UNSIGNED_BYTE), type);
     AllocateTexture(gfx::Size(width, height), format);
     if (pixels)
       SetPixels(0, 0, width, height, pixels);
   }
 
-  virtual void texSubImage2D(WGC3Denum target,
-                             WGC3Dint level,
-                             WGC3Dint xoffset,
-                             WGC3Dint yoffset,
-                             WGC3Dsizei width,
-                             WGC3Dsizei height,
-                             WGC3Denum format,
-                             WGC3Denum type,
+  virtual void texSubImage2D(GLenum target,
+                             GLint level,
+                             GLint xoffset,
+                             GLint yoffset,
+                             GLsizei width,
+                             GLsizei height,
+                             GLenum format,
+                             GLenum type,
                              const void* pixels) OVERRIDE {
     CheckTextureIsBound(target);
     ASSERT_EQ(static_cast<unsigned>(GL_TEXTURE_2D), target);
     ASSERT_FALSE(level);
     ASSERT_EQ(static_cast<unsigned>(GL_UNSIGNED_BYTE), type);
     {
       base::AutoLock lock_for_texture_access(namespace_->lock);
       ASSERT_EQ(GLDataFormat(BoundTexture(target)->format), format);
     }
     ASSERT_TRUE(pixels);
     SetPixels(xoffset, yoffset, width, height, pixels);
   }
 
-  virtual void genMailboxCHROMIUM(WGC3Dbyte* mailbox) OVERRIDE {
+  virtual void genMailboxCHROMIUM(GLbyte* mailbox) OVERRIDE {
     return shared_data_->GenMailbox(mailbox);
   }
 
-  virtual void produceTextureCHROMIUM(WGC3Denum target,
-                                      const WGC3Dbyte* mailbox) OVERRIDE {
+  virtual void produceTextureCHROMIUM(GLenum target,
+                                      const GLbyte* mailbox) OVERRIDE {
     CheckTextureIsBound(target);
 
     // Delay moving the texture into the mailbox until the next
     // InsertSyncPoint, so that it is not visible to other contexts that
     // haven't waited on that sync point.
     scoped_ptr<PendingProduceTexture> pending(new PendingProduceTexture);
     memcpy(pending->mailbox, mailbox, sizeof(pending->mailbox));
     base::AutoLock lock_for_texture_access(namespace_->lock);
     pending->texture = BoundTexture(target);
     pending_produce_textures_.push_back(pending.Pass());
   }
 
-  virtual void consumeTextureCHROMIUM(WGC3Denum target,
-                                      const WGC3Dbyte* mailbox) OVERRIDE {
+  virtual void consumeTextureCHROMIUM(GLenum target,
+                                      const GLbyte* mailbox) OVERRIDE {
     CheckTextureIsBound(target);
     base::AutoLock lock_for_texture_access(namespace_->lock);
     scoped_refptr<TestTexture> texture =
         shared_data_->ConsumeTexture(mailbox, last_waited_sync_point_);
     namespace_->textures.Replace(BoundTextureId(target), texture);
   }
 
   void GetPixels(gfx::Size size, ResourceFormat format, uint8_t* pixels) {
     CheckTextureIsBound(GL_TEXTURE_2D);
     base::AutoLock lock_for_texture_access(namespace_->lock);
     scoped_refptr<TestTexture> texture = BoundTexture(GL_TEXTURE_2D);
     ASSERT_EQ(texture->size, size);
     ASSERT_EQ(texture->format, format);
     memcpy(pixels, texture->data.get(), TextureSizeBytes(size, format));
   }
 
  protected:
   explicit ResourceProviderContext(ContextSharedData* shared_data)
       : shared_data_(shared_data),
         last_waited_sync_point_(0) {}
 
  private:
-  void AllocateTexture(gfx::Size size, WGC3Denum format) {
+  void AllocateTexture(gfx::Size size, GLenum format) {
     CheckTextureIsBound(GL_TEXTURE_2D);
     ResourceFormat texture_format = RGBA_8888;
     switch (format) {
       case GL_RGBA:
         texture_format = RGBA_8888;
         break;
       case GL_BGRA_EXT:
         texture_format = BGRA_8888;
         break;
     }
@@ skipping 20 matching lines @@
                     TextureSizeBytes(gfx::Size(xoffset, 1), texture->format);
     const uint8_t* src = static_cast<const uint8_t*>(pixels);
     for (int i = 0; i < height; ++i) {
       memcpy(dest, src, in_pitch);
       dest += out_pitch;
       src += in_pitch;
     }
   }
 
   struct PendingProduceTexture {
-    WGC3Dbyte mailbox[64];
+    GLbyte mailbox[64];
     scoped_refptr<TestTexture> texture;
   };
   typedef ScopedPtrDeque<PendingProduceTexture> PendingProduceTextureList;
   ContextSharedData* shared_data_;
   unsigned last_waited_sync_point_;
   PendingProduceTextureList pending_produce_textures_;
 };
 
 void FreeSharedBitmap(SharedBitmap* shared_bitmap) {
   delete shared_bitmap->memory();
@@ skipping 127 matching lines @@
                                const ReturnedResourceArray& returned) {
     array->insert(array->end(), returned.begin(), returned.end());
   }
 
   static ReturnCallback GetReturnCallback(ReturnedResourceArray* array) {
     return base::Bind(&ResourceProviderTest::CollectResources, array);
   }
 
   static void SetResourceFilter(ResourceProvider* resource_provider,
                                 ResourceProvider::ResourceId id,
-                                WGC3Denum filter) {
+                                GLenum filter) {
     ResourceProvider::ScopedSamplerGL sampler(
         resource_provider, id, GL_TEXTURE_2D, filter);
   }
 
   ResourceProviderContext* context() { return context3d_; }
 
   ResourceProvider::ResourceId CreateChildMailbox(unsigned* release_sync_point,
                                                   bool* lost_resource,
                                                   bool* release_called,
                                                   unsigned* sync_point) {
@@ skipping 160 matching lines @@
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, format);
   uint8_t data1[4] = { 1, 2, 3, 4 };
   gfx::Rect rect(size);
   child_resource_provider_->SetPixels(id1, data1, rect, rect, gfx::Vector2d());
 
   ResourceProvider::ResourceId id2 = child_resource_provider_->CreateResource(
       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureUsageAny, format);
   uint8_t data2[4] = { 5, 5, 5, 5 };
   child_resource_provider_->SetPixels(id2, data2, rect, rect, gfx::Vector2d());
 
-  WebGLId external_texture_id = child_context_->createExternalTexture();
+  GLuint external_texture_id = child_context_->createExternalTexture();
   child_context_->bindTexture(GL_TEXTURE_EXTERNAL_OES, external_texture_id);
 
   gpu::Mailbox external_mailbox;
   child_context_->genMailboxCHROMIUM(external_mailbox.name);
   child_context_->produceTextureCHROMIUM(GL_TEXTURE_EXTERNAL_OES,
                                          external_mailbox.name);
   const unsigned external_sync_point = child_context_->insertSyncPoint();
   ResourceProvider::ResourceId id3 =
       child_resource_provider_->CreateResourceFromTextureMailbox(
           TextureMailbox(
@@ skipping 1700 matching lines @@
     EXPECT_CALL(*context, insertSyncPoint());
     EXPECT_CALL(*context, produceTextureCHROMIUM(_, _)).Times(0);
 
     EXPECT_CALL(*context, waitSyncPoint(_)).Times(0);
     EXPECT_CALL(*context, consumeTextureCHROMIUM(_, _)).Times(0);
   }
 }
 
 class AllocationTrackingContext3D : public TestWebGraphicsContext3D {
  public:
-  MOCK_METHOD0(NextTextureId, WebGLId());
-  MOCK_METHOD1(RetireTextureId, void(WebGLId id));
-  MOCK_METHOD2(bindTexture, void(WGC3Denum target, WebGLId texture));
+  MOCK_METHOD0(NextTextureId, GLuint());
+  MOCK_METHOD1(RetireTextureId, void(GLuint id));
+  MOCK_METHOD2(bindTexture, void(GLenum target, GLuint texture));
   MOCK_METHOD5(texStorage2DEXT,
-               void(WGC3Denum target,
-                    WGC3Dint levels,
-                    WGC3Duint internalformat,
-                    WGC3Dint width,
-                    WGC3Dint height));
+               void(GLenum target,
+                    GLint levels,
+                    GLuint internalformat,
+                    GLint width,
+                    GLint height));
   MOCK_METHOD9(texImage2D,
-               void(WGC3Denum target,
-                    WGC3Dint level,
-                    WGC3Denum internalformat,
-                    WGC3Dsizei width,
-                    WGC3Dsizei height,
-                    WGC3Dint border,
-                    WGC3Denum format,
-                    WGC3Denum type,
+               void(GLenum target,
+                    GLint level,
+                    GLenum internalformat,
+                    GLsizei width,
+                    GLsizei height,
+                    GLint border,
+                    GLenum format,
+                    GLenum type,
                     const void* pixels));
   MOCK_METHOD9(texSubImage2D,
-               void(WGC3Denum target,
-                    WGC3Dint level,
-                    WGC3Dint xoffset,
-                    WGC3Dint yoffset,
-                    WGC3Dsizei width,
-                    WGC3Dsizei height,
-                    WGC3Denum format,
-                    WGC3Denum type,
+               void(GLenum target,
+                    GLint level,
+                    GLint xoffset,
+                    GLint yoffset,
+                    GLsizei width,
+                    GLsizei height,
+                    GLenum format,
+                    GLenum type,
                     const void* pixels));
   MOCK_METHOD9(asyncTexImage2DCHROMIUM,
-               void(WGC3Denum target,
-                    WGC3Dint level,
-                    WGC3Denum internalformat,
-                    WGC3Dsizei width,
-                    WGC3Dsizei height,
-                    WGC3Dint border,
-                    WGC3Denum format,
-                    WGC3Denum type,
+               void(GLenum target,
+                    GLint level,
+                    GLenum internalformat,
+                    GLsizei width,
+                    GLsizei height,
+                    GLint border,
+                    GLenum format,
+                    GLenum type,
                     const void* pixels));
   MOCK_METHOD9(asyncTexSubImage2DCHROMIUM,
-               void(WGC3Denum target,
-                    WGC3Dint level,
-                    WGC3Dint xoffset,
-                    WGC3Dint yoffset,
-                    WGC3Dsizei width,
-                    WGC3Dsizei height,
-                    WGC3Denum format,
-                    WGC3Denum type,
+               void(GLenum target,
+                    GLint level,
+                    GLint xoffset,
+                    GLint yoffset,
+                    GLsizei width,
+                    GLsizei height,
+                    GLenum format,
+                    GLenum type,
                     const void* pixels));
   MOCK_METHOD8(compressedTexImage2D,
-               void(WGC3Denum target,
-                    WGC3Dint level,
-                    WGC3Denum internalformat,
-                    WGC3Dsizei width,
-                    WGC3Dsizei height,
-                    WGC3Dint border,
-                    WGC3Dsizei image_size,
+               void(GLenum target,
+                    GLint level,
+                    GLenum internalformat,
+                    GLsizei width,
+                    GLsizei height,
+                    GLint border,
+                    GLsizei image_size,
                     const void* data));
-  MOCK_METHOD1(waitAsyncTexImage2DCHROMIUM, void(WGC3Denum));
-  MOCK_METHOD3(createImageCHROMIUM, WGC3Duint(WGC3Dsizei, WGC3Dsizei,
-                                              WGC3Denum));
-  MOCK_METHOD1(destroyImageCHROMIUM, void(WGC3Duint));
-  MOCK_METHOD2(mapImageCHROMIUM, void*(WGC3Duint, WGC3Denum));
-  MOCK_METHOD3(getImageParameterivCHROMIUM, void(WGC3Duint, WGC3Denum,
-                                                 GLint*));
-  MOCK_METHOD1(unmapImageCHROMIUM, void(WGC3Duint));
-  MOCK_METHOD2(bindTexImage2DCHROMIUM, void(WGC3Denum, WGC3Dint));
-  MOCK_METHOD2(releaseTexImage2DCHROMIUM, void(WGC3Denum, WGC3Dint));
+  MOCK_METHOD1(waitAsyncTexImage2DCHROMIUM, void(GLenum));
+  MOCK_METHOD3(createImageCHROMIUM, GLuint(GLsizei, GLsizei, GLenum));
+  MOCK_METHOD1(destroyImageCHROMIUM, void(GLuint));
+  MOCK_METHOD2(mapImageCHROMIUM, void*(GLuint, GLenum));
+  MOCK_METHOD3(getImageParameterivCHROMIUM, void(GLuint, GLenum, GLint*));
+  MOCK_METHOD1(unmapImageCHROMIUM, void(GLuint));
+  MOCK_METHOD2(bindTexImage2DCHROMIUM, void(GLenum, GLint));
+  MOCK_METHOD2(releaseTexImage2DCHROMIUM, void(GLenum, GLint));
 
   // We're mocking bindTexture, so we override
   // TestWebGraphicsContext3D::texParameteri to avoid assertions related to the
   // currently bound texture.
-  virtual void texParameteri(blink::WGC3Denum target,
-                             blink::WGC3Denum pname,
-                             blink::WGC3Dint param) {}
+  virtual void texParameteri(GLenum target, GLenum pname, GLint param) {}
 };
 
 TEST_P(ResourceProviderTest, TextureAllocation) {
   // Only for GL textures.
   if (GetParam() != ResourceProvider::GLTexture)
     return;
   scoped_ptr<AllocationTrackingContext3D> context_owned(
       new StrictMock<AllocationTrackingContext3D>);
   AllocationTrackingContext3D* context = context_owned.get();
 
@@ skipping 551 matching lines @@
   resource_provider->DeleteResource(id);
 }
 
 INSTANTIATE_TEST_CASE_P(
     ResourceProviderTests,
     ResourceProviderTest,
     ::testing::Values(ResourceProvider::GLTexture, ResourceProvider::Bitmap));
 
 class TextureIdAllocationTrackingContext : public TestWebGraphicsContext3D {
  public:
-  virtual blink::WebGLId NextTextureId() OVERRIDE {
+  virtual GLuint NextTextureId() OVERRIDE {
     base::AutoLock lock(namespace_->lock);
     return namespace_->next_texture_id++;
   }
-  virtual void RetireTextureId(blink::WebGLId) OVERRIDE {
-  }
-  blink::WebGLId PeekTextureId() {
+  virtual void RetireTextureId(GLuint) OVERRIDE {}
+  GLuint PeekTextureId() {
     base::AutoLock lock(namespace_->lock);
     return namespace_->next_texture_id;
   }
 };
 
 TEST(ResourceProviderTest, TextureAllocationChunkSize) {
   scoped_ptr<TextureIdAllocationTrackingContext> context_owned(
       new TextureIdAllocationTrackingContext);
   TextureIdAllocationTrackingContext* context = context_owned.get();
 
@@ skipping 37 matching lines @@
     resource_provider->AllocateForTesting(id);
     Mock::VerifyAndClearExpectations(context);
 
     DCHECK_EQ(10u, context->PeekTextureId());
     resource_provider->DeleteResource(id);
   }
 }
 
 }  // namespace
 }  // namespace cc