Further plumb visual rect into cc:DisplayItemList.

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/strings/stringprintf.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "cc/base/math_util.h"
 #include "cc/debug/picture_debug_util.h"
 #include "cc/debug/traced_display_item_list.h"
 #include "cc/debug/traced_value.h"
 #include "cc/playback/display_item_list_settings.h"
 #include "cc/playback/display_item_proto_factory.h"
 #include "cc/playback/largest_display_item.h"
 #include "cc/proto/display_item.pb.h"
 #include "cc/proto/gfx_conversions.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkPictureRecorder.h"
 #include "third_party/skia/include/utils/SkPictureUtils.h"
+#include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/skia_util.h"
 
 namespace cc {
 
 namespace {
 
 // We don't perform per-layer solid color analysis when there are too many skia
 // operations.
 const int kOpCountThatIsOkToAnalyze = 10;
 
@@ skipping 18 matching lines @@
 
 scoped_refptr<DisplayItemList> DisplayItemList::CreateFromProto(
     const proto::DisplayItemList& proto) {
   gfx::Rect layer_rect = ProtoToRect(proto.layer_rect());
   scoped_refptr<DisplayItemList> list =
       DisplayItemList::Create(ProtoToRect(proto.layer_rect()),
                               DisplayItemListSettings(proto.settings()));
 
   for (int i = 0; i < proto.items_size(); i++) {
     const proto::DisplayItem& item_proto = proto.items(i);
-    DisplayItem* item =
-        DisplayItemProtoFactory::AllocateAndConstruct(list.get(), item_proto);
+    DisplayItem* item = DisplayItemProtoFactory::AllocateAndConstruct(
+        layer_rect, list.get(), item_proto);
     if (item)
       item->FromProtobuf(item_proto);
   }
 
   return list;
 }
 
 DisplayItemList::DisplayItemList(gfx::Rect layer_rect,
                                  const DisplayItemListSettings& settings,
                                  bool retain_individual_display_items)
@@ skipping 119 matching lines @@
 void DisplayItemList::RemoveLast() {
   // We cannot remove the last item if it has been squashed into a picture.
   // The last item should not have been handled by ProcessAppendedItems, so we
   // don't need to remove it from approximate_op_count_, etc.
   DCHECK(retain_individual_display_items_);
   DCHECK(!settings_.use_cached_picture);
   items_.RemoveLast();
 }
 
 void DisplayItemList::Finalize() {
+  // TODO(wkorman): Uncomment the assert below once we've investigated
+  // and resolved issues. http://crbug.com/557905
+  // DCHECK_EQ(items_.size(), visual_rects_.size());
+
+  // TODO(vmpstr): Build and make use of an RTree from the visual
+  // rects. For now we just clear them out since we won't ever need
+  // them to stick around post-Finalize. http://crbug.com/527245
+  visual_rects_.clear();
+
   ProcessAppendedItems();
 
   if (settings_.use_cached_picture) {
     // Convert to an SkPicture for faster rasterization.
     DCHECK(settings_.use_cached_picture);
     DCHECK(!picture_);
     picture_ = skia::AdoptRef(recorder_->endRecordingAsPicture());
     DCHECK(picture_);
     picture_memory_usage_ =
         SkPictureUtils::ApproximateBytesUsed(picture_.get());
@@ skipping 42 matching lines @@
 
 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();
 
   state->BeginDictionary("params");
   if (include_items) {
     state->BeginArray("items");
+    size_t item_index = 0;
     for (const DisplayItem* item : items_) {
-      item->AsValueInto(state.get());
+      item->AsValueInto(visual_rects_.size() >= item_index
+                            ? visual_rects_[item_index]
+                            : gfx::Rect(),
+                        state.get());
+      item_index++;
     }
     state->EndArray();  // "items".
   }
   state->SetValue("layer_rect", MathUtil::AsValue(layer_rect_));
   state->EndDictionary();  // "params".
 
   if (!layer_rect_.IsEmpty()) {
     SkPictureRecorder recorder;
     SkCanvas* canvas =
         recorder.beginRecording(layer_rect_.width(), layer_rect_.height());
@@ skipping 40 matching lines @@
 }
 
 void DisplayItemList::GetDiscardableImagesInRect(
     const gfx::Rect& rect,
     float raster_scale,
     std::vector<DrawImage>* images) {
   image_map_.GetDiscardableImagesInRect(rect, raster_scale, images);
 }
 
 }  // namespace cc