cc: Record frame timing composite events in the tracker.

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 211 matching lines @@
       device_scale_factor_(1.f),
       resourceless_software_draw_(false),
       begin_impl_frame_interval_(BeginFrameArgs::DefaultInterval()),
       animation_registrar_(AnimationRegistrar::Create()),
       rendering_stats_instrumentation_(rendering_stats_instrumentation),
       micro_benchmark_controller_(this),
       shared_bitmap_manager_(shared_bitmap_manager),
       gpu_memory_buffer_manager_(gpu_memory_buffer_manager),
       id_(id),
       requires_high_res_to_draw_(false),
-      required_for_draw_tile_is_top_of_raster_queue_(false) {
+      required_for_draw_tile_is_top_of_raster_queue_(false),
+      frame_timing_tracker_(FrameTimingTracker::Create()) {
   DCHECK(proxy_->IsImplThread());
   DidVisibilityChange(this, visible_);
   animation_registrar_->set_supports_scroll_animations(
       proxy_->SupportsImplScrolling());
 
   SetDebugState(settings.initial_debug_state);
 
   // LTHI always has an active tree.
   active_tree_ = LayerTreeImpl::create(this, new SyncedProperty<ScaleGroup>(),
                                        new SyncedElasticOverscroll);
@@ skipping 551 matching lines @@
 
             contributing_render_pass_id =
                 it->NextContributingRenderPassId(contributing_render_pass_id);
           }
         }
 
         AppendQuadsForLayer(target_render_pass,
                             *it,
                             occlusion_tracker,
                             &append_quads_data);
+
+        // For layers that represent themselves, add composite frame timing
+        // requests if the visible rect intersects the requested rect.
+        const std::vector<FrameTimingRequest>& frame_timing_requests =
+            it->frame_timing_requests();
+        for (const auto& request : frame_timing_requests) {

[danakj, 2015/02/02 21:19:06]

you could just : it->frame_timing_requests())  ? and avoid the temp var?

[vmpstr, 2015/02/02 22:32:05]

Done.

+          if (request.rect().Intersects(it->visible_content_rect())) {

[danakj, 2015/02/02 21:19:06]

you need to map this VCR to layer space

[vmpstr, 2015/02/02 22:32:05]

Done.

+            current_composite_events_.push_back(
+                FrameTimingTracker::FrameAndRectIds(
+                    active_tree_->source_frame_number(), request.id()));
+          }
+        }
       }
 
       ++layers_drawn;
     }
 
     rendering_stats_instrumentation_->AddVisibleContentArea(
         append_quads_data.visible_content_area);
     rendering_stats_instrumentation_->AddApproximatedVisibleContentArea(
         append_quads_data.approximated_visible_content_area);
 
@@ skipping 228 matching lines @@
     viewport_damage_rect_ = gfx::Rect();
 
     active_tree_->root_layer()->render_surface()->damage_tracker()->
         AddDamageNextUpdate(device_viewport_damage_rect);
   }
 
   DrawResult draw_result = CalculateRenderPasses(frame);
   if (draw_result != DRAW_SUCCESS) {
     DCHECK(!output_surface_->capabilities()
                .draw_and_swap_full_viewport_every_frame);
+    current_composite_events_.clear();

[danakj, 2015/02/02 21:19:06]

if you make this a member of the |frame| then you don't have to worry about
clearing it after each frame?

[vmpstr, 2015/02/02 22:32:05]

Done.

     return draw_result;
   }
 
   // If we return DRAW_SUCCESS, then we expect DrawLayers() to be called before
   // this function is called again.
   return draw_result;
 }
 
 void LayerTreeHostImpl::EvictTexturesForTesting() {
   EnforceManagedMemoryPolicy(ManagedMemoryPolicy(0));
@@ skipping 368 matching lines @@
 
 static void LayerTreeHostImplDidBeginTracingCallback(LayerImpl* layer) {
   layer->DidBeginTracing();
 }
 
 void LayerTreeHostImpl::DrawLayers(FrameData* frame,
                                    base::TimeTicks frame_begin_time) {
   TRACE_EVENT0("cc", "LayerTreeHostImpl::DrawLayers");
   DCHECK(CanDraw());
 
+  if (!current_composite_events_.empty()) {
+    frame_timing_tracker_->SaveTimeStamps(base::TimeTicks::Now(),

[danakj, 2015/02/02 21:19:06]

should we use the frame time instead of now?

[vmpstr, 2015/02/02 22:32:05]

Done. I think that works. According to the spec, we want the "time of the
event", the event being the composite event, which I think the impl frame time
captures.

+                                          current_composite_events_);
+    current_composite_events_.clear();
+  }
+
   if (frame->has_no_damage) {
     TRACE_EVENT_INSTANT0("cc", "EarlyOut_NoDamage", TRACE_EVENT_SCOPE_THREAD);
     DCHECK(!output_surface_->capabilities()
                .draw_and_swap_full_viewport_every_frame);
     return;
   }
 
   DCHECK(!frame->render_passes.empty());
 
   fps_counter_->SaveTimeStamp(frame_begin_time,
@@ skipping 2008 matching lines @@
 }
 
 void LayerTreeHostImpl::UnregisterPictureLayerImpl(PictureLayerImpl* layer) {
   std::vector<PictureLayerImpl*>::iterator it =
       std::find(picture_layers_.begin(), picture_layers_.end(), layer);
   DCHECK(it != picture_layers_.end());
   picture_layers_.erase(it);
 }
 
 }  // namespace cc