cc: Changed to prediction histograms in tile manager

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 <string>
 
 #include "base/bind.h"
@@ skipping 905 matching lines @@
   int64 total_pixels_rasterized =
       picture_pile->Raster(&canvas, rect, contents_scale);
 
   base::TimeDelta duration = stats_instrumentation->EndRecording(start_time);
 
   if (stats_instrumentation->record_rendering_stats()) {
     stats_instrumentation->AddRaster(duration,
                                      total_pixels_rasterized,
                                      metadata.is_tile_in_pending_tree_now_bin);
 
-    UMA_HISTOGRAM_CUSTOM_COUNTS("Renderer4.PictureRasterTimeMS",
-                                duration.InMilliseconds(),
-                                0,
-                                10,
-                                10);
+    HISTOGRAM_CUSTOM_COUNTS("Renderer4.PictureRasterTimeUS",
+                            duration.InMicroseconds(),
+                            0,
+                            100000,
+                            100);
 
     if (metadata.prediction_benchmarking) {
       PicturePileImpl::Analysis analysis;
       picture_pile->AnalyzeInRect(rect, contents_scale, &analysis);
       bool is_predicted_cheap = analysis.is_cheap_to_raster;
       bool is_actually_cheap = duration.InMillisecondsF() <= 1.0f;
       RecordCheapnessPredictorResults(is_predicted_cheap, is_actually_cheap);
 
       DCHECK_EQ(bitmap.rowBytes(),
                 static_cast<size_t>(bitmap.width() * bitmap.bytesPerPixel()));
 
       RecordSolidColorPredictorResults(
           reinterpret_cast<SkColor*>(bitmap.getPixels()),
           bitmap.getSize() / bitmap.bytesPerPixel(),
           analysis.is_solid_color,
           analysis.solid_color,
           analysis.is_transparent);
     }
   }
 }
 
 // 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);
+    HISTOGRAM_BOOLEAN("Renderer4.CheapPredictorBadlyWrong", true);
   else if (!is_predicted_cheap && is_actually_cheap)
-    UMA_HISTOGRAM_BOOLEAN("Renderer4.CheapPredictorSafelyWrong", true);
+    HISTOGRAM_BOOLEAN("Renderer4.CheapPredictorSafelyWrong", true);
 
-  UMA_HISTOGRAM_BOOLEAN("Renderer4.CheapPredictorAccuracy",
-                        is_predicted_cheap == is_actually_cheap);
+  HISTOGRAM_BOOLEAN("Renderer4.CheapPredictorAccuracy",
+                    is_predicted_cheap == is_actually_cheap);
 }
 
 // static
 void TileManager::RecordSolidColorPredictorResults(
     const SkColor* actual_colors,
     size_t color_count,
     bool is_predicted_solid,
     SkColor predicted_color,
     bool is_predicted_transparent) {
   DCHECK_GT(color_count, 0u);
 
   bool is_actually_solid = true;
   bool is_transparent = true;
 
   SkColor actual_color = *actual_colors;
   for (unsigned int i = 0; i < color_count; ++i) {
     SkColor current_color = actual_colors[i];
     if (current_color != actual_color ||
         SkColorGetA(current_color) != 255)
       is_actually_solid = false;
 
     if (SkColorGetA(current_color) != 0)
       is_transparent = false;
 
     if (!is_actually_solid && !is_transparent)
       break;
   }
 
   if (is_predicted_solid && !is_actually_solid)
-    UMA_HISTOGRAM_BOOLEAN("Renderer4.ColorPredictor.WrongActualNotSolid", true);

[enne (OOO), 2013/04/04 20:42:09]

I'm not sure I agree that making these not uma histograms is a good choice. 
It'd be nice to be able to see in the field if the color predictor starts
failing.

[vmpstr, 2013/04/04 20:53:19]

These would only be recorded if both gpu-benchmarking and
prediction-benchmarking is turned on. If someone is running with those flags,
then I imagine they would be manually inspecting the results :)

I don't mind changing those back though, since we'll still record at least as
much data... Do you think all of my UMA -> non-UMA changes should be undone or
just the color predictor ones?

+    HISTOGRAM_BOOLEAN("Renderer4.ColorPredictor.WrongActualNotSolid", true);
   else if (is_predicted_solid &&
            is_actually_solid &&
            predicted_color != actual_color)
-    UMA_HISTOGRAM_BOOLEAN("Renderer4.ColorPredictor.WrongColor", true);
+    HISTOGRAM_BOOLEAN("Renderer4.ColorPredictor.WrongColor", true);
   else if (!is_predicted_solid && is_actually_solid)
-    UMA_HISTOGRAM_BOOLEAN("Renderer4.ColorPredictor.WrongActualSolid", true);
+    HISTOGRAM_BOOLEAN("Renderer4.ColorPredictor.WrongActualSolid", true);
 
   bool correct_guess = (is_predicted_solid && is_actually_solid &&
                         predicted_color == actual_color) ||
                        (!is_predicted_solid && !is_actually_solid);
-  UMA_HISTOGRAM_BOOLEAN("Renderer4.ColorPredictor.Accuracy", correct_guess);
+  HISTOGRAM_BOOLEAN("Renderer4.ColorPredictor.Accuracy", correct_guess);
 
   if (correct_guess)
-    UMA_HISTOGRAM_BOOLEAN("Renderer4.ColorPredictor.IsCorrectSolid",
+    HISTOGRAM_BOOLEAN("Renderer4.ColorPredictor.IsCorrectSolid",
                           is_predicted_solid);
 
   if (is_predicted_transparent)
-    UMA_HISTOGRAM_BOOLEAN(
-        "Renderer4.ColorPredictor.PredictedTransparentIsActually",
-        is_transparent);
-  UMA_HISTOGRAM_BOOLEAN("Renderer4.ColorPredictor.IsActuallyTransparent",
-                        is_transparent);
+    HISTOGRAM_BOOLEAN("Renderer4.ColorPredictor.PredictedTransparentIsActually",
+                      is_transparent);
+  HISTOGRAM_BOOLEAN("Renderer4.ColorPredictor.IsActuallyTransparent",
+                    is_transparent);
 }
 
 // static
 void TileManager::RunImageDecodeTask(
     skia::LazyPixelRef* pixel_ref,
     RenderingStatsInstrumentation* stats_instrumentation) {
   TRACE_EVENT0("cc", "TileManager::RunImageDecodeTask");
   base::TimeTicks start_time = stats_instrumentation->StartRecording();
   pixel_ref->Decode();
   base::TimeDelta duration = stats_instrumentation->EndRecording(start_time);
   stats_instrumentation->AddDeferredImageDecode(duration);
 }
 
 }  // namespace cc