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 287 matching lines @@
 
   if (UsePendingTreeForSync())
     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.
     sync_tree()->UpdateDrawProperties();
     // Start working on newly created tiles immediately if needed.
     if (tile_manager_ && tile_priorities_dirty_)
       PrepareTiles();
     else
       NotifyReadyToActivate();
@@ skipping 1475 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::TimeDelta frame_duration =
+      client_->GetNextBeginImplFrameTimeIfRequested() - main_frame_time_;

[enne (OOO), 2015/02/12 23:41:07]

So for SingleThreadProxy this will always be negative?

[vmpstr, 2015/03/03 18:56:46]

I changed this to use the same value. As far as I know, this is only used in
browser compositors, where we wouldn't expect to see these requests, but it
should work the same.

[enne (OOO), 2015/03/06 21:27:55]

Oh.  I figured that requests were coming from Javascript, so were in the
renderer?  I guess then I don't quite understand what the goals here are.

+  frame_timing_tracker_->SaveMainFrameTimeStamps(
+      request_ids, main_frame_time_, frame_duration,
+      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::UsePendingTreeForSync() const {
@@ skipping 1398 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