cc: handling debug settings in new LayerTreeDebugState structure

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 "cc/layer_tree_host_impl.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/debug/trace_event.h"
 #include "cc/append_quads_data.h"
 #include "cc/damage_tracker.h"
 #include "cc/debug_rect_history.h"
 #include "cc/delay_based_time_source.h"
-#include "cc/font_atlas.h"
 #include "cc/frame_rate_counter.h"
 #include "cc/gl_renderer.h"
 #include "cc/heads_up_display_layer_impl.h"
 #include "cc/layer_iterator.h"
 #include "cc/layer_tree_host.h"
 #include "cc/layer_tree_host_common.h"
 #include "cc/math_util.h"
 #include "cc/overdraw_metrics.h"
 #include "cc/page_scale_animation.h"
 #include "cc/prioritized_resource_manager.h"
@@ skipping 177 matching lines @@
 LayerTreeHostImpl::LayerTreeHostImpl(const LayerTreeSettings& settings, LayerTreeHostImplClient* client, Proxy* proxy)
     : m_client(client)
     , m_proxy(proxy)
     , m_sourceFrameNumber(-1)
     , m_rootScrollLayerImpl(0)
     , m_currentlyScrollingLayerImpl(0)
     , m_hudLayerImpl(0)
     , m_scrollingLayerIdFromPreviousTree(-1)
     , m_scrollDeltaIsInViewportSpace(false)
     , m_settings(settings)
+    , m_switches(settings.initialSwitchSettings)
     , m_deviceScaleFactor(1)
     , m_visible(true)
     , m_contentsTexturesPurged(false)
     , m_managedMemoryPolicy(PrioritizedResourceManager::defaultMemoryAllocationLimit(),
                             PriorityCalculator::allowEverythingCutoff(),
                             0,
                             PriorityCalculator::allowNothingCutoff())
     , m_backgroundColor(0)
     , m_hasTransparentBackground(false)
     , m_needsAnimateLayers(false)
@@ skipping 257 matching lines @@
     // Create the render passes in dependency order.
     for (int surfaceIndex = frame.renderSurfaceLayerList->size() - 1; surfaceIndex >= 0 ; --surfaceIndex) {
         LayerImpl* renderSurfaceLayer = (*frame.renderSurfaceLayerList)[surfaceIndex];
         renderSurfaceLayer->renderSurface()->appendRenderPasses(frame);
     }
 
     bool recordMetricsForFrame = m_settings.showOverdrawInTracing && base::debug::TraceLog::GetInstance() && base::debug::TraceLog::GetInstance()->IsEnabled();
     OcclusionTrackerImpl occlusionTracker(m_rootLayerImpl->renderSurface()->contentRect(), recordMetricsForFrame);
     occlusionTracker.setMinimumTrackingSize(m_settings.minimumOcclusionTrackingSize);
 
-    if (settings().showOccludingRects)
+    if (m_switches.showOccludingRects)
         occlusionTracker.setOccludingScreenSpaceRectsContainer(&frame.occludingScreenSpaceRects);
-    if (settings().showNonOccludingRects)
+    if (m_switches.showNonOccludingRects)
         occlusionTracker.setNonOccludingScreenSpaceRectsContainer(&frame.nonOccludingScreenSpaceRects);
 
     // Add quads to the Render passes in FrontToBack order to allow for testing occlusion and performing culling during the tree walk.
     typedef LayerIterator<LayerImpl, std::vector<LayerImpl*>, RenderSurfaceImpl, LayerIteratorActions::FrontToBack> LayerIteratorType;
 
     // Typically when we are missing a texture and use a checkerboard quad, we still draw the frame. However when the layer being
     // checkerboarded is moving due to an impl-animation, we drop the frame to avoid flashing due to the texture suddenly appearing
     // in the future.
     bool drawFrame = true;
 
@@ skipping 284 matching lines @@
 {
     TRACE_EVENT0("cc", "LayerTreeHostImpl::drawLayers");
     DCHECK(canDraw());
     DCHECK(!frame.renderPasses.empty());
 
     // FIXME: use the frame begin time from the overall compositor scheduler.
     // This value is currently inaccessible because it is up in Chromium's
     // RenderWidget.
     m_fpsCounter->markBeginningOfFrame(base::TimeTicks::Now());
 
-    if (m_settings.showDebugRects())
-        m_debugRectHistory->saveDebugRectsForCurrentFrame(m_rootLayerImpl.get(), *frame.renderSurfaceLayerList, frame.occludingScreenSpaceRects, frame.nonOccludingScreenSpaceRects, settings());
+    if (m_switches.showHudRects())
+        m_debugRectHistory->saveDebugRectsForCurrentFrame(m_rootLayerImpl.get(), *frame.renderSurfaceLayerList, frame.occludingScreenSpaceRects, frame.nonOccludingScreenSpaceRects, m_switches);
 
     // Because the contents of the HUD depend on everything else in the frame, the contents
     // of its texture are updated as the last thing before the frame is drawn.
-    if (m_hudLayerImpl)
+    if (m_hudLayerImpl && m_switches.showHudInfo())
         m_hudLayerImpl->updateHudTexture(m_resourceProvider.get());
 
     m_renderer->drawFrame(frame.renderPasses, frame.renderPassesById);
 
     // Once a RenderPass has been drawn, its damage should be cleared in
     // case the RenderPass will be reused next frame.
     for (unsigned int i = 0; i < frame.renderPasses.size(); i++)
         frame.renderPasses[i]->damage_rect = gfx::RectF();
 
     // The next frame should start by assuming nothing has changed, and changes are noted as they occur.
@@ skipping 776 matching lines @@
     ScrollbarAnimationController* scrollbarController = layer->scrollbarAnimationController();
     double monotonicTime = (time - base::TimeTicks()).InSecondsF();
     if (scrollbarController && scrollbarController->animate(monotonicTime))
         m_client->setNeedsRedrawOnImplThread();
 
     for (size_t i = 0; i < layer->children().size(); ++i)
         animateScrollbarsRecursive(layer->children()[i], time);
 }
 
 }  // namespace cc