not for commit/review (thread cost tracker)

cc/resources/tile_manager.cc

 // Copyright 2012 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/resources/tile_manager.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 
 #include "base/bind.h"
 #include "base/debug/trace_event_argument.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #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"
 #include "cc/resources/tile_task_runner.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 
 namespace cc {
 namespace {
 
 // Flag to indicate whether we should try and detect that
 // a tile is of solid color.
 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),
         contents_scale_(contents_scale),
         tile_resolution_(tile_resolution),
         layer_id_(layer_id),
         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:
   void RunOnWorkerThread() override {
     TRACE_EVENT0("cc", "RasterizerTaskImpl::RunOnWorkerThread");
 
     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:
   void ScheduleOnOriginThread(TileTaskClient* client) override {
     DCHECK(!raster_buffer_);
     raster_buffer_ = client->AcquireBufferForRaster(resource());
   }
   void CompleteOnOriginThread(TileTaskClient* client) override {
     client->ReleaseBufferForRaster(raster_buffer_.Pass());
   }
   void RunReplyOnOriginThread() override {
     DCHECK(!raster_buffer_);
-    reply_.Run(analysis_, !HasFinishedRunning());
+    reply_.Run(analysis_, !HasFinishedRunning(), cost_tracker_probe_.Pass());
   }
 
  protected:
   ~RasterTaskImpl() override { DCHECK(!raster_buffer_); }
 
  private:
   void Analyze(const RasterSource* raster_source) {
     frame_viewer_instrumentation::ScopedAnalyzeTask analyze_task(
         tile_id_, tile_resolution_, source_frame_number_, layer_id_);
 
@@ skipping 22 matching lines @@
 
   RasterSource::SolidColorAnalysis analysis_;
   scoped_refptr<RasterSource> raster_source_;
   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_;
+  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);
 };
 
 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 {}
 
  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);
 };
 
 const char* TaskSetName(TaskSet task_set) {
   switch (task_set) {
     case TileManager::ALL:
       return "ALL";
     case TileManager::REQUIRED_FOR_ACTIVATION:
       return "REQUIRED_FOR_ACTIVATION";
@@ skipping 18 matching lines @@
   state->SetInteger("canceled_count", stats.canceled_count);
   return state;
 }
 
 // static
 scoped_ptr<TileManager> TileManager::Create(
     TileManagerClient* client,
     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(
     TileManagerClient* client,
     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),
       tile_task_runner_(tile_task_runner),
       scheduled_raster_task_limit_(scheduled_raster_task_limit),
       all_tiles_that_need_to_be_rasterized_are_scheduled_(true),
       did_check_for_completed_tasks_since_last_schedule_tasks_(true),
       did_oom_on_last_assign_(false),
       ready_to_activate_check_notifier_(
           task_runner_.get(),
           base::Bind(&TileManager::CheckIfReadyToActivate,
                      base::Unretained(this))),
       ready_to_draw_check_notifier_(
           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);
 }
 
 TileManager::~TileManager() {
   // Reset global state and manage. This should cause
   // our memory usage to drop to zero.
   global_state_ = GlobalStateThatImpactsTilePriority();
 
   TileTaskQueue empty;
   tile_task_runner_->ScheduleTasks(&empty);
@@ skipping 456 matching lines @@
   // been called.
   orphan_raster_tasks_.clear();
 
   did_check_for_completed_tasks_since_last_schedule_tasks_ = false;
 }
 
 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))));
 }
 
 scoped_refptr<RasterTask> TileManager::CreateRasterTask(Tile* tile) {
   ManagedTileState& mts = tile->managed_state();
 
   scoped_ptr<ScopedResource> resource =
       resource_pool_->AcquireResource(tile->size());
   const ScopedResource* const_resource = resource.get();
 
@@ skipping 13 matching lines @@
       continue;
     }
 
     // Create and append new image decode task for this pixel ref.
     scoped_refptr<ImageDecodeTask> decode_task =
         CreateImageDecodeTask(tile, pixel_ref);
     decode_tasks.push_back(decode_task);
     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));
+  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) {
+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)
     return;
 
   LayerPixelRefTaskMap::iterator layer_it = image_decode_tasks_.find(layer_id);
   if (layer_it == image_decode_tasks_.end())
     return;
 
   PixelRefTaskMap& pixel_ref_tasks = layer_it->second;
   PixelRefTaskMap::iterator task_it =
       pixel_ref_tasks.find(pixel_ref->getGenerationID());
 
   if (task_it != pixel_ref_tasks.end())
     pixel_ref_tasks.erase(task_it);
 }
 
 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];
   ManagedTileState& mts = tile->managed_state();
   DCHECK(mts.raster_task.get());
   orphan_raster_tasks_.push_back(mts.raster_task);
   mts.raster_task = NULL;
 
   if (was_canceled) {
     ++update_visible_tiles_stats_.canceled_count;
@@ skipping 139 matching lines @@
   result -= other;
   return result;
 }
 
 bool TileManager::MemoryUsage::Exceeds(const MemoryUsage& limit) const {
   return memory_bytes_ > limit.memory_bytes_ ||
          resource_count_ > limit.resource_count_;
 }
 
 }  // namespace cc