Implement WebKit::WebUnitTestSupport::createLayerTreeViewForTesting()

cc/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/resource_provider.h"
 
 #include "base/logging.h"
 #include "cc/output_surface.h"
 #include "cc/scoped_ptr_deque.h"
 #include "cc/scoped_ptr_hash_map.h"
 #include "cc/test/fake_output_surface.h"
-#include "cc/test/fake_web_graphics_context_3d.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/Source/Platform/chromium/public/WebGraphicsContext3D.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
 #include "ui/gfx/rect.h"
 
 using namespace WebKit;
 
@@ skipping 71 matching lines @@
         , m_nextMailBox(1)
     { }
 
     unsigned m_nextSyncPoint;
     unsigned m_nextMailBox;
     typedef ScopedPtrHashMap<unsigned, Texture> TextureMap;
     TextureMap m_textures;
     base::hash_map<unsigned, unsigned> m_syncPointForMailbox;
 };
 
-class ResourceProviderContext : public FakeWebGraphicsContext3D {
+class ResourceProviderContext : public TestWebGraphicsContext3D {
 public:
     static scoped_ptr<ResourceProviderContext> create(ContextSharedData* sharedData) { return make_scoped_ptr(new ResourceProviderContext(Attributes(), sharedData)); }
 
     virtual unsigned insertSyncPoint()
     {
         unsigned syncPoint = m_sharedData->insertSyncPoint();
         // Commit the produceTextureCHROMIUM calls at this point, so that
         // they're associated with the sync point.
         for (PendingProduceTextureList::iterator it = m_pendingProduceTextures.begin(); it != m_pendingProduceTextures.end(); ++it)
             m_sharedData->produceTexture((*it)->mailbox, syncPoint, (*it)->texture.Pass());
         m_pendingProduceTextures.clear();
         return syncPoint;
     }
 
     virtual void waitSyncPoint(unsigned syncPoint)
     {
         m_lastWaitedSyncPoint = std::max(syncPoint, m_lastWaitedSyncPoint);
     }
 
     virtual void bindTexture(WGC3Denum target, WebGLId texture)
     {
       ASSERT_EQ(target, GL_TEXTURE_2D);
       ASSERT_TRUE(!texture || m_textures.find(texture) != m_textures.end());
       m_currentTexture = texture;
     }
 
     virtual WebGLId createTexture()
     {
-        WebGLId id = FakeWebGraphicsContext3D::createTexture();
+        WebGLId id = TestWebGraphicsContext3D::createTexture();
         m_textures.add(id, scoped_ptr<Texture>());
         return id;
     }
 
     virtual void deleteTexture(WebGLId id)
     {
         TextureMap::iterator it = m_textures.find(id);
         ASSERT_FALSE(it == m_textures.end());
         m_textures.erase(it);
         if (m_currentTexture == id)
@@ skipping 77 matching lines @@
         memcpy(pixels, texture->data.get(), textureSize(size, format));
     }
 
     int textureCount()
     {
         return m_textures.size();
     }
 
 protected:
     ResourceProviderContext(const Attributes& attrs, ContextSharedData* sharedData)
-        : FakeWebGraphicsContext3D(attrs)
+        : TestWebGraphicsContext3D(attrs)
         , m_sharedData(sharedData)
         , m_currentTexture(0)
         , m_lastWaitedSyncPoint(0)
     { }
 
 private:
     void allocateTexture(const gfx::Size& size, WGC3Denum format)
     {
         ASSERT_TRUE(m_currentTexture);
         m_textures.set(m_currentTexture, make_scoped_ptr(new Texture(size, format)));
@@ skipping 315 matching lines @@
         resourceIdsToTransfer.push_back(mappedId);
         TransferableResourceList list;
         m_resourceProvider->prepareSendToChild(childId, resourceIdsToTransfer, &list);
         EXPECT_NE(0u, list.sync_point);
         EXPECT_EQ(1u, list.resources.size());
         childResourceProvider->receiveFromParent(list);
     }
     EXPECT_EQ(0u, childResourceProvider->numResources());
 }
 
-class TextureStateTrackingContext : public FakeWebGraphicsContext3D {
+class TextureStateTrackingContext : public TestWebGraphicsContext3D {
 public:
     MOCK_METHOD2(bindTexture, void(WGC3Denum target, WebGLId texture));
     MOCK_METHOD3(texParameteri, void(WGC3Denum target, WGC3Denum pname, WGC3Dint param));
 
     // Force all textures to be "1" so we can test for them.
     virtual WebKit::WebGLId NextTextureId() { return 1; }
 };
 
 TEST_P(ResourceProviderTest, ScopedSampler)
 {
@@ skipping 65 matching lines @@
     EXPECT_CALL(*context, texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
     EXPECT_CALL(*context, texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
     EXPECT_CALL(*context, texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
     EXPECT_CALL(*context, texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
     EXPECT_CALL(*context, texParameteri(GL_TEXTURE_2D, GL_TEXTURE_POOL_CHROMIUM, GL_TEXTURE_POOL_MANAGED_CHROMIUM));
     ResourceProvider::ResourceId id = resourceProvider->createManagedResource(size, format, ResourceProvider::TextureUsageAny);
 
     Mock::VerifyAndClearExpectations(context);
 }
 
-class AllocationTrackingContext3D : public FakeWebGraphicsContext3D {
+class AllocationTrackingContext3D : public TestWebGraphicsContext3D {
 public:
     MOCK_METHOD0(createTexture, WebGLId());
     MOCK_METHOD1(deleteTexture, void(WebGLId texture_id));
     MOCK_METHOD2(bindTexture, void(WGC3Denum target, WebGLId texture));
     MOCK_METHOD9(texImage2D, void(WGC3Denum target, WGC3Dint level, WGC3Denum internalformat,
                                   WGC3Dsizei width, WGC3Dsizei height, WGC3Dint border, WGC3Denum format,
                                   WGC3Denum type, const void* pixels));
     MOCK_METHOD9(texSubImage2D, void(WGC3Denum target, WGC3Dint level, WGC3Dint xoffset, WGC3Dint yoffset,
                                      WGC3Dsizei width, WGC3Dsizei height, WGC3Denum format,
                                      WGC3Denum type, const void* pixels));
@@ skipping 72 matching lines @@
     Mock::VerifyAndClearExpectations(context);
 }
 
 INSTANTIATE_TEST_CASE_P(ResourceProviderTests,
                         ResourceProviderTest,
                         ::testing::Values(ResourceProvider::GLTexture,
                                           ResourceProvider::Bitmap));
 
 }  // namespace
 }  // namespace cc