not for commit/review (thread cost 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 284 matching lines @@
     CreatePendingTree();
 }
 
 void LayerTreeHostImpl::CommitComplete() {
   TRACE_EVENT0("cc", "LayerTreeHostImpl::CommitComplete");
 
   if (pending_tree_)
     pending_tree_->ApplyScrollDeltasSinceBeginMainFrame();
   sync_tree()->set_needs_update_draw_properties();
 
+  frame_timing_cost_tracker_.ResetCost();
+  frame_timing_cost_tracker_.Start(sync_tree()->source_frame_number());
   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 1516 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);
   }
+
+  // frame_timing_cost_tracker_.GetTotalCost().InSecondsF());
 }
 
 void LayerTreeHostImpl::SetVisible(bool visible) {
   DCHECK(proxy_->IsImplThread());
 
   if (visible_ == visible)
     return;
   visible_ = visible;
   DidVisibilityChange(this, visible_);
   EnforceManagedMemoryPolicy(ActualManagedMemoryPolicy());
@@ skipping 108 matching lines @@
 
   base::SingleThreadTaskRunner* task_runner =
       proxy_->HasImplThread() ? proxy_->ImplThreadTaskRunner()
                               : proxy_->MainThreadTaskRunner();
   DCHECK(task_runner);
   size_t scheduled_raster_task_limit =
       IsSynchronousSingleThreaded() ? std::numeric_limits<size_t>::max()
                                     : settings_.scheduled_raster_task_limit;
   tile_manager_ = TileManager::Create(
       this, task_runner, resource_pool_.get(),
-      tile_task_worker_pool_->AsTileTaskRunner(), scheduled_raster_task_limit);
+      tile_task_worker_pool_->AsTileTaskRunner(), scheduled_raster_task_limit,
+      frame_timing_cost_tracker_.GetWorkerThreadCostTracker());
 
   UpdateTileManagerMemoryPolicy(ActualManagedMemoryPolicy());
 }
 
 void LayerTreeHostImpl::CreateResourceAndTileTaskWorkerPool(
     scoped_ptr<TileTaskWorkerPool>* tile_task_worker_pool,
     scoped_ptr<ResourcePool>* resource_pool,
     scoped_ptr<ResourcePool>* staging_resource_pool) {
   base::SingleThreadTaskRunner* task_runner =
       proxy_->HasImplThread() ? proxy_->ImplThreadTaskRunner()
@@ skipping 1497 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