Add cheapness predictor success histogram

cc/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/tile_manager.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
@@ skipping 639 matching lines @@
 
   ResourceProvider::ResourceId resource_id = resource->id();
 
   if (use_cheapness_estimator_ &&
       tile->picture_pile()->IsCheapInRect(tile->content_rect_,
                                           tile->contents_scale())) {
     RunRasterTask(resource_pool_->resource_provider()->mapPixelBuffer(
                       resource_id),
                   tile->content_rect_,
                   tile->contents_scale(),
+                  use_cheapness_estimator_,
                   tile->picture_pile(),
                   &rendering_stats_);
     TileManager::OnRasterTaskCompleted(tile, resource.Pass(),
                                        manage_tiles_call_count_);
     return;
   }
 
   raster_worker_pool_->PostRasterTaskAndReply(
       tile->picture_pile(),
       base::Bind(&TileManager::RunRasterTask,
                  resource_pool_->resource_provider()->mapPixelBuffer(
                      resource_id),
                  tile->content_rect_,
-                 tile->contents_scale()),
+                 tile->contents_scale(),
+                 use_cheapness_estimator_),
       base::Bind(&TileManager::OnRasterTaskCompletedByWorker,
                  base::Unretained(this),
                  tile,
                  base::Passed(&resource),
                  manage_tiles_call_count_));
 }
 
 void TileManager::OnRasterTaskCompleted(
     scoped_refptr<Tile> tile,
     scoped_ptr<ResourcePool::Resource> resource,
@@ skipping 85 matching lines @@
   // Increment count for new bin.
   ++raster_state_count_[mts.raster_state][tree][bin];
 
   mts.tree_bin[tree] = bin;
 }
 
 // static
 void TileManager::RunRasterTask(uint8* buffer,
                                 const gfx::Rect& rect,
                                 float contents_scale,
+                                bool use_cheapness_estimator,
                                 PicturePileImpl* picture_pile,
                                 RenderingStats* stats) {
   TRACE_EVENT0("cc", "TileManager::RunRasterTask");
   DCHECK(picture_pile);
   DCHECK(buffer);
   SkBitmap bitmap;
   bitmap.setConfig(SkBitmap::kARGB_8888_Config, rect.width(), rect.height());
   bitmap.setPixels(buffer);
   SkDevice device(bitmap);
   SkCanvas canvas(&device);
 
   base::TimeTicks begin_time;
   if (stats)
     begin_time = base::TimeTicks::Now();
 
   picture_pile->Raster(&canvas, rect, contents_scale, stats);
 
   if (stats) {
     base::TimeTicks end_time = base::TimeTicks::Now();

[nduca, 2013/02/04 23:16:52]

now that i look at this, didn't we already collect the start and end time inside
:797 already?

     base::TimeDelta duration = end_time - begin_time;
     stats->totalRasterizeTime += duration;
     UMA_HISTOGRAM_CUSTOM_COUNTS(
       "Renderer4.PictureRasterTimeMS",
       duration.InMilliseconds(),
       0, 10, 10
     );
+
+    if (use_cheapness_estimator) {
+      bool is_cheap = picture_pile->IsCheapInRect (rect, contents_scale);
+      bool is_correct_estimate = false;
+      
+      // Cheap means less than 1ms
+      if ((is_cheap && duration.InMillisecondsF() <= 1.0f) ||
+          (!is_cheap && duration.InMillisecondsF() > 1.0f))
+        is_correct_estimate = true;
+
+      UMA_HISTOGRAM_BOOLEAN(
+        "Renderer4.CheapnessPredictorAccuracy",
+        is_correct_estimate
+      );
+    }
   }
 }
 
 // static
 void TileManager::RunImageDecodeTask(skia::LazyPixelRef* pixel_ref,
                                      RenderingStats* stats) {
   TRACE_EVENT0("cc", "TileManager::RunImageDecodeTask");
   base::TimeTicks decode_begin_time;
   if (stats)
     decode_begin_time = base::TimeTicks::Now();
   pixel_ref->Decode();
   if (stats) {
     stats->totalDeferredImageDecodeCount++;
     stats->totalDeferredImageDecodeTime +=
         base::TimeTicks::Now() - decode_begin_time;
   }
 }
 
 }  // namespace cc