cc: More consistent reasoning about display list memory usage.

cc/playback/display_item_list.cc

 // Copyright 2014 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/playback/display_item_list.h"
 
 #include <string>
 
 #include "base/numerics/safe_conversions.h"
 #include "base/trace_event/trace_event.h"
@@ skipping 30 matching lines @@
                                  bool retain_individual_display_items)
     : items_(LargestDisplayItemSize(),
              settings.max_sidecar_size,
              kDefaultNumDisplayItemsToReserve,
              settings.sidecar_destroyer),
       use_cached_picture_(settings.use_cached_picture),
       retain_individual_display_items_(retain_individual_display_items),
       layer_rect_(layer_rect),
       is_suitable_for_gpu_rasterization_(true),
       approximate_op_count_(0),
-      picture_memory_usage_(0) {
+      picture_memory_usage_(0),
+      external_memory_usage_(0) {
 #if DCHECK_IS_ON()
   needs_process_ = false;
 #endif
   if (use_cached_picture_) {
     SkRTreeFactory factory;
     recorder_.reset(new SkPictureRecorder());
     canvas_ = skia::SharePtr(recorder_->beginRecording(
         layer_rect_.width(), layer_rect_.height(), &factory));
     canvas_->translate(-layer_rect_.x(), -layer_rect_.y());
     canvas_->clipRect(gfx::RectToSkRect(layer_rect_));
@@ skipping 84 matching lines @@
     approximate_op_count_ += item->approximate_op_count();
 
     if (use_cached_picture_) {
       DCHECK(canvas_);
       item->Raster(canvas_.get(), gfx::Rect(), NULL);
     }
 
     if (retain_individual_display_items_) {
       // Warning: this double-counts SkPicture data if use_cached_picture_ is
       // also true.
-      picture_memory_usage_ += item->picture_memory_usage();
+      external_memory_usage_ += item->external_memory_usage();
     }
   }
 
   if (!retain_individual_display_items_)
     items_.clear();
 }
 
 void DisplayItemList::RasterIntoCanvas(const DisplayItem& item) {
   DCHECK(canvas_);
   DCHECK(!retain_individual_display_items_);
@@ skipping 19 matching lines @@
 
 void DisplayItemList::Finalize() {
   ProcessAppendedItems();
 
   if (use_cached_picture_) {
     // Convert to an SkPicture for faster rasterization.
     DCHECK(use_cached_picture_);
     DCHECK(!picture_);
     picture_ = skia::AdoptRef(recorder_->endRecordingAsPicture());
     DCHECK(picture_);
-    picture_memory_usage_ +=
+    picture_memory_usage_ =
         SkPictureUtils::ApproximateBytesUsed(picture_.get());
     recorder_.reset();
     canvas_.clear();
   }
 }
 
 bool DisplayItemList::IsSuitableForGpuRasterization() const {
   DCHECK(ProcessAppendedItemsCalled());
   // This is more permissive than Picture's implementation, since none of the
   // items might individually trigger a veto even though they collectively have
   // enough "bad" operations that a corresponding Picture would get vetoed.
   return is_suitable_for_gpu_rasterization_;
 }
 
 int DisplayItemList::ApproximateOpCount() const {
   DCHECK(ProcessAppendedItemsCalled());
   return approximate_op_count_;
 }
 
-size_t DisplayItemList::PictureMemoryUsage() const {
+size_t DisplayItemList::ApproximateMemoryUsage() const {
   DCHECK(ProcessAppendedItemsCalled());
   // We double-count in this case. Produce zero to avoid being misleading.
   if (use_cached_picture_ && retain_individual_display_items_)
     return 0;
 
   DCHECK_IMPLIES(use_cached_picture_, picture_);
-  return picture_memory_usage_;
+
+  size_t memory_usage = sizeof(*this);
+
+  // Memory outside this class due to |items_|.
+  memory_usage += items_.GetCapacityInBytes() + external_memory_usage_;
+
+  // Memory outside this class due to |picture|.
+  memory_usage += picture_memory_usage_;
+
+  // TODO(jbroman): Does anything else owned by this class substantially
+  // contribute to memory usage?
+
+  return memory_usage;
 }
 
 scoped_refptr<base::trace_event::ConvertableToTraceFormat>
 DisplayItemList::AsValue(bool include_items) const {
   DCHECK(ProcessAppendedItemsCalled());
   scoped_refptr<base::trace_event::TracedValue> state =
       new base::trace_event::TracedValue();
 
   if (include_items) {
     state->BeginArray("params.items");
@@ skipping 44 matching lines @@
     return;
 
   pixel_refs_->GatherPixelRefsFromPicture(picture_.get());
 }
 
 void* DisplayItemList::GetSidecar(DisplayItem* display_item) {
   return items_.GetSidecar(display_item);
 }
 
 }  // namespace cc