cc: Remove cc::settings, move them to LayerTreeSettings.

cc/layer_tree_host.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 "cc/layer_tree_host.h"
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop.h"
 #include "cc/font_atlas.h"
 #include "cc/graphics_context.h"
 #include "cc/heads_up_display_layer.h"
 #include "cc/heads_up_display_layer_impl.h"
 #include "cc/layer.h"
 #include "cc/layer_animation_controller.h"
 #include "cc/layer_iterator.h"
 #include "cc/layer_tree_host_client.h"
 #include "cc/layer_tree_host_common.h"
 #include "cc/layer_tree_host_impl.h"
 #include "cc/math_util.h"
 #include "cc/occlusion_tracker.h"
 #include "cc/overdraw_metrics.h"
-#include "cc/settings.h"
 #include "cc/single_thread_proxy.h"
 #include "cc/switches.h"
 #include "cc/thread.h"
 #include "cc/thread_proxy.h"
 #include "cc/tree_synchronizer.h"
 
 using namespace std;
 
 namespace {
 static int numLayerTreeInstances;
 }
 
 namespace cc {
 
 bool LayerTreeHost::s_needsFilterContext = false;
 
 LayerTreeSettings::LayerTreeSettings()
     : acceleratePainting(false)
     , showPlatformLayerTree(false)
     , showPaintRects(false)
     , showPropertyChangedRects(false)
     , showSurfaceDamageRects(false)
     , showScreenSpaceRects(false)
     , showReplicaScreenSpaceRects(false)
     , showOccludingRects(false)
     , renderVSyncEnabled(true)
+    , perTilePaintingEnabled(false)
+    , partialSwapEnabled(false)
+    , acceleratedAnimationEnabled(false)
+    , pageScalePinchZoomEnabled(false)
+    , jankInsteadOfCheckerboard(false)

[slavi, 2012/11/14 00:54:58]

Wasn't jank-instead-of-checkerboard removed a couple days ago?

[danakj, 2012/11/14 00:56:36]

it's in the process of dying in the CQ.

+    , backgroundColorInsteadOfCheckerboard(false)
+    , showOverdrawInTracing(false)
     , refreshRate(0)
     , maxPartialTextureUpdates(std::numeric_limits<size_t>::max())
     , defaultTileSize(gfx::Size(256, 256))
     , maxUntiledLayerSize(gfx::Size(512, 512))
     , minimumOcclusionTrackingSize(gfx::Size(160, 160))
 {
     // TODO(danakj): Move this to chromium when we don't go through the WebKit API anymore.
     showPropertyChangedRects = CommandLine::ForCurrentProcess()->HasSwitch(cc::switches::kShowPropertyChangedRects);
     showSurfaceDamageRects = CommandLine::ForCurrentProcess()->HasSwitch(cc::switches::kShowSurfaceDamageRects);
     showScreenSpaceRects = CommandLine::ForCurrentProcess()->HasSwitch(cc::switches::kShowScreenSpaceRects);
     showReplicaScreenSpaceRects = CommandLine::ForCurrentProcess()->HasSwitch(cc::switches::kShowReplicaScreenSpaceRects);
     showOccludingRects = CommandLine::ForCurrentProcess()->HasSwitch(cc::switches::kShowOccludingRects);
+    partialSwapEnabled = CommandLine::ForCurrentProcess()->HasSwitch(switches::kEnablePartialSwap);
+    jankInsteadOfCheckerboard = CommandLine::ForCurrentProcess()->HasSwitch(switches::kJankInsteadOfCheckerboard);
+    backgroundColorInsteadOfCheckerboard = CommandLine::ForCurrentProcess()->HasSwitch(switches::kBackgroundColorInsteadOfCheckerboard);
+    showOverdrawInTracing = CommandLine::ForCurrentProcess()->HasSwitch(switches::kTraceOverdraw);
 }
 
 LayerTreeSettings::~LayerTreeSettings()
 {
 }
 
 RendererCapabilities::RendererCapabilities()
     : bestTextureFormat(0)
     , contextHasCachedFrontBuffer(false)
     , usingPartialSwap(false)
@@ skipping 466 matching lines @@
     return 0;
 }
 
 void LayerTreeHost::updateLayers(Layer* rootLayer, ResourceUpdateQueue& queue)
 {
     TRACE_EVENT0("cc", "LayerTreeHost::updateLayers");
 
     LayerList updateList;
 
     {
-        if (Settings::pageScalePinchZoomEnabled()) {
+        if (m_settings.pageScalePinchZoomEnabled) {
             Layer* rootScroll = findFirstScrollableLayer(rootLayer);
             if (rootScroll)
                 rootScroll->setImplTransform(m_implTransform);
         }
 
         TRACE_EVENT0("cc", "LayerTreeHost::updateLayers::calcDrawEtc");
         LayerTreeHostCommon::calculateDrawTransforms(rootLayer, deviceViewportSize(), m_deviceScaleFactor, m_pageScaleFactor, rendererCapabilities().maxTextureSize, updateList);
     }
 
     // Reset partial texture update requests.
@@ skipping 106 matching lines @@
     }
     return needMoreUpdates;
 }
 
 bool LayerTreeHost::paintLayerContents(const LayerList& renderSurfaceLayerList, ResourceUpdateQueue& queue)
 {
     // Use FrontToBack to allow for testing occlusion and performing culling during the tree walk.
     typedef LayerIterator<Layer, LayerList, RenderSurface, LayerIteratorActions::FrontToBack> LayerIteratorType;
 
     bool needMoreUpdates = false;
-    bool recordMetricsForFrame = Settings::traceOverdraw() && base::debug::TraceLog::GetInstance() && base::debug::TraceLog::GetInstance()->IsEnabled();
+    bool recordMetricsForFrame = m_settings.showOverdrawInTracing && base::debug::TraceLog::GetInstance() && base::debug::TraceLog::GetInstance()->IsEnabled();
     OcclusionTracker occlusionTracker(m_rootLayer->renderSurface()->contentRect(), recordMetricsForFrame);
     occlusionTracker.setMinimumTrackingSize(m_settings.minimumOcclusionTrackingSize);
 
     prioritizeTextures(renderSurfaceLayerList, occlusionTracker.overdrawMetrics());
 
     LayerIteratorType end = LayerIteratorType::end(&renderSurfaceLayerList);
     for (LayerIteratorType it = LayerIteratorType::begin(&renderSurfaceLayerList); it != end; ++it) {
         occlusionTracker.enterLayer(it);
 
         if (it.representsTargetRenderSurface()) {
@@ skipping 110 matching lines @@
 {
     if (deviceScaleFactor ==  m_deviceScaleFactor)
         return;
     m_deviceScaleFactor = deviceScaleFactor;
 
     setNeedsCommit();
 }
 
 void LayerTreeHost::animateLayers(base::TimeTicks time)
 {
-    if (!Settings::acceleratedAnimationEnabled() || !m_needsAnimateLayers)
+    if (!m_settings.acceleratedAnimationEnabled || !m_needsAnimateLayers)
         return;
 
     TRACE_EVENT0("cc", "LayerTreeHostImpl::animateLayers");
     m_needsAnimateLayers = animateLayersRecursive(m_rootLayer.get(), time);
 }
 
 bool LayerTreeHost::animateLayersRecursive(Layer* current, base::TimeTicks time)
 {
     if (!current)
         return false;
@@ skipping 27 matching lines @@
             else
                 layer->notifyAnimationFinished(wallClockTime.ToDoubleT());
         }
     }
 
     for (size_t childIndex = 0; childIndex < layer->children().size(); ++childIndex)
         setAnimationEventsRecursive(events, layer->children()[childIndex].get(), wallClockTime);
 }
 
 }  // namespace cc