cc: Consolidate the analysis_canvas operations

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 158 matching lines @@
   state->Set("resolution", TileResolutionAsValue(resolution).release());
   state->Set("time_to_needed_in_seconds", MathUtil::asValueSafely(time_to_needed_in_seconds).release());
   state->Set("distance_to_visible_in_pixels", MathUtil::asValueSafely(distance_to_visible_in_pixels).release());
   return state.PassAs<base::Value>();
 }
 
 TileManager::TileManager(
     TileManagerClient* client,
     ResourceProvider* resource_provider,
     size_t num_raster_threads,
-    bool use_cheapness_estimator)
+    bool use_cheapness_estimator,
+    bool solid_color_benchmarking)
     : client_(client),
       resource_pool_(ResourcePool::Create(resource_provider)),
       raster_worker_pool_(RasterWorkerPool::Create(this, num_raster_threads)),
       manage_tiles_pending_(false),
       manage_tiles_call_count_(0),
       bytes_pending_upload_(0),
       has_performed_uploads_since_last_flush_(false),
       ever_exceeded_memory_budget_(false),
       record_rendering_stats_(false),
       use_cheapness_estimator_(use_cheapness_estimator),
       allow_cheap_tasks_(true),
-      did_schedule_cheap_tasks_(false) {
+      did_schedule_cheap_tasks_(false),
+      solid_color_benchmarking_(solid_color_benchmarking) {
   for (int i = 0; i < NUM_STATES; ++i) {
     for (int j = 0; j < NUM_TREES; ++j) {
       for (int k = 0; k < NUM_BINS; ++k)
         raster_state_count_[i][j][k] = 0;
     }
   }
 }
 
 TileManager::~TileManager() {
   // Reset global state and manage. This should cause
@@ skipping 608 matching lines @@
                  base::Passed(&resource),
                  manage_tiles_call_count_));
   did_schedule_cheap_tasks_ |= is_cheap;
 }
 
 TileManager::RasterTaskMetadata TileManager::GetRasterTaskMetadata(
     const Tile& tile) const {
   RasterTaskMetadata metadata;
   const ManagedTileState& mts = tile.managed_state();
   metadata.use_cheapness_estimator = use_cheapness_estimator_;
+  metadata.solid_color_benchmarking = solid_color_benchmarking_;
   metadata.is_tile_in_pending_tree_now_bin =
       mts.tree_bin[PENDING_TREE] == NOW_BIN;
   metadata.tile_resolution = mts.resolution;
   return metadata;
 }
 
 void TileManager::OnRasterTaskCompleted(
     scoped_refptr<Tile> tile,
     scoped_ptr<ResourcePool::Resource> resource,
     int manage_tiles_call_count_when_dispatched) {
@@ skipping 102 matching lines @@
   SkDevice device(bitmap);
   SkCanvas canvas(&device);
 
   base::TimeTicks begin_time;
   if (stats)
     begin_time = base::TimeTicks::HighResNow();
 
   int64 total_pixels_rasterized = 0;
   picture_pile->Raster(&canvas, rect, contents_scale,
                        &total_pixels_rasterized);
-
   if (stats) {
     stats->totalPixelsRasterized += total_pixels_rasterized;
 
     base::TimeTicks end_time = base::TimeTicks::HighResNow();
     base::TimeDelta duration = end_time - begin_time;
     stats->totalRasterizeTime += duration;
     if (metadata.is_tile_in_pending_tree_now_bin)
       stats->totalRasterizeTimeForNowBinsOnPendingTree += duration;
 
     UMA_HISTOGRAM_CUSTOM_COUNTS("Renderer4.PictureRasterTimeMS",
                                 duration.InMilliseconds(),
                                 0,
                                 10,
                                 10);
 
     if (metadata.use_cheapness_estimator) {
       bool is_predicted_cheap =
-          picture_pile->IsCheapInRect(rect, contents_scale);
+        picture_pile->IsCheapInRect(rect, contents_scale);

[reveman, 2013/02/26 23:34:40]

nit: 4 space indent here

       bool is_actually_cheap = duration.InMillisecondsF() <= 1.0f;
       RecordCheapnessPredictorResults(is_predicted_cheap, is_actually_cheap);
     }
   }
+
+  if (metadata.solid_color_benchmarking) {
+    SkColor solid_color;
+    bool is_predicted_solid =
+      picture_pile->GetColorIfSolidInRect(rect, contents_scale, &solid_color);

[reveman, 2013/02/26 23:34:40]

nit: 4 space indent

+    bool is_predicted_transparent =
+      picture_pile->IsTransparentInRect(rect, contents_scale);

[reveman, 2013/02/26 23:34:40]

nit: 4 space indent

+
+    RecordSolidColorPredictorResults(buffer,
+                                     rect.width() * rect.height(),
+                                     is_predicted_solid,
+                                     solid_color,
+                                     is_predicted_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);
   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

[reveman, 2013/02/26 23:34:40]

nit: space between // and static

+void TileManager::RecordSolidColorPredictorResults(const uint8* actual_bytes,
+                                                   size_t pixel_count,
+                                                   bool is_predicted_solid,
+                                                   SkColor predicted_color,
+                                                   bool is_predicted_transparent) {

[reveman, 2013/02/26 23:34:40]

nit: lines should be <= 80 characters long

+  CHECK(pixel_count > 0);

[reveman, 2013/02/26 23:34:40]

use CHECK_GT

+
+  bool is_actually_solid = true;
+  bool is_transparent = true;
+  SkColor actual_color = SkColorSetARGB(actual_bytes[3],
+                                        actual_bytes[2],
+                                        actual_bytes[1],
+                                        actual_bytes[0]);

[reveman, 2013/02/26 23:34:40]

is it safe to assume pixels are packed this way? you should probably use the
macros in SkColorPriv.h here.

+  for (int i = (pixel_count-1)*4; i >= 0; i -= 4) {

[reveman, 2013/02/26 23:34:40]

what if stride != width?

+    SkColor current_color = SkColorSetARGB(actual_bytes[i+3],
+                                           actual_bytes[i+2],
+                                           actual_bytes[i+1],
+                                           actual_bytes[i]);
+    if (current_color != actual_color ||
+        SkColorGetA(current_color) != 255)
+      is_actually_solid = false;
+
+    if (SkColorGetA(current_color) != 0)
+      is_transparent = false;
+  }
+
+  if (is_predicted_solid && !is_actually_solid)
+    UMA_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);
+  else if(!is_predicted_solid && is_actually_solid)

[reveman, 2013/02/26 23:34:40]

nit: space between if and (

+    UMA_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);
+
+  if (correct_guess)
+    UMA_HISTOGRAM_BOOLEAN("Renderer4.ColorPredictor.IsCorrectSolid", 
+                          is_predicted_solid);
+
+  if (is_predicted_transparent)
+    UMA_HISTOGRAM_BOOLEAN("Renderer4.ColorPredictor.PredictedTransparentIsActually", is_transparent);

[reveman, 2013/02/26 23:34:40]

nit: lines should be <= 80 characters long

+  UMA_HISTOGRAM_BOOLEAN("Renderer4.ColorPredictor.IsActuallyTransparent", is_transparent);

[reveman, 2013/02/26 23:34:40]

nit: lines should be <= 80 characters long

+}
+
 // 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::HighResNow();
   pixel_ref->Decode();
   if (stats) {
     stats->totalDeferredImageDecodeCount++;
     stats->totalDeferredImageDecodeTime +=
         base::TimeTicks::HighResNow() - decode_begin_time;
   }
 }
 
 }  // namespace cc