Move CC switches to cc/switches.h.

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 "CCDelegatedRendererLayerImpl.h"
 #include "CCHeadsUpDisplayLayerImpl.h"
 #include "CCIOSurfaceLayerImpl.h"
 #include "CCLayerImpl.h"
 #include "CCLayerTilingData.h"
 #include "CCQuadSink.h"
 #include "CCRenderPassDrawQuad.h"
 #include "CCRendererGL.h"
 #include "CCScrollbarGeometryFixedThumb.h"
 #include "CCScrollbarLayerImpl.h"
 #include "CCSettings.h"
 #include "CCSingleThreadProxy.h"
 #include "CCSolidColorDrawQuad.h"
 #include "CCTextureDrawQuad.h"
 #include "CCTextureLayerImpl.h"
 #include "CCTileDrawQuad.h"
 #include "CCTiledLayerImpl.h"
 #include "CCVideoLayerImpl.h"
+#include "base/command_line.h"
 #include "base/hash_tables.h"
 #include "cc/test/animation_test_common.h"
 #include "cc/test/fake_web_compositor_output_surface.h"
 #include "cc/test/fake_web_graphics_context_3d.h"
 #include "cc/test/fake_web_scrollbar_theme_geometry.h"
 #include "cc/test/geometry_test_utils.h"
 #include "cc/test/layer_test_common.h"
 #include "cc/test/render_pass_test_common.h"
 #include "cc/test/test_common.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ skipping 22 matching lines @@
     CCLayerTreeHostImplTest()
         : m_onCanDrawStateChangedCalled(false)
         , m_didRequestCommit(false)
         , m_didRequestRedraw(false)
         , m_reduceMemoryResult(true)
     {
     }
 
     virtual void SetUp()
     {
-        CCSettings::setPageScalePinchZoomEnabled(GetParam());
+        CCSettings::setPageScalePinchZoomEnabledForTest(GetParam());
         CCLayerTreeSettings settings;
         settings.minimumOcclusionTrackingSize = IntSize();
 
         m_hostImpl = CCLayerTreeHostImpl::create(settings, this);
         m_hostImpl->initializeRenderer(createContext());
         m_hostImpl->setViewportSize(IntSize(10, 10), IntSize(10, 10));
     }
 
     virtual void TearDown()
     {
-        CCSettings::reset();
     }
 
     virtual void didLoseContextOnImplThread() OVERRIDE { }
     virtual void onSwapBuffersCompleteOnImplThread() OVERRIDE { }
     virtual void onVSyncParametersChanged(double, double) OVERRIDE { }
     virtual void onCanDrawStateChanged(bool canDraw) OVERRIDE { m_onCanDrawStateChangedCalled = true; }
     virtual void setNeedsRedrawOnImplThread() OVERRIDE { m_didRequestRedraw = true; }
     virtual void setNeedsCommitOnImplThread() OVERRIDE { m_didRequestCommit = true; }
     virtual void postAnimationEventsToMainThreadOnImplThread(scoped_ptr<CCAnimationEventsVector>, double wallClockTime) OVERRIDE { }
     virtual bool reduceContentsTextureMemoryOnImplThread(size_t limitBytes) OVERRIDE { return m_reduceMemoryResult; }
 
     void setReduceMemoryResult(bool reduceMemoryResult) { m_reduceMemoryResult = reduceMemoryResult; }
 
     scoped_ptr<CCLayerTreeHostImpl> createLayerTreeHost(bool partialSwap, scoped_ptr<CCGraphicsContext> graphicsContext, scoped_ptr<CCLayerImpl> root)
     {
-        CCSettings::setPartialSwapEnabled(partialSwap);
+        CCSettings::setPartialSwapEnabledForTest(partialSwap);
 
         CCLayerTreeSettings settings;
         settings.minimumOcclusionTrackingSize = IntSize();
 
         scoped_ptr<CCLayerTreeHostImpl> myHostImpl = CCLayerTreeHostImpl::create(settings, this);
 
         myHostImpl->initializeRenderer(graphicsContext.Pass());
         myHostImpl->setViewportSize(IntSize(10, 10), IntSize(10, 10));
 
         root->setAnchorPoint(FloatPoint(0, 0));
@@ skipping 1826 matching lines @@
 // Make sure damage tracking propagates all the way to the graphics context,
 // where it should request to swap only the subBuffer that is damaged.
 TEST_P(CCLayerTreeHostImplTest, partialSwapReceivesDamageRect)
 {
     scoped_ptr<CCGraphicsContext> ccContext = FakeWebCompositorOutputSurface::create(adoptPtr(new PartialSwapTrackerContext)).PassAs<CCGraphicsContext>();
     PartialSwapTrackerContext* partialSwapTracker = static_cast<PartialSwapTrackerContext*>(ccContext->context3D());
 
     // This test creates its own CCLayerTreeHostImpl, so
     // that we can force partial swap enabled.
     CCLayerTreeSettings settings;
-    CCSettings::setPartialSwapEnabled(true);
+    CCSettings::setPartialSwapEnabledForTest(true);
     scoped_ptr<CCLayerTreeHostImpl> layerTreeHostImpl = CCLayerTreeHostImpl::create(settings, this);
     layerTreeHostImpl->initializeRenderer(ccContext.Pass());
     layerTreeHostImpl->setViewportSize(IntSize(500, 500), IntSize(500, 500));
 
     scoped_ptr<CCLayerImpl> root = FakeDrawableCCLayerImpl::create(1);
     scoped_ptr<CCLayerImpl> child = FakeDrawableCCLayerImpl::create(2);
     child->setPosition(FloatPoint(12, 13));
     child->setAnchorPoint(FloatPoint(0, 0));
     child->setBounds(IntSize(14, 15));
     child->setContentBounds(IntSize(14, 15));
@@ skipping 262 matching lines @@
     // Unlimited texture size.
     virtual void getIntegerv(WGC3Denum pname, WGC3Dint* value)
     {
         if (pname == cc::GraphicsContext3D::MAX_TEXTURE_SIZE)
             *value = 8192;
     }
 };
 
 static scoped_ptr<CCLayerTreeHostImpl> setupLayersForOpacity(bool partialSwap, CCLayerTreeHostImplClient* client)
 {
-    CCSettings::setPartialSwapEnabled(partialSwap);
+    CCSettings::setPartialSwapEnabledForTest(partialSwap);
 
     scoped_ptr<CCGraphicsContext> context = FakeWebCompositorOutputSurface::create(adoptPtr(new PartialSwapContext)).PassAs<CCGraphicsContext>();
 
     CCLayerTreeSettings settings;
     scoped_ptr<CCLayerTreeHostImpl> myHostImpl = CCLayerTreeHostImpl::create(settings, client);
     myHostImpl->initializeRenderer(context.Pass());
     myHostImpl->setViewportSize(IntSize(100, 100), IntSize(100, 100));
 
     /*
       Layers are created as follows:
@@ skipping 744 matching lines @@
     addDrawingLayerTo(surfaceLayerPtr, 4, IntRect(5, 5, rootSize.width() - 25, rootSize.height() - 25), &childPtr);
 }
 
 class CCRendererGLWithReleaseTextures : public CCRendererGL {
 public:
     using CCRendererGL::releaseRenderPassTextures;
 };
 
 TEST_P(CCLayerTreeHostImplTest, textureCachingWithClipping)
 {
-    CCSettings::setPartialSwapEnabled(true);
+    CCSettings::setPartialSwapEnabledForTest(true);
 
     CCLayerTreeSettings settings;
     settings.minimumOcclusionTrackingSize = IntSize();
     scoped_ptr<CCLayerTreeHostImpl> myHostImpl = CCLayerTreeHostImpl::create(settings, this);
 
     CCLayerImpl* rootPtr;
     CCLayerImpl* surfaceLayerPtr;
 
     scoped_ptr<CCGraphicsContext> context = FakeWebCompositorOutputSurface::create(adoptPtr(new PartialSwapContext)).PassAs<CCGraphicsContext>();
 
@@ skipping 76 matching lines @@
         EXPECT_EQ(2U, frame.renderPasses[0]->quadList().size());
         ASSERT_EQ(1U, frame.renderPasses[1]->quadList().size());
 
         myHostImpl->drawLayers(frame);
         myHostImpl->didDrawAllLayers(frame);
     }
 }
 
 TEST_P(CCLayerTreeHostImplTest, textureCachingWithOcclusion)
 {
-    CCSettings::setPartialSwapEnabled(false);
+    CCSettings::setPartialSwapEnabledForTest(false);
 
     CCLayerTreeSettings settings;
     settings.minimumOcclusionTrackingSize = IntSize();
     scoped_ptr<CCLayerTreeHostImpl> myHostImpl = CCLayerTreeHostImpl::create(settings, this);
 
     // Layers are structure as follows:
     //
     //  R +-- S1 +- L10 (owning)
     //    |      +- L11
     //    |      +- L12
@@ skipping 95 matching lines @@
         EXPECT_EQ(2U, frame.renderPasses[0]->quadList().size());
 
         myHostImpl->drawLayers(frame);
         myHostImpl->didDrawAllLayers(frame);
     }
 
 }
 
 TEST_P(CCLayerTreeHostImplTest, textureCachingWithOcclusionEarlyOut)
 {
-    CCSettings::setPartialSwapEnabled(false);
+    CCSettings::setPartialSwapEnabledForTest(false);
 
     CCLayerTreeSettings settings;
     settings.minimumOcclusionTrackingSize = IntSize();
     scoped_ptr<CCLayerTreeHostImpl> myHostImpl = CCLayerTreeHostImpl::create(settings, this);
 
     // Layers are structure as follows:
     //
     //  R +-- S1 +- L10 (owning, non drawing)
     //    |      +- L11 (corner, unoccluded)
     //    |      +- L12 (corner, unoccluded)
@@ skipping 95 matching lines @@
 
         EXPECT_EQ(2U, frame.renderPasses[0]->quadList().size());
 
         myHostImpl->drawLayers(frame);
         myHostImpl->didDrawAllLayers(frame);
     }
 }
 
 TEST_P(CCLayerTreeHostImplTest, textureCachingWithOcclusionExternalOverInternal)
 {
-    CCSettings::setPartialSwapEnabled(false);
+    CCSettings::setPartialSwapEnabledForTest(false);
 
     CCLayerTreeSettings settings;
     settings.minimumOcclusionTrackingSize = IntSize();
     scoped_ptr<CCLayerTreeHostImpl> myHostImpl = CCLayerTreeHostImpl::create(settings, this);
 
     // Layers are structured as follows:
     //
     //  R +-- S1 +- L10 (owning, drawing)
     //    |      +- L11 (corner, occluded by L12)
     //    |      +- L12 (opposite corner)
@@ skipping 68 matching lines @@
         EXPECT_GT(frame.renderPasses[0]->quadList().size(), 0U);
         EXPECT_EQ(2U, frame.renderPasses[1]->quadList().size());
 
         myHostImpl->drawLayers(frame);
         myHostImpl->didDrawAllLayers(frame);
     }
 }
 
 TEST_P(CCLayerTreeHostImplTest, textureCachingWithOcclusionExternalNotAligned)
 {
-    CCSettings::setPartialSwapEnabled(false);
+    CCSettings::setPartialSwapEnabledForTest(false);
 
     CCLayerTreeSettings settings;
     scoped_ptr<CCLayerTreeHostImpl> myHostImpl = CCLayerTreeHostImpl::create(settings, this);
 
     // Layers are structured as follows:
     //
     //  R +-- S1 +- L10 (rotated, drawing)
     //           +- L11 (occupies half surface)
 
     CCLayerImpl* rootPtr;
@@ skipping 53 matching lines @@
 
         EXPECT_EQ(1U, frame.renderPasses[0]->quadList().size());
 
         myHostImpl->drawLayers(frame);
         myHostImpl->didDrawAllLayers(frame);
     }
 }
 
 TEST_P(CCLayerTreeHostImplTest, textureCachingWithOcclusionPartialSwap)
 {
-    CCSettings::setPartialSwapEnabled(true);
+    CCSettings::setPartialSwapEnabledForTest(true);
 
     CCLayerTreeSettings settings;
     settings.minimumOcclusionTrackingSize = IntSize();
     scoped_ptr<CCLayerTreeHostImpl> myHostImpl = CCLayerTreeHostImpl::create(settings, this);
 
     // Layers are structure as follows:
     //
     //  R +-- S1 +- L10 (owning)
     //    |      +- L11
     //    |      +- L12
@@ skipping 92 matching lines @@
         // Root render pass only.
         ASSERT_EQ(1U, frame.renderPasses.size());
 
         myHostImpl->drawLayers(frame);
         myHostImpl->didDrawAllLayers(frame);
     }
 }
 
 TEST_P(CCLayerTreeHostImplTest, textureCachingWithScissor)
 {
-    CCSettings::setPartialSwapEnabled(false);
+    CCSettings::setPartialSwapEnabledForTest(false);
 
     CCLayerTreeSettings settings;
     settings.minimumOcclusionTrackingSize = IntSize();
     scoped_ptr<CCLayerTreeHostImpl> myHostImpl = CCLayerTreeHostImpl::create(settings, this);
 
     /*
       Layers are created as follows:
 
          +--------------------+
          |                  1 |
@@ skipping 86 matching lines @@
         myHostImpl->drawLayers(frame);
         myHostImpl->didDrawAllLayers(frame);
     }
 
     // We should have a cached texture for surface 2 again even though it was damaged.
     EXPECT_TRUE(myHostImpl->renderer()->haveCachedResourcesForRenderPassId(childPassId));
 }
 
 TEST_P(CCLayerTreeHostImplTest, surfaceTextureCaching)
 {
-    CCSettings::setPartialSwapEnabled(true);
+    CCSettings::setPartialSwapEnabledForTest(true);
 
     CCLayerTreeSettings settings;
     settings.minimumOcclusionTrackingSize = IntSize();
     scoped_ptr<CCLayerTreeHostImpl> myHostImpl = CCLayerTreeHostImpl::create(settings, this);
 
     CCLayerImpl* rootPtr;
     CCLayerImpl* intermediateLayerPtr;
     CCLayerImpl* surfaceLayerPtr;
     CCLayerImpl* childPtr;
 
@@ skipping 140 matching lines @@
         CCRenderPass* targetPass = frame.renderPassesById.get(quad->renderPassId());
         EXPECT_TRUE(targetPass->damageRect().isEmpty());
 
         myHostImpl->drawLayers(frame);
         myHostImpl->didDrawAllLayers(frame);
     }
 }
 
 TEST_P(CCLayerTreeHostImplTest, surfaceTextureCachingNoPartialSwap)
 {
-    CCSettings::setPartialSwapEnabled(false);
+    CCSettings::setPartialSwapEnabledForTest(false);
 
     CCLayerTreeSettings settings;
     settings.minimumOcclusionTrackingSize = IntSize();
     scoped_ptr<CCLayerTreeHostImpl> myHostImpl = CCLayerTreeHostImpl::create(settings, this);
 
     CCLayerImpl* rootPtr;
     CCLayerImpl* intermediateLayerPtr;
     CCLayerImpl* surfaceLayerPtr;
     CCLayerImpl* childPtr;
 
@@ skipping 499 matching lines @@
         verifyRenderPassTestData(removeRenderPassesCases[testCaseIndex], testData);
         testCaseIndex++;
     }
 }
 
 INSTANTIATE_TEST_CASE_P(CCLayerTreeHostImplTests,
                         CCLayerTreeHostImplTest,
                         ::testing::Values(false, true));
 
 } // namespace