CC: Force push properties for all layers when tracing is started

cc/trees/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/trees/layer_tree_host_impl.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/basictypes.h"
@@ skipping 138 matching lines @@
                   max_transfer_buffer_usage_bytes);
 }
 
 size_t GetMaxStagingResourceCount() {
   // Upper bound for number of staging resource to allow.
   return 32;
 }
 
 }  // namespace
 
-LayerTreeHostImpl::FrameData::FrameData() : has_no_damage(false) {
+FrameData::FrameData() : has_no_damage(false) {
 }
 
-LayerTreeHostImpl::FrameData::~FrameData() {}
+FrameData::~FrameData() {
+}
 
 scoped_ptr<LayerTreeHostImpl> LayerTreeHostImpl::Create(
     const LayerTreeSettings& settings,
     LayerTreeHostImplClient* client,
     Proxy* proxy,
     RenderingStatsInstrumentation* rendering_stats_instrumentation,
     SharedBitmapManager* shared_bitmap_manager,
     gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
     int id) {
   return make_scoped_ptr(new LayerTreeHostImpl(settings,
@@ skipping 369 matching lines @@
     render_surface->damage_tracker()->UpdateDamageTrackingState(
         render_surface->layer_list(),
         render_surface_layer->id(),
         render_surface->SurfacePropertyChangedOnlyFromDescendant(),
         render_surface->content_rect(),
         render_surface_layer->mask_layer(),
         render_surface_layer->filters());
   }
 }
 
-void LayerTreeHostImpl::FrameData::AsValueInto(
-    base::trace_event::TracedValue* value) const {
+void FrameData::AsValueInto(base::trace_event::TracedValue* value) const {
   value->SetBoolean("has_no_damage", has_no_damage);
 
   // Quad data can be quite large, so only dump render passes if we select
   // cc.debug.quads.
   bool quads_enabled;
   TRACE_EVENT_CATEGORY_GROUP_ENABLED(
       TRACE_DISABLED_BY_DEFAULT("cc.debug.quads"), &quads_enabled);
   if (quads_enabled) {
     value->BeginArray("render_passes");
     for (size_t i = 0; i < render_passes.size(); ++i) {
       value->BeginDictionary();
       render_passes[i]->AsValueInto(value);
       value->EndDictionary();
     }
     value->EndArray();
   }
 }
 
-void LayerTreeHostImpl::FrameData::AppendRenderPass(
-    scoped_ptr<RenderPass> render_pass) {
+void FrameData::AppendRenderPass(scoped_ptr<RenderPass> render_pass) {
   render_passes_by_id[render_pass->id] = render_pass.get();
   render_passes.push_back(render_pass.Pass());
 }
 
 DrawMode LayerTreeHostImpl::GetDrawMode() const {
   if (resourceless_software_draw_) {
     return DRAW_MODE_RESOURCELESS_SOFTWARE;
   } else if (output_surface_->context_provider()) {
     return DRAW_MODE_HARDWARE;
   } else {
@@ skipping 358 matching lines @@
 
 void LayerTreeHostImpl::DidAnimateScrollOffset() {
   client_->SetNeedsCommitOnImplThread();
   client_->RenewTreePriority();
 }
 
 void LayerTreeHostImpl::SetViewportDamage(const gfx::Rect& damage_rect) {
   viewport_damage_rect_.Union(damage_rect);
 }
 
-static inline RenderPass* FindRenderPassById(
-    RenderPassId render_pass_id,
-    const LayerTreeHostImpl::FrameData& frame) {
+static inline RenderPass* FindRenderPassById(RenderPassId render_pass_id,
+                                             const FrameData& frame) {
   RenderPassIdHashMap::const_iterator it =
       frame.render_passes_by_id.find(render_pass_id);
   return it != frame.render_passes_by_id.end() ? it->second : NULL;
 }
 
 static void RemoveRenderPassesRecursive(RenderPassId remove_render_pass_id,
-                                        LayerTreeHostImpl::FrameData* frame) {
+                                        FrameData* frame) {
   RenderPass* remove_render_pass =
       FindRenderPassById(remove_render_pass_id, *frame);
   // The pass was already removed by another quad - probably the original, and
   // we are the replica.
   if (!remove_render_pass)
     return;
   RenderPassList& render_passes = frame->render_passes;
   RenderPassList::iterator to_remove = std::find(render_passes.begin(),
                                                  render_passes.end(),
                                                  remove_render_pass);
@@ skipping 548 matching lines @@
           pending_tree_->root_layer(),
           [](LayerImpl* layer) { layer->DidBeginTracing(); });
     }
     LayerTreeHostCommon::CallFunctionForSubtree(
         active_tree_->root_layer(),
         [](LayerImpl* layer) { layer->DidBeginTracing(); });
   }
 
   {
     TRACE_EVENT0("cc", "DrawLayers.FrameViewerTracing");
     TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(

[danakj, 2015/03/16 19:06:49]

Did you mean to call TraceLayerTreeSnapshot here?

        TRACE_DISABLED_BY_DEFAULT("cc.debug") ","
        TRACE_DISABLED_BY_DEFAULT("cc.debug.quads") ","
        TRACE_DISABLED_BY_DEFAULT("devtools.timeline.layers"),
        "cc::LayerTreeHostImpl",
        id_,
        AsValueWithFrame(frame));
   }
 
   const DrawMode draw_mode = GetDrawMode();
 
@@ skipping 81 matching lines @@
   // We would not have any content to draw until the pending tree is activated.
   // Prevent the active tree from drawing until activation.
   SetRequiresHighResToDraw();
 }
 
 const RendererCapabilitiesImpl&
 LayerTreeHostImpl::GetRendererCapabilities() const {
   return renderer_->Capabilities();
 }
 
-bool LayerTreeHostImpl::SwapBuffers(const LayerTreeHostImpl::FrameData& frame) {
+bool LayerTreeHostImpl::SwapBuffers(const FrameData& frame) {
   ResetRequiresHighResToDraw();
   if (frame.has_no_damage) {
     active_tree()->BreakSwapPromises(SwapPromise::SWAP_FAILS);
     return false;
   }
   CompositorFrameMetadata metadata = MakeCompositorFrameMetadata();
   active_tree()->FinishSwapPromises(&metadata);
   for (auto& latency : metadata.latency_info) {
     TRACE_EVENT_FLOW_STEP0(
         "input,benchmark",
@@ skipping 1827 matching lines @@
   new_target.SetToMin(layer_impl->MaxScrollOffset());
 
   curve->UpdateTarget(
       animation->TrimTimeToCurrentIteration(CurrentBeginFrameArgs().frame_time)
           .InSecondsF(),
       new_target);
 
   return true;
 }
 }  // namespace cc