Have a common implementation of cc::OutputSurface

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"
@@ skipping 265 matching lines @@
 class ResourceProviderTest : public testing::TestWithParam<ResourceProvider::ResourceType> {
 public:
     ResourceProviderTest()
         : m_sharedData(ContextSharedData::create())
         , m_outputSurface(FakeOutputSurface::Create3d(ResourceProviderContext::create(m_sharedData.get()).PassAs<WebKit::WebGraphicsContext3D>().PassAs<WebKit::WebGraphicsContext3D>()))
         , m_resourceProvider(ResourceProvider::create(m_outputSurface.get()))
     {
         m_resourceProvider->setDefaultResourceType(GetParam());
     }
 
-    ResourceProviderContext* context() { return static_cast<ResourceProviderContext*>(m_outputSurface->Context3D()); }
+    ResourceProviderContext* context() { return static_cast<ResourceProviderContext*>(m_outputSurface->context3d()); }
 
     void getResourcePixels(ResourceProvider::ResourceId id, const gfx::Size& size, WGC3Denum format, uint8_t* pixels)
     {
         if (GetParam() == ResourceProvider::GLTexture) {
             ResourceProvider::ScopedReadLockGL lockGL(m_resourceProvider.get(), id);
             ASSERT_NE(0U, lockGL.textureId());
             context()->bindTexture(GL_TEXTURE_2D, lockGL.textureId());
             context()->getPixels(size, format, pixels);
         } else if (GetParam() == ResourceProvider::Bitmap) {
             ResourceProvider::ScopedReadLockSoftware lockSoftware(m_resourceProvider.get(), id);
@@ skipping 172 matching lines @@
         resourceIdsToTransfer.push_back(mappedId2);
         TransferableResourceList list;
         m_resourceProvider->prepareSendToChild(childId, resourceIdsToTransfer, &list);
         EXPECT_NE(0u, list.sync_point);
         EXPECT_EQ(2u, list.resources.size());
         childResourceProvider->receiveFromParent(list);
     }
     EXPECT_FALSE(childResourceProvider->inUseByConsumer(id1));
     EXPECT_FALSE(childResourceProvider->inUseByConsumer(id2));
 
-    ResourceProviderContext* childContext3D = static_cast<ResourceProviderContext*>(childOutputSurface->Context3D());
+    ResourceProviderContext* childContext3D = static_cast<ResourceProviderContext*>(childOutputSurface->context3d());
     {
         ResourceProvider::ScopedReadLockGL lock(childResourceProvider.get(), id1);
         ASSERT_NE(0U, lock.textureId());
         childContext3D->bindTexture(GL_TEXTURE_2D, lock.textureId());
         childContext3D->getPixels(size, format, result);
         EXPECT_EQ(0, memcmp(data1, result, pixelSize));
     }
     {
         ResourceProvider::ScopedReadLockGL lock(childResourceProvider.get(), id2);
         ASSERT_NE(0U, lock.textureId());
@@ skipping 83 matching lines @@
     virtual WebKit::WebGLId NextTextureId() { return 1; }
 };
 
 TEST_P(ResourceProviderTest, ScopedSampler)
 {
     // Sampling is only supported for GL textures.
     if (GetParam() != ResourceProvider::GLTexture)
         return;
 
     scoped_ptr<OutputSurface> outputSurface(FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(new TextureStateTrackingContext)));
-    TextureStateTrackingContext* context = static_cast<TextureStateTrackingContext*>(outputSurface->Context3D());
+    TextureStateTrackingContext* context = static_cast<TextureStateTrackingContext*>(outputSurface->context3d());
     scoped_ptr<ResourceProvider> resourceProvider(ResourceProvider::create(outputSurface.get()));
 
     gfx::Size size(1, 1);
     WGC3Denum format = GL_RGBA;
     int textureId = 1;
 
     // Check that the texture gets created with the right sampler settings.
     EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, textureId))
         .Times(2); // Once to create and once to allocate.
     EXPECT_CALL(*context, texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
@@ skipping 30 matching lines @@
     Mock::VerifyAndClearExpectations(context);
 }
 
 TEST_P(ResourceProviderTest, ManagedResource)
 {
     // Sampling is only supported for GL textures.
     if (GetParam() != ResourceProvider::GLTexture)
         return;
 
     scoped_ptr<OutputSurface> outputSurface(FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(new TextureStateTrackingContext)));
-    TextureStateTrackingContext* context = static_cast<TextureStateTrackingContext*>(outputSurface->Context3D());
+    TextureStateTrackingContext* context = static_cast<TextureStateTrackingContext*>(outputSurface->context3d());
     scoped_ptr<ResourceProvider> resourceProvider(ResourceProvider::create(outputSurface.get()));
 
     gfx::Size size(1, 1);
     WGC3Denum format = GL_RGBA;
     int textureId = 1;
 
     // Check that the texture gets created with the right sampler settings.
     EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, textureId));
     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));
@@ skipping 34 matching lines @@
     scoped_ptr<OutputSurface> outputSurface(FakeOutputSurface::Create3d(mock_context.Pass()));
 
     gfx::Size size(2, 2);
     gfx::Vector2d offset(0, 0);
     gfx::Rect rect(0, 0, 2, 2);
     WGC3Denum format = GL_RGBA;
     ResourceProvider::ResourceId id = 0;
     uint8_t pixels[16] = {0};
     int textureId = 123;
 
-    AllocationTrackingContext3D* context = static_cast<AllocationTrackingContext3D*>(outputSurface->Context3D());
+    AllocationTrackingContext3D* context = static_cast<AllocationTrackingContext3D*>(outputSurface->context3d());
     scoped_ptr<ResourceProvider> resourceProvider(ResourceProvider::create(outputSurface.get()));
 
     // Lazy allocation. Don't allocate when creating the resource.
     EXPECT_CALL(*context, createTexture()).WillOnce(Return(textureId));
     EXPECT_CALL(*context, deleteTexture(textureId)).Times(1);
     EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, textureId)).Times(1);
     EXPECT_CALL(*context, texImage2D(_,_,_,_,_,_,_,_,_)).Times(0);
     EXPECT_CALL(*context, asyncTexImage2DCHROMIUM(_,_,_,_,_,_,_,_,_)).Times(0);
     id = resourceProvider->createResource(size, format, ResourceProvider::TextureUsageAny);
     resourceProvider->deleteResource(id);
@@ skipping 36 matching lines @@
     Mock::VerifyAndClearExpectations(context);
 }
 
 INSTANTIATE_TEST_CASE_P(ResourceProviderTests,
                         ResourceProviderTest,
                         ::testing::Values(ResourceProvider::GLTexture,
                                           ResourceProvider::Bitmap));
 
 }  // namespace
 }  // namespace cc