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 265 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();
   }
 }
 
 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_)
     output_surface_->ForceReclaimResources();
 
   if (settings_.impl_side_painting && !proxy_->CommitToActiveTree())
     CreatePendingTree();
 }
 
 void LayerTreeHostImpl::CommitComplete() {
   TRACE_EVENT0("cc", "LayerTreeHostImpl::CommitComplete");
 
   sync_tree()->set_needs_update_draw_properties();
 
+  // If we don't have a pending tree, it means we've committed directly to the
+  // active tree. In that case, record frame timing information immediately.
+  if (!pending_tree_)
+    RecordMainFrameTiming();
+
   if (settings_.impl_side_painting) {
     // Impl-side painting needs an update immediately post-commit to have the
     // opportunity to create tilings.  Other paths can call UpdateDrawProperties
     // more lazily when needed prior to drawing.  Because invalidations may
     // be coming from the main thread, it's safe to do an update for lcd text
     // at this point and see if lcd text needs to be disabled on any layers.
     bool update_lcd_text = true;
     sync_tree()->UpdateDrawProperties(update_lcd_text);
     // Start working on newly created tiles immediately if needed.
     if (tile_manager_ && tile_priorities_dirty_)
@@ skipping 1474 matching lines @@
     // Now that we've synced everything from the pending tree to the active
     // tree, rename the pending tree the recycle tree so we can reuse it on the
     // next sync.
     DCHECK(!recycle_tree_);
     pending_tree_.swap(recycle_tree_);
 
     active_tree_->SetRootLayerScrollOffsetDelegate(
         root_layer_scroll_offset_delegate_);
 
     UpdateViewportContainerSizes();
+
+    // If we had a pending tree, now is when we should record main frame timing
+    // information.
+    RecordMainFrameTiming();
   } else {
     active_tree_->ProcessUIResourceRequestQueue();
   }
 
   active_tree_->DidBecomeActive();
   ActivateAnimations();
   if (settings_.impl_side_painting) {
     client_->RenewTreePriority();
     // If we have any picture layers, then by activating we also modified tile
     // priorities.
@@ skipping 254 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::SetBeginMainFrameTime(base::TimeTicks frame_time) {
+  main_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_->GetNextBeginImplFrameTimeIfRequested();

[enne (OOO), 2015/03/06 00:00:57]

Maybe I just don't understand the spec, but what is "end time" supposed to
represent? I had the same question about duration.  It's just an estimate of how
long this particular thing will be shown?

+  frame_timing_tracker_->SaveMainFrameTimeStamps(
+      request_ids, main_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 1377 matching lines @@
     (*it)->OnSetNeedsRedrawOnImpl();
 }
 
 void LayerTreeHostImpl::NotifySwapPromiseMonitorsOfForwardingToMainThread() {
   std::set<SwapPromiseMonitor*>::iterator it = swap_promise_monitor_.begin();
   for (; it != swap_promise_monitor_.end(); it++)
     (*it)->OnForwardScrollUpdateToMainThreadOnImpl();
 }
 
 }  // namespace cc