Move CC switches to cc/switches.h.

cc/layer_tree_host_impl.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 "CCAppendQuadsData.h"
 #include "CCDamageTracker.h"
@@ skipping 129 matching lines @@
     return overflow;
 }
 
 WebTransformationMatrix CCPinchZoomViewport::implTransform() const
 {
     WebTransformationMatrix transform;
     transform.scale(m_pageScaleDelta);
 
     // If the pinch state is applied in the impl, then push it to the
     // impl transform, otherwise the scale is handled by WebCore.
-    if (CCSettings::pageScalePinchZoomEnabled()) {
+    if (Settings::pageScalePinchZoomEnabled()) {
         transform.scale(m_pageScaleFactor);
         transform.translate(-m_pinchViewportScrollDelta.x(),
                             -m_pinchViewportScrollDelta.y());
     }
 
     return transform;
 }
 
 class CCLayerTreeHostImplTimeSourceAdapter : public CCTimeSourceClient {
 public:
@@ skipping 272 matching lines @@
 
                 targetRenderPass->appendQuadsForLayer(*it, &occlusionTracker, appendQuadsData);
             }
         }
 
         if (appendQuadsData.hadOcclusionFromOutsideTargetSurface)
             targetRenderPass->setHasOcclusionFromOutsideTargetSurface(true);
 
         if (appendQuadsData.hadMissingTiles) {
             bool layerHasAnimatingTransform = it->screenSpaceTransformIsAnimating() || it->drawTransformIsAnimating();
-            if (layerHasAnimatingTransform || CCSettings::jankInsteadOfCheckerboard())
+            if (layerHasAnimatingTransform || Settings::jankInsteadOfCheckerboard())
                 drawFrame = false;
         }
 
         occlusionTracker.leaveLayer(it);
     }
 
 #ifndef NDEBUG
     for (size_t i = 0; i < frame.renderPasses.size(); ++i) {
       for (size_t j = 0; j < frame.renderPasses[i]->quadList().size(); ++j)
         DCHECK(frame.renderPasses[i]->quadList()[j]->sharedQuadStateId() >= 0);
@@ skipping 473 matching lines @@
 }
 
 void CCLayerTreeHostImpl::setPageScaleFactorAndLimits(float pageScaleFactor, float minPageScaleFactor, float maxPageScaleFactor)
 {
     if (!pageScaleFactor)
       return;
 
     float pageScaleChange = pageScaleFactor / m_pinchZoomViewport.pageScaleFactor();
     m_pinchZoomViewport.setPageScaleFactorAndLimits(pageScaleFactor, minPageScaleFactor, maxPageScaleFactor);
 
-    if (!CCSettings::pageScalePinchZoomEnabled()) {
+    if (!Settings::pageScalePinchZoomEnabled()) {
         if (pageScaleChange != 1)
             adjustScrollsForPageScaleChange(m_rootScrollLayerImpl, pageScaleChange);
     }
 
     // Clamp delta to limits and refresh display matrix.
     setPageScaleDelta(m_pinchZoomViewport.pageScaleDelta() / m_pinchZoomViewport.sentPageScaleDelta());
     m_pinchZoomViewport.setSentPageScaleDelta(1);
 }
 
 void CCLayerTreeHostImpl::setPageScaleDelta(float delta)
@@ skipping 11 matching lines @@
     FloatSize viewBounds = m_deviceViewportSize;
     if (CCLayerImpl* clipLayer = m_rootScrollLayerImpl->parent()) {
         // Compensate for non-overlay scrollbars.
         if (clipLayer->masksToBounds()) {
             viewBounds = clipLayer->bounds();
             viewBounds.scale(m_deviceScaleFactor);
         }
     }
 
     IntSize contentBounds = contentSize();
-    if (CCSettings::pageScalePinchZoomEnabled()) {
+    if (Settings::pageScalePinchZoomEnabled()) {
         // Pinch with pageScale scrolls entirely in layout space.  contentSize
         // returns the bounds including the page scale factor, so calculate the
         // pre page-scale layout size here.
         float pageScaleFactor = m_pinchZoomViewport.pageScaleFactor();
         contentBounds.setWidth(contentBounds.width() / pageScaleFactor);
         contentBounds.setHeight(contentBounds.height() / pageScaleFactor);
     } else {
         viewBounds.scale(1 / m_pinchZoomViewport.pageScaleDelta());
     }
 
@@ skipping 215 matching lines @@
     float pageScaleDelta = m_pinchZoomViewport.pageScaleDelta();
     FloatPoint previousScaleAnchor(m_previousPinchAnchor.x() / pageScaleDelta,
                                    m_previousPinchAnchor.y() / pageScaleDelta);
     setPageScaleDelta(pageScaleDelta * magnifyDelta);
     pageScaleDelta = m_pinchZoomViewport.pageScaleDelta();
     FloatPoint newScaleAnchor(anchor.x() / pageScaleDelta, anchor.y() / pageScaleDelta);
     FloatSize move = previousScaleAnchor - newScaleAnchor;
 
     m_previousPinchAnchor = anchor;
 
-    if (CCSettings::pageScalePinchZoomEnabled()) {
+    if (Settings::pageScalePinchZoomEnabled()) {
         // Compute the application of the delta with respect to the current page zoom of the page.
         move.scale(1 / (m_pinchZoomViewport.pageScaleFactor() * m_deviceScaleFactor));
     }
 
-    FloatSize scrollOverflow = CCSettings::pageScalePinchZoomEnabled() ? m_pinchZoomViewport.applyScroll(move) : move;
+    FloatSize scrollOverflow = Settings::pageScalePinchZoomEnabled() ? m_pinchZoomViewport.applyScroll(move) : move;
     m_rootScrollLayerImpl->scrollBy(roundedIntSize(scrollOverflow));
 
     if (m_rootScrollLayerImpl->scrollbarAnimationController())
         m_rootScrollLayerImpl->scrollbarAnimationController()->didPinchGestureUpdate();
 
     m_client->setNeedsCommitOnImplThread();
     m_client->setNeedsRedrawOnImplThread();
 }
 
 void CCLayerTreeHostImpl::pinchGestureEnd()
@@ skipping 80 matching lines @@
 
 scoped_ptr<CCScrollAndScaleSet> CCLayerTreeHostImpl::processScrollDeltas()
 {
     scoped_ptr<CCScrollAndScaleSet> scrollInfo(new CCScrollAndScaleSet());
 
     if (m_pinchGestureActive || m_pageScaleAnimation) {
         scrollInfo->pageScaleDelta = 1;
         m_pinchZoomViewport.setSentPageScaleDelta(1);
         // FIXME(aelias): Make these painting optimizations compatible with
         // compositor-side scaling.
-        if (!CCSettings::pageScalePinchZoomEnabled()) {
+        if (!Settings::pageScalePinchZoomEnabled()) {
             if (m_pinchGestureActive)
                 computePinchZoomDeltas(scrollInfo.get());
             else if (m_pageScaleAnimation.get())
                 computeDoubleTapZoomDeltas(scrollInfo.get());
         }
         return scrollInfo.Pass();
     }
 
     collectScrollDeltas(scrollInfo.get(), m_rootLayerImpl.get());
     scrollInfo->pageScaleDelta = m_pinchZoomViewport.pageScaleDelta();
@@ skipping 30 matching lines @@
     m_client->setNeedsRedrawOnImplThread();
 
     if (m_pageScaleAnimation->isAnimationCompleteAtTime(monotonicTime)) {
         m_pageScaleAnimation.reset();
         m_client->setNeedsCommitOnImplThread();
     }
 }
 
 void CCLayerTreeHostImpl::animateLayers(double monotonicTime, double wallClockTime)
 {
-    if (!CCSettings::acceleratedAnimationEnabled() || !m_needsAnimateLayers || !m_rootLayerImpl)
+    if (!Settings::acceleratedAnimationEnabled() || !m_needsAnimateLayers || !m_rootLayerImpl)
         return;
 
     TRACE_EVENT0("cc", "CCLayerTreeHostImpl::animateLayers");
 
     scoped_ptr<CCAnimationEventsVector> events(make_scoped_ptr(new CCAnimationEventsVector));
 
     bool didAnimate = false;
     animateLayersRecursive(m_rootLayerImpl.get(), monotonicTime, wallClockTime, events.get(), didAnimate, m_needsAnimateLayers);
 
     if (!events->empty())
@@ skipping 81 matching lines @@
 
     CCScrollbarAnimationController* scrollbarController = layer->scrollbarAnimationController();
     if (scrollbarController && scrollbarController->animate(monotonicTime))
         m_client->setNeedsRedrawOnImplThread();
 
     for (size_t i = 0; i < layer->children().size(); ++i)
         animateScrollbarsRecursive(layer->children()[i], monotonicTime);
 }
 
 }  // namespace cc