cc: Compute picture pile size at construction time.

cc/resources/picture_pile_impl.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 <algorithm>
 #include <limits>
 #include <set>
 
 #include "base/trace_event/trace_event.h"
 #include "cc/base/region.h"
@@ skipping 16 matching lines @@
 PicturePileImpl::PicturePileImpl()
     : background_color_(SK_ColorTRANSPARENT),
       requires_clear_(true),
       can_use_lcd_text_(true),
       is_solid_color_(false),
       solid_color_(SK_ColorTRANSPARENT),
       has_any_recordings_(false),
       clear_canvas_with_debug_color_(false),
       min_contents_scale_(0.f),
       slow_down_raster_scale_factor_for_debug_(0),
-      should_attempt_to_use_distance_field_text_(false) {
+      should_attempt_to_use_distance_field_text_(false),
+      picture_memory_usage_(0) {
 }
 
 PicturePileImpl::PicturePileImpl(const PicturePile* other,
                                  bool can_use_lcd_text)
     : picture_map_(other->picture_map_),
       tiling_(other->tiling_),
       background_color_(other->background_color_),
       requires_clear_(other->requires_clear_),
       can_use_lcd_text_(can_use_lcd_text),
       is_solid_color_(other->is_solid_color_),
       solid_color_(other->solid_color_),
       recorded_viewport_(other->recorded_viewport_),
       has_any_recordings_(other->has_any_recordings_),
       clear_canvas_with_debug_color_(other->clear_canvas_with_debug_color_),
       min_contents_scale_(other->min_contents_scale_),
       slow_down_raster_scale_factor_for_debug_(
           other->slow_down_raster_scale_factor_for_debug_),
-      should_attempt_to_use_distance_field_text_(false) {
+      should_attempt_to_use_distance_field_text_(false),
+      picture_memory_usage_(0) {
+  // Figure out the picture size upon construction.
+  base::hash_set<const Picture*> pictures_seen;
+  for (const auto& map_value : picture_map_) {
+    const Picture* picture = map_value.second.get();
+    if (pictures_seen.insert(picture).second)
+      picture_memory_usage_ += picture->ApproximateMemoryUsage();
+  }
 }
 
 PicturePileImpl::PicturePileImpl(const PicturePileImpl* other,
                                  bool can_use_lcd_text)
     : picture_map_(other->picture_map_),
       tiling_(other->tiling_),
       background_color_(other->background_color_),
       requires_clear_(other->requires_clear_),
       can_use_lcd_text_(can_use_lcd_text),
       is_solid_color_(other->is_solid_color_),
       solid_color_(other->solid_color_),
       recorded_viewport_(other->recorded_viewport_),
       has_any_recordings_(other->has_any_recordings_),
       clear_canvas_with_debug_color_(other->clear_canvas_with_debug_color_),
       min_contents_scale_(other->min_contents_scale_),
       slow_down_raster_scale_factor_for_debug_(
           other->slow_down_raster_scale_factor_for_debug_),
       should_attempt_to_use_distance_field_text_(
-          other->should_attempt_to_use_distance_field_text_) {
+          other->should_attempt_to_use_distance_field_text_),
+      picture_memory_usage_(other->picture_memory_usage_) {
 }
 
 PicturePileImpl::~PicturePileImpl() {
 }
 
 void PicturePileImpl::PlaybackToSharedCanvas(SkCanvas* canvas,
                                              const gfx::Rect& canvas_rect,
                                              float contents_scale) const {
   RasterCommon(canvas, NULL, canvas_rect, contents_scale);
 }
@@ skipping 172 matching lines @@
       recorder.beginRecording(tiling_rect.width(), tiling_rect.height());
   if (!tiling_rect.IsEmpty())
     PlaybackToCanvas(canvas, tiling_rect, 1.0);
   skia::RefPtr<SkPicture> picture =
       skia::AdoptRef(recorder.endRecordingAsPicture());
 
   return picture;
 }
 
 size_t PicturePileImpl::GetPictureMemoryUsage() const {
-  // Place all pictures in a set to de-dupe.
-  size_t total_size = 0;
-  std::set<const Picture*> pictures_seen;
-  for (const auto& map_value : picture_map_) {
-    const Picture* picture = map_value.second.get();
-    if (pictures_seen.insert(picture).second)
-      total_size += picture->ApproximateMemoryUsage();
-  }
-
-  return total_size;
+  return picture_memory_usage_;
 }
 
 void PicturePileImpl::PerformSolidColorAnalysis(
     const gfx::Rect& content_rect,
     float contents_scale,
     RasterSource::SolidColorAnalysis* analysis) const {
   DCHECK(analysis);
   TRACE_EVENT0("cc", "PicturePileImpl::PerformSolidColorAnalysis");
 
   gfx::Rect layer_rect = gfx::ScaleToEnclosingRect(
@@ skipping 166 matching lines @@
   for (const auto& map_pair : picture_map_) {
     const Picture* picture = map_pair.second.get();
     if (processed_pictures.count(picture) == 0) {
       picture->EmitTraceSnapshot();
       processed_pictures.insert(picture);
     }
   }
 }
 
 }  // namespace cc