Add cheapness predictor success histogram

cc/tile_manager.cc

Index: cc/tile_manager.cc
diff --git a/cc/tile_manager.cc b/cc/tile_manager.cc
index 83c0ab2b235d2f557631804d14967b174ae1e1bb..5986015eeafd226d2aef0535f09de4110d05214a 100644
--- a/cc/tile_manager.cc
+++ b/cc/tile_manager.cc
@@ -116,7 +116,8 @@ TileManager::TileManager(
     TileManagerClient* client,
     ResourceProvider* resource_provider,
     size_t num_raster_threads,
-    bool record_rendering_stats)
+    bool record_rendering_stats,
+    bool use_cheapness_estimator)
     : client_(client),
       resource_pool_(ResourcePool::Create(resource_provider)),
       raster_worker_pool_(RasterWorkerPool::Create(num_raster_threads, record_rendering_stats)),
@@ -124,7 +125,8 @@ TileManager::TileManager(
       manage_tiles_call_count_(0),
       bytes_pending_set_pixels_(0),
       ever_exceeded_memory_budget_(false),
-      record_rendering_stats_(record_rendering_stats) {
+      record_rendering_stats_(record_rendering_stats),
+      use_cheapness_estimator_(use_cheapness_estimator) {
   for (int i = 0; i < NUM_STATES; ++i) {
     for (int j = 0; j < NUM_TREES; ++j) {
       for (int k = 0; k < NUM_BINS; ++k)
@@ -633,8 +635,8 @@ void TileManager::OnImageDecodeTaskCompleted(
   DispatchMoreTasks();
 }
 
-void TileManager::DispatchOneRasterTask(scoped_refptr<Tile> tile) {
-  TRACE_EVENT0("cc", "TileManager::DispatchOneRasterTask");
+scoped_ptr<ResourcePool::Resource> TileManager::PrepareTileForRaster(
+    Tile* tile) {
   ManagedTileState& managed_tile_state = tile->managed_state();
   DCHECK(managed_tile_state.can_use_gpu_memory);
   scoped_ptr<ResourcePool::Resource> resource =
@@ -645,16 +647,22 @@ void TileManager::DispatchOneRasterTask(scoped_refptr<Tile> tile) {
   managed_tile_state.can_be_freed = false;
 
   DidTileRasterStateChange(tile, RASTER_STATE);
+  return resource.Pass();
+}
 
+void TileManager::DispatchOneRasterTask(scoped_refptr<Tile> tile) {
+  TRACE_EVENT0("cc", "TileManager::DispatchOneRasterTask");
+  scoped_ptr<ResourcePool::Resource> resource = PrepareTileForRaster(tile);
   ResourceProvider::ResourceId resource_id = resource->id();
 
   raster_worker_pool_->PostRasterTaskAndReply(
       tile->picture_pile(),
-      base::Bind(&TileManager::RunRasterTask,
+      base::Bind(&TileManager::PerformRaster,
                  resource_pool_->resource_provider()->mapPixelBuffer(
                      resource_id),
                  tile->content_rect_,
-                 tile->contents_scale()),
+                 tile->contents_scale(),
+                 use_cheapness_estimator_),
       base::Bind(&TileManager::OnRasterTaskCompleted,
                  base::Unretained(this),
                  tile,
@@ -662,11 +670,26 @@ void TileManager::DispatchOneRasterTask(scoped_refptr<Tile> tile) {
                  manage_tiles_call_count_));
 }
 
-void TileManager::OnRasterTaskCompleted(
+void TileManager::PerformOneRaster(Tile* tile) {
+  scoped_ptr<ResourcePool::Resource> resource = PrepareTileForRaster(tile);
+  ResourceProvider::ResourceId resource_id = resource->id();
+
+  PerformRaster(resource_pool_->resource_provider()->mapPixelBuffer(
+                    resource_id),
+                tile->content_rect_,
+                tile->contents_scale(),
+                use_cheapness_estimator_,
+                tile->picture_pile(),
+                &rendering_stats_);
+
+  OnRasterCompleted(tile, resource.Pass(), manage_tiles_call_count_);
+}
+
+void TileManager::OnRasterCompleted(
     scoped_refptr<Tile> tile,
     scoped_ptr<ResourcePool::Resource> resource,
     int manage_tiles_call_count_when_dispatched) {
-  TRACE_EVENT0("cc", "TileManager::OnRasterTaskCompleted");
+  TRACE_EVENT0("cc", "TileManager::OnRasterCompleted");
 
   // Release raster resources.
   resource_pool_->resource_provider()->unmapPixelBuffer(resource->id());
@@ -707,7 +730,14 @@ void TileManager::OnRasterTaskCompleted(
     managed_tile_state.resource_is_being_initialized = false;
     DidTileRasterStateChange(tile, IDLE_STATE);
   }
+}
 
+void TileManager::OnRasterTaskCompleted(
+    scoped_refptr<Tile> tile,
+    scoped_ptr<ResourcePool::Resource> resource,
+    int manage_tiles_call_count_when_dispatched) {
+  OnRasterCompleted(tile, resource.Pass(),
+                    manage_tiles_call_count_when_dispatched);
   DispatchMoreTasks();
 }
 
@@ -750,12 +780,13 @@ void TileManager::DidTileBinChange(Tile* tile,
 }
 
 // static
-void TileManager::RunRasterTask(uint8* buffer,
+void TileManager::PerformRaster(uint8* buffer,
                                 const gfx::Rect& rect,
                                 float contents_scale,
+                                bool use_cheapness_estimator,
                                 PicturePileImpl* picture_pile,
                                 RenderingStats* stats) {
-  TRACE_EVENT0("cc", "TileManager::RunRasterTask");
+  TRACE_EVENT0("cc", "TileManager::PerformRaster");
   DCHECK(picture_pile);
   DCHECK(buffer);
   SkBitmap bitmap;
@@ -774,15 +805,33 @@ void TileManager::RunRasterTask(uint8* buffer,
     base::TimeTicks end_time = base::TimeTicks::Now();
     base::TimeDelta duration = end_time - begin_time;
     stats->totalRasterizeTime += duration;
-    UMA_HISTOGRAM_CUSTOM_COUNTS(
-      "Renderer4.PictureRasterTimeMS",
-      duration.InMilliseconds(),
-      0, 10, 10
-    );
+    UMA_HISTOGRAM_CUSTOM_COUNTS("Renderer4.PictureRasterTimeMS",
+                                duration.InMilliseconds(),
+                                0,
+                                10,
+                                10);
+
+    if (use_cheapness_estimator) {
+      bool is_predicted_cheap = picture_pile->IsCheapInRect (rect, contents_scale);
+      bool is_actually_cheap = duration.InMillisecondsF() <= 1.0f;
+      RecordCheapnessPredictorResults(is_predicted_cheap, is_actually_cheap);
+    }
   }
 }
 
 // static
+void TileManager::RecordCheapnessPredictorResults(bool is_predicted_cheap,
+                                                  bool is_actually_cheap) {
+  if (is_predicted_cheap && !is_actually_cheap)
+    UMA_HISTOGRAM_BOOLEAN("Renderer4.CheapPredictorBadlyWrong", true);
+  else if (!is_predicted_cheap && is_actually_cheap)
+    UMA_HISTOGRAM_BOOLEAN("Renderer4.CheapPredictorSafelyWrong", true);
+
+  UMA_HISTOGRAM_BOOLEAN("Renderer4.CheapPredictorAccuracy",
+                        is_predicted_cheap == is_actually_cheap);
+}
+
+// static
 void TileManager::RunImageDecodeTask(skia::LazyPixelRef* pixel_ref,
                                      RenderingStats* stats) {
   TRACE_EVENT0("cc", "TileManager::RunImageDecodeTask");