not for commit/review (thread cost tracker)

cc/resources/tile_manager.cc

Index: cc/resources/tile_manager.cc
diff --git a/cc/resources/tile_manager.cc b/cc/resources/tile_manager.cc
index 1391daf7bb62e97d23722f9ef9de5ef7b8078716..610e9967549ec0a8826eeef3eb6b42264228940c 100644
--- a/cc/resources/tile_manager.cc
+++ b/cc/resources/tile_manager.cc
@@ -16,6 +16,7 @@
 #include "cc/debug/devtools_instrumentation.h"
 #include "cc/debug/frame_viewer_instrumentation.h"
 #include "cc/debug/traced_value.h"
+#include "cc/debug/worker_thread_cost_tracker.h"
 #include "cc/layers/picture_layer_impl.h"
 #include "cc/resources/raster_buffer.h"
 #include "cc/resources/tile.h"
@@ -31,19 +32,21 @@ const bool kUseColorEstimator = true;
 
 class RasterTaskImpl : public RasterTask {
  public:
-  RasterTaskImpl(
-      const Resource* resource,
-      RasterSource* raster_source,
-      const gfx::Rect& content_rect,
-      float contents_scale,
-      TileResolution tile_resolution,
-      int layer_id,
-      const void* tile_id,
-      int source_frame_number,
-      bool analyze_picture,
-      const base::Callback<void(const RasterSource::SolidColorAnalysis&, bool)>&
-          reply,
-      ImageDecodeTask::Vector* dependencies)
+  RasterTaskImpl(const Resource* resource,
+                 RasterSource* raster_source,
+                 const gfx::Rect& content_rect,
+                 float contents_scale,
+                 TileResolution tile_resolution,
+                 int layer_id,
+                 const void* tile_id,
+                 int source_frame_number,
+                 bool analyze_picture,
+                 scoped_ptr<WorkerThreadCostTracker::Probe> cost_tracker_probe,
+                 const base::Callback<
+                     void(const RasterSource::SolidColorAnalysis&,
+                          bool,
+                          scoped_ptr<WorkerThreadCostTracker::Probe>)>& reply,
+                 ImageDecodeTask::Vector* dependencies)
       : RasterTask(resource, dependencies),
         raster_source_(raster_source),
         content_rect_(content_rect),
@@ -53,6 +56,7 @@ class RasterTaskImpl : public RasterTask {
         tile_id_(tile_id),
         source_frame_number_(source_frame_number),
         analyze_picture_(analyze_picture),
+        cost_tracker_probe_(cost_tracker_probe.Pass()),
         reply_(reply) {}
 
   // Overridden from Task:
@@ -62,13 +66,17 @@ class RasterTaskImpl : public RasterTask {
     DCHECK(raster_source_.get());
     DCHECK(raster_buffer_);
 
+    cost_tracker_probe_->Start(source_frame_number_);
     if (analyze_picture_) {
       Analyze(raster_source_.get());
-      if (analysis_.is_solid_color)
+      if (analysis_.is_solid_color) {
+        cost_tracker_probe_->Stop();
         return;
+      }
     }
 
     Raster(raster_source_.get());
+    cost_tracker_probe_->Stop();
   }
 
   // Overridden from TileTask:
@@ -81,7 +89,7 @@ class RasterTaskImpl : public RasterTask {
   }
   void RunReplyOnOriginThread() override {
     DCHECK(!raster_buffer_);
-    reply_.Run(analysis_, !HasFinishedRunning());
+    reply_.Run(analysis_, !HasFinishedRunning(), cost_tracker_probe_.Pass());
   }
 
  protected:
@@ -124,8 +132,10 @@ class RasterTaskImpl : public RasterTask {
   const void* tile_id_;
   int source_frame_number_;
   bool analyze_picture_;
-  const base::Callback<void(const RasterSource::SolidColorAnalysis&, bool)>
-      reply_;
+  scoped_ptr<WorkerThreadCostTracker::Probe> cost_tracker_probe_;
+  const base::Callback<void(const RasterSource::SolidColorAnalysis&,
+                            bool,
+                            scoped_ptr<WorkerThreadCostTracker::Probe>)> reply_;
   scoped_ptr<RasterBuffer> raster_buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(RasterTaskImpl);
@@ -133,28 +143,39 @@ class RasterTaskImpl : public RasterTask {
 
 class ImageDecodeTaskImpl : public ImageDecodeTask {
  public:
-  ImageDecodeTaskImpl(SkPixelRef* pixel_ref,
-                      int layer_id,
-                      const base::Callback<void(bool was_canceled)>& reply)
+  ImageDecodeTaskImpl(
+      SkPixelRef* pixel_ref,
+      int layer_id,
+      int source_frame_number,
+      scoped_ptr<WorkerThreadCostTracker::Probe> cost_tracker_probe,
+      const base::Callback<
+          void(bool was_canceled,
+               scoped_ptr<WorkerThreadCostTracker::Probe> probe)>& reply)
       : pixel_ref_(skia::SharePtr(pixel_ref)),
         layer_id_(layer_id),
+        source_frame_number_(source_frame_number),
+        cost_tracker_probe_(cost_tracker_probe.Pass()),
         reply_(reply) {}
 
   // Overridden from Task:
   void RunOnWorkerThread() override {
     TRACE_EVENT0("cc", "ImageDecodeTaskImpl::RunOnWorkerThread");
 
+    cost_tracker_probe_->Start(source_frame_number_);
     devtools_instrumentation::ScopedImageDecodeTask image_decode_task(
         pixel_ref_.get());
     // This will cause the image referred to by pixel ref to be decoded.
     pixel_ref_->lockPixels();
     pixel_ref_->unlockPixels();
+    cost_tracker_probe_->Stop();
   }
 
   // Overridden from TileTask:
   void ScheduleOnOriginThread(TileTaskClient* client) override {}
   void CompleteOnOriginThread(TileTaskClient* client) override {}
-  void RunReplyOnOriginThread() override { reply_.Run(!HasFinishedRunning()); }
+  void RunReplyOnOriginThread() override {
+    reply_.Run(!HasFinishedRunning(), cost_tracker_probe_.Pass());
+  }
 
  protected:
   ~ImageDecodeTaskImpl() override {}
@@ -162,7 +183,10 @@ class ImageDecodeTaskImpl : public ImageDecodeTask {
  private:
   skia::RefPtr<SkPixelRef> pixel_ref_;
   int layer_id_;
-  const base::Callback<void(bool was_canceled)> reply_;
+  int source_frame_number_;
+  scoped_ptr<WorkerThreadCostTracker::Probe> cost_tracker_probe_;
+  const base::Callback<void(bool was_canceled,
+                            scoped_ptr<WorkerThreadCostTracker::Probe>)> reply_;
 
   DISALLOW_COPY_AND_ASSIGN(ImageDecodeTaskImpl);
 };
@@ -201,10 +225,11 @@ scoped_ptr<TileManager> TileManager::Create(
     base::SequencedTaskRunner* task_runner,
     ResourcePool* resource_pool,
     TileTaskRunner* tile_task_runner,
-    size_t scheduled_raster_task_limit) {
-  return make_scoped_ptr(new TileManager(client, task_runner, resource_pool,
-                                         tile_task_runner,
-                                         scheduled_raster_task_limit));
+    size_t scheduled_raster_task_limit,
+    WorkerThreadCostTracker* worker_thread_cost_tracker) {
+  return make_scoped_ptr(
+      new TileManager(client, task_runner, resource_pool, tile_task_runner,
+                      scheduled_raster_task_limit, worker_thread_cost_tracker));
 }
 
 TileManager::TileManager(
@@ -212,7 +237,8 @@ TileManager::TileManager(
     const scoped_refptr<base::SequencedTaskRunner>& task_runner,
     ResourcePool* resource_pool,
     TileTaskRunner* tile_task_runner,
-    size_t scheduled_raster_task_limit)
+    size_t scheduled_raster_task_limit,
+    WorkerThreadCostTracker* worker_thread_cost_tracker)
     : client_(client),
       task_runner_(task_runner),
       resource_pool_(resource_pool),
@@ -229,7 +255,8 @@ TileManager::TileManager(
           task_runner_.get(),
           base::Bind(&TileManager::CheckIfReadyToDraw, base::Unretained(this))),
       did_notify_ready_to_activate_(false),
-      did_notify_ready_to_draw_(false) {
+      did_notify_ready_to_draw_(false),
+      worker_thread_cost_tracker_(worker_thread_cost_tracker) {
   tile_task_runner_->SetClient(this);
 }
 
@@ -706,11 +733,10 @@ scoped_refptr<ImageDecodeTask> TileManager::CreateImageDecodeTask(
     Tile* tile,
     SkPixelRef* pixel_ref) {
   return make_scoped_refptr(new ImageDecodeTaskImpl(
-      pixel_ref,
-      tile->layer_id(),
+      pixel_ref, tile->layer_id(), tile->source_frame_number(),
+      worker_thread_cost_tracker_->CreateProbe(),
       base::Bind(&TileManager::OnImageDecodeTaskCompleted,
-                 base::Unretained(this),
-                 tile->layer_id(),
+                 base::Unretained(this), tile->layer_id(),
                  base::Unretained(pixel_ref))));
 }
 
@@ -744,26 +770,21 @@ scoped_refptr<RasterTask> TileManager::CreateRasterTask(Tile* tile) {
     existing_pixel_refs[id] = decode_task;
   }
 
-  return make_scoped_refptr(
-      new RasterTaskImpl(const_resource,
-                         tile->raster_source(),
-                         tile->content_rect(),
-                         tile->contents_scale(),
-                         mts.resolution,
-                         tile->layer_id(),
-                         static_cast<const void*>(tile),
-                         tile->source_frame_number(),
-                         tile->use_picture_analysis(),
-                         base::Bind(&TileManager::OnRasterTaskCompleted,
-                                    base::Unretained(this),
-                                    tile->id(),
-                                    base::Passed(&resource)),
-                         &decode_tasks));
-}
-
-void TileManager::OnImageDecodeTaskCompleted(int layer_id,
-                                             SkPixelRef* pixel_ref,
-                                             bool was_canceled) {
+  return make_scoped_refptr(new RasterTaskImpl(
+      const_resource, tile->raster_source(), tile->content_rect(),
+      tile->contents_scale(), mts.resolution, tile->layer_id(),
+      static_cast<const void*>(tile), tile->source_frame_number(),
+      tile->use_picture_analysis(), worker_thread_cost_tracker_->CreateProbe(),
+      base::Bind(&TileManager::OnRasterTaskCompleted, base::Unretained(this),
+                 tile->id(), base::Passed(&resource)),
+      &decode_tasks));
+}
+
+void TileManager::OnImageDecodeTaskCompleted(
+    int layer_id,
+    SkPixelRef* pixel_ref,
+    bool was_canceled,
+    scoped_ptr<WorkerThreadCostTracker::Probe> cost_tracker_probe) {
   // If the task was canceled, we need to clean it up
   // from |image_decode_tasks_|.
   if (!was_canceled)
@@ -785,7 +806,8 @@ void TileManager::OnRasterTaskCompleted(
     Tile::Id tile_id,
     scoped_ptr<ScopedResource> resource,
     const RasterSource::SolidColorAnalysis& analysis,
-    bool was_canceled) {
+    bool was_canceled,
+    scoped_ptr<WorkerThreadCostTracker::Probe> cost_tracker_probe) {
   DCHECK(tiles_.find(tile_id) != tiles_.end());
 
   Tile* tile = tiles_[tile_id];