Patch from https://codereview.chromium.org/11111005/ without actual file deletes

cc/layer_tree_host_impl_unittest.cc

 // Copyright 2011 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 "config.h"
 
 #include "CCLayerTreeHostImpl.h"
 
 #include "CCAnimationTestCommon.h"
 #include "CCDelegatedRendererLayerImpl.h"
@@ skipping 932 matching lines @@
 
 private:
     explicit MissingTextureAnimatingLayer(int id, bool tileMissing, bool skipsDraw, bool animating, CCResourceProvider* resourceProvider)
         : DidDrawCheckLayer(id)
     {
         OwnPtr<CCLayerTilingData> tilingData = CCLayerTilingData::create(IntSize(10, 10), CCLayerTilingData::NoBorderTexels);
         tilingData->setBounds(bounds());
         setTilingData(*tilingData.get());
         setSkipsDraw(skipsDraw);
         if (!tileMissing) {
-            CCResourceProvider::ResourceId resource = resourceProvider->createResource(CCRenderer::ContentPool, IntSize(), GraphicsContext3D::RGBA, CCResourceProvider::TextureUsageAny);
+            CCResourceProvider::ResourceId resource = resourceProvider->createResource(CCRenderer::ContentPool, IntSize(), GL_RGBA, CCResourceProvider::TextureUsageAny);
             pushTileProperties(0, 0, resource, IntRect());
         }
         if (animating)
             addAnimatedTransformToLayer(*this, 10, 3, 0);
     }
 };
 
 TEST_P(CCLayerTreeHostImplTest, prepareToDrawFailsWhenAnimationUsesCheckerboard)
 {
     // When the texture is not missing, we draw as usual.
@@ skipping 524 matching lines @@
     scrollInfo = m_hostImpl->processScrollDeltas();
     expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), wheelScrollDelta);
 }
 
 class BlendStateTrackerContext: public FakeWebGraphicsContext3D {
 public:
     BlendStateTrackerContext() : m_blend(false) { }
 
     virtual void enable(WGC3Denum cap)
     {
-        if (cap == GraphicsContext3D::BLEND)
+        if (cap == GL_BLEND)
             m_blend = true;
     }
 
     virtual void disable(WGC3Denum cap)
     {
-        if (cap == GraphicsContext3D::BLEND)
+        if (cap == GL_BLEND)
             m_blend = false;
     }
 
     bool blend() const { return m_blend; }
 
 private:
     bool m_blend;
 };
 
 class BlendStateCheckLayer : public CCLayerImpl {
@@ skipping 32 matching lines @@
     void setOpaqueContentRect(const IntRect& rect) { m_opaqueContentRect = rect; }
 
 private:
     explicit BlendStateCheckLayer(int id, CCResourceProvider* resourceProvider)
         : CCLayerImpl(id)
         , m_blend(false)
         , m_hasRenderSurface(false)
         , m_quadsAppended(false)
         , m_quadRect(5, 5, 5, 5)
         , m_quadVisibleRect(5, 5, 5, 5)
-        , m_resourceId(resourceProvider->createResource(CCRenderer::ContentPool, IntSize(1, 1), GraphicsContext3D::RGBA, CCResourceProvider::TextureUsageAny))
+        , m_resourceId(resourceProvider->createResource(CCRenderer::ContentPool, IntSize(1, 1), GL_RGBA, CCResourceProvider::TextureUsageAny))
     {
         setAnchorPoint(FloatPoint(0, 0));
         setBounds(IntSize(10, 10));
         setContentBounds(IntSize(10, 10));
         setDrawsContent(true);
     }
 
     bool m_blend;
     bool m_hasRenderSurface;
     bool m_quadsAppended;
@@ skipping 328 matching lines @@
 
 class PartialSwapTrackerContext : public FakeWebGraphicsContext3D {
 public:
     virtual void postSubBufferCHROMIUM(int x, int y, int width, int height)
     {
         m_partialSwapRect = IntRect(x, y, width, height);
     }
 
     virtual WebString getString(WGC3Denum name)
     {
-        if (name == GraphicsContext3D::EXTENSIONS)
+        if (name == GL_EXTENSIONS)
             return WebString("GL_CHROMIUM_post_sub_buffer GL_CHROMIUM_set_visibility");
 
         return WebString();
     }
 
     IntRect partialSwapRect() const { return m_partialSwapRect; }
 
 private:
     IntRect m_partialSwapRect;
 };
@@ skipping 156 matching lines @@
             .WillRepeatedly(Return());
 
         EXPECT_CALL(*m_context, uniform4f(_, _, _, _, _))
             .WillRepeatedly(Return());
 
         // Any other strings are empty
         EXPECT_CALL(*m_context, getString(_))
             .WillRepeatedly(Return(WebString()));
 
         // Support for partial swap, if needed
-        EXPECT_CALL(*m_context, getString(GraphicsContext3D::EXTENSIONS))
+        EXPECT_CALL(*m_context, getString(GL_EXTENSIONS))
             .WillRepeatedly(Return(WebString("GL_CHROMIUM_post_sub_buffer")));
 
         EXPECT_CALL(*m_context, getRequestableExtensionsCHROMIUM())
             .WillRepeatedly(Return(WebString("GL_CHROMIUM_post_sub_buffer")));
 
         // Any un-sanctioned calls to enable() are OK
         EXPECT_CALL(*m_context, enable(_))
             .WillRepeatedly(Return());
 
         // Any un-sanctioned calls to disable() are OK
         EXPECT_CALL(*m_context, disable(_))
             .WillRepeatedly(Return());
     }
 
     void mustDrawSolidQuad()
     {
-        EXPECT_CALL(*m_context, drawElements(GraphicsContext3D::TRIANGLES, 6, GraphicsContext3D::UNSIGNED_SHORT, 0))
+        EXPECT_CALL(*m_context, drawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0))
             .WillOnce(Return())
             .RetiresOnSaturation();
 
         // 1 is hardcoded return value of fake createProgram()
         EXPECT_CALL(*m_context, useProgram(1))
             .WillOnce(Return())
             .RetiresOnSaturation();
 
     }
 
     void mustSetScissor(int x, int y, int width, int height)
     {
-        EXPECT_CALL(*m_context, enable(GraphicsContext3D::SCISSOR_TEST))
+        EXPECT_CALL(*m_context, enable(GL_SCISSOR_TEST))
             .WillRepeatedly(Return());
 
         EXPECT_CALL(*m_context, scissor(x, y, width, height))
             .Times(AtLeast(1))
             .WillRepeatedly(Return());
     }
 
     void mustSetNoScissor()
     {
-        EXPECT_CALL(*m_context, disable(GraphicsContext3D::SCISSOR_TEST))
+        EXPECT_CALL(*m_context, disable(GL_SCISSOR_TEST))
             .WillRepeatedly(Return());
 
-        EXPECT_CALL(*m_context, enable(GraphicsContext3D::SCISSOR_TEST))
+        EXPECT_CALL(*m_context, enable(GL_SCISSOR_TEST))
             .Times(0);
 
         EXPECT_CALL(*m_context, scissor(_, _, _, _))
             .Times(0);
     }
 };
 
 TEST_P(CCLayerTreeHostImplTest, noPartialSwap)
 {
     scoped_ptr<CCGraphicsContext> context = FakeWebCompositorOutputSurface::create(adoptPtr(new MockContext)).PassAs<CCGraphicsContext>();
@@ skipping 44 matching lines @@
         myHostImpl->drawLayers(frame);
         myHostImpl->didDrawAllLayers(frame);
     }
     Mock::VerifyAndClearExpectations(&mockContext);
 }
 
 class PartialSwapContext : public FakeWebGraphicsContext3D {
 public:
     WebString getString(WGC3Denum name)
     {
-        if (name == GraphicsContext3D::EXTENSIONS)
+        if (name == GL_EXTENSIONS)
             return WebString("GL_CHROMIUM_post_sub_buffer");
         return WebString();
     }
 
     WebString getRequestableExtensionsCHROMIUM()
     {
         return WebString("GL_CHROMIUM_post_sub_buffer");
     }
 
     // Unlimited texture size.
     virtual void getIntegerv(WGC3Denum pname, WGC3Dint* value)
     {
-        if (pname == cc::GraphicsContext3D::MAX_TEXTURE_SIZE)
+        if (pname == GL_MAX_TEXTURE_SIZE)
             *value = 8192;
     }
 };
 
 static scoped_ptr<CCLayerTreeHostImpl> setupLayersForOpacity(bool partialSwap, CCLayerTreeHostImplClient* client)
 {
     CCSettings::setPartialSwapEnabled(partialSwap);
 
     scoped_ptr<CCGraphicsContext> context = FakeWebCompositorOutputSurface::create(adoptPtr(new PartialSwapContext)).PassAs<CCGraphicsContext>();
 
@@ skipping 307 matching lines @@
 public:
     FakeVideoFrame() : m_textureId(0) { memset(m_data, 0x80, sizeof(m_data)); }
     virtual ~FakeVideoFrame() { }
     virtual Format format() const { return m_textureId ? FormatNativeTexture : FormatYV12; }
     virtual unsigned width() const { return 4; }
     virtual unsigned height() const { return 4; }
     virtual unsigned planes() const { return 3; }
     virtual int stride(unsigned plane) const { return 4; }
     virtual const void* data(unsigned plane) const { return m_data; }
     virtual unsigned textureId() const { return m_textureId; }
-    virtual unsigned textureTarget() const { return m_textureId ? GraphicsContext3D::TEXTURE_2D : 0; }
+    virtual unsigned textureTarget() const { return m_textureId ? GL_TEXTURE_2D : 0; }
 
     void setTextureId(unsigned id) { m_textureId = id; }
 
 private:
     char m_data[16];
     unsigned m_textureId;
 };
 
 // Fake video frame provider that always provides the same FakeVideoFrame.
 class FakeVideoFrameProvider: public WebVideoFrameProvider {
@@ skipping 13 matching lines @@
 
 private:
     WebVideoFrame* m_frame;
     Client* m_client;
 };
 
 class StrictWebGraphicsContext3DWithIOSurface : public StrictWebGraphicsContext3D {
 public:
     virtual WebString getString(WGC3Denum name) OVERRIDE
     {
-        if (name == cc::GraphicsContext3D::EXTENSIONS)
+        if (name == GL_EXTENSIONS)
             return WebString("GL_CHROMIUM_iosurface GL_ARB_texture_rectangle");
 
         return WebString();
     }
 };
 
 class FakeWebGraphicsContext3DWithIOSurface : public FakeWebGraphicsContext3D {
 public:
     virtual WebString getString(WGC3Denum name) OVERRIDE
     {
-        if (name == cc::GraphicsContext3D::EXTENSIONS)
+        if (name == GL_EXTENSIONS)
             return WebString("GL_CHROMIUM_iosurface GL_ARB_texture_rectangle");
 
         return WebString();
     }
 };
 
 class FakeWebScrollbarThemeGeometryNonEmpty : public FakeWebScrollbarThemeGeometry {
     virtual WebRect trackRect(WebScrollbar*) OVERRIDE { return WebRect(0, 0, 10, 10); }
     virtual WebRect thumbRect(WebScrollbar*) OVERRIDE { return WebRect(0, 5, 5, 2); }
     virtual void splitTrack(WebScrollbar*, const WebRect& track, WebRect& startTrack, WebRect& thumb, WebRect& endTrack) OVERRIDE
     {
         thumb = WebRect(0, 5, 5, 2);
         startTrack = WebRect(0, 5, 0, 5);
         endTrack = WebRect(0, 0, 0, 5);
     }
 };
 
 class FakeScrollbarLayerImpl : public CCScrollbarLayerImpl {
 public:
     static scoped_ptr<FakeScrollbarLayerImpl> create(int id)
     {
         return make_scoped_ptr(new FakeScrollbarLayerImpl(id));
     }
 
     void createResources(CCResourceProvider* provider)
     {
         ASSERT(provider);
         int pool = 0;
         IntSize size(10, 10);
-        GC3Denum format = GraphicsContext3D::RGBA;
+        GLenum format = GL_RGBA;
         CCResourceProvider::TextureUsageHint hint = CCResourceProvider::TextureUsageAny;
         setScrollbarGeometry(CCScrollbarGeometryFixedThumb::create(FakeWebScrollbarThemeGeometryNonEmpty::create()));
 
         setBackTrackResourceId(provider->createResource(pool, size, format, hint));
         setForeTrackResourceId(provider->createResource(pool, size, format, hint));
         setThumbResourceId(provider->createResource(pool, size, format, hint));
     }
 
 protected:
     explicit FakeScrollbarLayerImpl(int id)
         : CCScrollbarLayerImpl(id)
     {
     }
 };
 
 static inline scoped_ptr<CCRenderPass> createRenderPassWithResource(CCResourceProvider* provider)
 {
-    CCResourceProvider::ResourceId resourceId = provider->createResource(0, IntSize(1, 1), GraphicsContext3D::RGBA, CCResourceProvider::TextureUsageAny);
+    CCResourceProvider::ResourceId resourceId = provider->createResource(0, IntSize(1, 1), GL_RGBA, CCResourceProvider::TextureUsageAny);
 
     scoped_ptr<CCRenderPass> pass = CCRenderPass::create(CCRenderPass::Id(1, 1), IntRect(0, 0, 1, 1), WebTransformationMatrix());
     scoped_ptr<CCSharedQuadState> sharedState = CCSharedQuadState::create(WebTransformationMatrix(), IntRect(0, 0, 1, 1), IntRect(0, 0, 1, 1), 1, false);
     scoped_ptr<CCTextureDrawQuad> quad = CCTextureDrawQuad::create(sharedState.get(), IntRect(0, 0, 1, 1), resourceId, false, FloatRect(0, 0, 1, 1), false);
 
     static_cast<CCTestRenderPass*>(pass.get())->appendSharedQuadState(sharedState.Pass());
     static_cast<CCTestRenderPass*>(pass.get())->appendQuad(quad.PassAs<CCDrawQuad>());
 
     return pass.Pass();
 }
@@ skipping 165 matching lines @@
     {
         if (!m_textures.get(id))
             return;
 
         m_textures.set(id, false);
         --m_numTextures;
     }
 
     virtual WebString getString(WGC3Denum name) OVERRIDE
     {
-        if (name == cc::GraphicsContext3D::EXTENSIONS)
+        if (name == GL_EXTENSIONS)
             return WebString("GL_CHROMIUM_iosurface GL_ARB_texture_rectangle");
 
         return WebString();
     }
 
     unsigned numTextures() const { return m_numTextures; }
 
 private:
     HashMap<WebGLId, bool> m_textures;
     unsigned m_numTextures;
@@ skipping 1516 matching lines @@
         verifyRenderPassTestData(removeRenderPassesCases[testCaseIndex], testData);
         testCaseIndex++;
     }
 }
 
 INSTANTIATE_TEST_CASE_P(CCLayerTreeHostImplTests,
                         CCLayerTreeHostImplTest,
                         ::testing::Values(false, true));
 
 } // namespace