cc: Cull DrawingDisplayItems outside of the raster playback rect

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/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
@@ skipping 76 matching lines @@
     gfx::Rect layer_rect,
     const DisplayItemListSettings& settings) {
   return make_scoped_refptr(new DisplayItemList(layer_rect, settings));
 }
 
 DisplayItemList::~DisplayItemList() {
 }
 
 void DisplayItemList::Raster(SkCanvas* canvas,
                              SkPicture::AbortCallback* callback,
+                             const gfx::Rect& canvas_target_playback_rect,
                              float contents_scale) const {
   DCHECK(ProcessAppendedItemsCalled());
   if (!use_cached_picture_) {
     canvas->save();
     canvas->scale(contents_scale, contents_scale);
     for (auto* item : items_)
-      item->Raster(canvas, callback);
+      item->Raster(canvas, canvas_target_playback_rect, callback);
     canvas->restore();
   } else {
     DCHECK(picture_);
 
     canvas->save();
     canvas->scale(contents_scale, contents_scale);
     canvas->translate(layer_rect_.x(), layer_rect_.y());
     if (callback) {
       // If we have a callback, we need to call |draw()|, |drawPicture()|
       // doesn't take a callback.  This is used by |AnalysisCanvas| to early
@@ skipping 24 matching lines @@
 #if DCHECK_IS_ON()
   needs_process_ = false;
 #endif
   for (const DisplayItem* item : items_) {
     is_suitable_for_gpu_rasterization_ &=
         item->is_suitable_for_gpu_rasterization();
     approximate_op_count_ += item->approximate_op_count();
 
     if (use_cached_picture_) {
       DCHECK(canvas_);
-      item->Raster(canvas_.get(), NULL);
+      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();
     }
   }
 
   if (!retain_individual_display_items_)
@@ skipping 52 matching lines @@
   }
   state->EndArray();
   state->SetValue("params.layer_rect", MathUtil::AsValue(layer_rect_));
 
   if (!layer_rect_.IsEmpty()) {
     SkPictureRecorder recorder;
     SkCanvas* canvas =
         recorder.beginRecording(layer_rect_.width(), layer_rect_.height());
     canvas->translate(-layer_rect_.x(), -layer_rect_.y());
     canvas->clipRect(gfx::RectToSkRect(layer_rect_));
-    Raster(canvas, NULL, 1.f);
+    Raster(canvas, NULL, gfx::Rect(), 1.f);
     skia::RefPtr<SkPicture> picture =
         skia::AdoptRef(recorder.endRecordingAsPicture());
 
     std::string b64_picture;
     PictureDebugUtil::SerializeAsBase64(picture.get(), &b64_picture);
     state->SetString("skp64", b64_picture);
   }
 
   return state;
 }
@@ skipping 16 matching lines @@
     return;
 
   pixel_refs_->GatherPixelRefsFromPicture(picture_.get());
 }
 
 void* DisplayItemList::GetSidecar(DisplayItem* display_item) {
   return items_.GetSidecar(display_item);
 }
 
 }  // namespace cc