cc: Add main frame timing info to frame timing 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 264 matching lines @@
   DestroyTileManager();
 }
 
 void LayerTreeHostImpl::BeginMainFrameAborted(CommitEarlyOutReason reason) {
   // If the begin frame data was handled, then scroll and scale set was applied
   // by the main thread, so the active tree needs to be updated as if these sent
   // values were applied and committed.
   if (CommitEarlyOutHandledCommit(reason)) {
     active_tree_->ApplySentScrollAndScaleDeltasFromAbortedCommit();
     active_tree_->ResetContentsTexturesPurged();
+    RecordMainFrameTiming();

[mithro-old, 2015/03/20 02:17:54]

The fact that this method is being called in two places makes me think it is in
the wrong place.

[vmpstr, 2015/03/20 18:47:26]

Whether this is done in the scheduler or in lthi, I'm not sure where a single
place is that would capture both of these cases:

1. We aborted a commit due to no changes in the trees and properties
2. We processed the commit, rasterized the sync tree, and activated it.

Please let me know if you had a better place in mind.

[mithro-old, 2015/03/23 00:15:08]

If we aborted the commit, should we be generating a frame time value anyway? We
effectively didn't actually generate a main frame or call raf.
I was pondering the NotifyReadyToCommit / BeginMainFrameAborted methods   in the
scheduler for main frame times and the OnBeginImplFrameDeadline for composite
frame times.

[vmpstr, 2015/03/23 20:26:43]

This happens after apply scroll deltas, animate layers, layout, etc. I think
it's just a bit of a misnomer to call this an abort, since we did everything we
would normally do short of creating a pending tree and later activating it. That
is, we successfully finished the frame and we know that we don't have to do
extra work. I'm counting that as a frame that happened... What do you think?

[mithro-old, 2015/03/24 07:37:42]

Despite having worked in this area for a while, I'm always feel like I don't
really understand what is going on most of the time :/

Taking a step back and looking at the specification;

 * PerformanceRenderTiming captures the work performed by the renderer to
process the frame: DOM modification, JavaScript execution, CSS calculation, and
similar activities.

 * PerformanceCompositeTiming captures events performed by the compositor to
place rendered content onto the screen.

I think this maps the following;

 * Create a PerformanceRenderTiming any time we generate new "content" which
maps to any work as part of the "BeginMainFrame" to get stuff ready for the impl
thread including the commit and activate stages.

 * Create a PerformanceCompositeTiming any time we are going to put something
onto the screen (IE Draw and Swap) which maps to any work as part of the
BeginImplFrameDeadline.

Which is why I'm pondering this could be cleaner up at the scheduling level.

On 2015/03/23 20:26:43, vmpstr wrote:
To be exact in your case only the CommitEarlyOutReason::FINISHED_NO_UPDATES
reason matters (which is the only one CommitEarlyOutHandledCommit returns true
on).

Looking at that pathway in ThreadProxy::BeginMainFrame there is the following
comment;
    // Although the commit is internally aborted, this is because it has been
    // detected to be a no-op.  From the perspective of an embedder, this commit
    // went through, and input should no longer be throttled, etc.

But you are correct that this happens *after* all the stuff you mentioned. From
what I can tell, by "no-op" it actually means "there were no evicted UI
resources".

The code also does a "BreakSwapPromises" however looking at the scheduler, there
doesn't appear to be an explicit guarantee for or against a Draw happening after
an aborted commit. 
Yeah, there are lots of things here which could be better named. Makes it even
more important to get new things named correctly so things trend in the right
direction.

   }
 }
 
 void LayerTreeHostImpl::BeginCommit() {
   TRACE_EVENT0("cc", "LayerTreeHostImpl::BeginCommit");
 
   // Ensure all textures are returned so partial texture updates can happen
   // during the commit. Impl-side-painting doesn't upload during commits, so
   // is unaffected.
   if (!settings_.impl_side_painting && output_surface_)
@@ skipping 1563 matching lines @@
 
   scoped_ptr<PendingPageScaleAnimation> pending_page_scale_animation =
       active_tree_->TakePendingPageScaleAnimation();
   if (pending_page_scale_animation) {
     StartPageScaleAnimation(
         pending_page_scale_animation->target_offset,
         pending_page_scale_animation->use_anchor,
         pending_page_scale_animation->scale,
         pending_page_scale_animation->duration);
   }
+  RecordMainFrameTiming();
 }
 
 void LayerTreeHostImpl::SetVisible(bool visible) {
   DCHECK(proxy_->IsImplThread());
 
   if (visible_ == visible)
     return;
   visible_ = visible;
   DidVisibilityChange(this, visible_);
   EnforceManagedMemoryPolicy(ActualManagedMemoryPolicy());
@@ skipping 221 matching lines @@
   *resource_pool = ResourcePool::Create(
       resource_provider_.get(), GL_TEXTURE_2D);
 
   *tile_task_worker_pool = PixelBufferTileTaskWorkerPool::Create(
       task_runner, TileTaskWorkerPool::GetTaskGraphRunner(), context_provider,
       resource_provider_.get(),
       GetMaxTransferBufferUsageBytes(context_provider->ContextCapabilities(),
                                      settings_.renderer_settings.refresh_rate));
 }
 
+void LayerTreeHostImpl::SetCurrentRequestAnimationFrameTime(
+    base::TimeTicks frame_time) {
+  request_animation_frame_time_ = frame_time;
+}
+
+void LayerTreeHostImpl::RecordMainFrameTiming() {
+  std::vector<int64_t> request_ids;
+  active_tree_->GatherFrameTimingRequestIds(&request_ids);
+  if (request_ids.empty())
+    return;
+
+  base::TimeTicks end_time =
+      client_->GetNextPredictedRequestAnimationFrameTime();
+  frame_timing_tracker_->SaveMainFrameTimeStamps(
+      request_ids, request_animation_frame_time_, end_time,
+      active_tree_->source_frame_number());
+}
+
 void LayerTreeHostImpl::DestroyTileManager() {
   tile_manager_ = nullptr;
   resource_pool_ = nullptr;
   staging_resource_pool_ = nullptr;
   tile_task_worker_pool_ = nullptr;
   rasterizer_ = nullptr;
   single_thread_synchronous_task_graph_runner_ = nullptr;
 }
 
 bool LayerTreeHostImpl::IsSynchronousSingleThreaded() const {
@@ skipping 1351 matching lines @@
   new_target.SetToMin(layer_impl->MaxScrollOffset());
 
   curve->UpdateTarget(
       animation->TrimTimeToCurrentIteration(CurrentBeginFrameArgs().frame_time)
           .InSecondsF(),
       new_target);
 
   return true;
 }
 }  // namespace cc