Reland "Raster display item lists via a visual rect RTree."

Rather than caching and playing back an entire SkPicture
when rastering a display item list for a particular
playback rect, instead retain display items and query
them via an RTree of their visual rects to find and
raster only what's needed.

Display item lists no longer support the notion of a
bounding "layer rect" with mutable origin.

DisplayItemListSettings proto is obsolete after this
change as it's comprised solely of one field to allow
switching whether to use the aforementioned now-deleted
cached SkPicture code path. It will be deleted in a
subsequent patch.

Last reverted change: http://crrev.com/2217263003

BUG=529938
CQ_INCLUDE_TRYBOTS=master.tryserver.blink:linux_precise_blink_rel
TBR=chrishtr,vmpstr

Review-Url: https://codereview.chromium.org/2225563002
Cr-Commit-Position: refs/heads/master@{#411560}

cc/blink/web_content_layer_impl.cc

@@ -75,7 +75,7 @@ WebContentLayerImpl::PaintContentsToDisplayList(
   settings.use_cached_picture = UseCachedPictureRaster();
 
   scoped_refptr<cc::DisplayItemList> display_list =
-      cc::DisplayItemList::Create(PaintableRegion(), settings);
+      cc::DisplayItemList::Create(settings);
   if (client_) {
     WebDisplayItemListImpl list(display_list.get());
     client_->paintContents(&list, PaintingControlToWeb(painting_control));

cc/blink/web_display_item_list_impl.cc

@@ -33,8 +33,7 @@ namespace {
 scoped_refptr<cc::DisplayItemList> CreateUncachedDisplayItemListForBlink() {
   cc::DisplayItemListSettings settings;
   settings.use_cached_picture = false;
-  gfx::Rect layer_rect;
-  return cc::DisplayItemList::Create(layer_rect, settings);
+  return cc::DisplayItemList::Create(settings);
 }
 
 }  // namespace
@@ -51,13 +50,8 @@ WebDisplayItemListImpl::WebDisplayItemListImpl(
 void WebDisplayItemListImpl::appendDrawingItem(
     const blink::WebRect& visual_rect,
     sk_sp<const SkPicture> picture) {
-  if (display_item_list_->RetainsIndividualDisplayItems()) {
-    display_item_list_->CreateAndAppendDrawingItem<cc::DrawingDisplayItem>(
-        visual_rect, std::move(picture));
-  } else {
-    cc::DrawingDisplayItem item(std::move(picture));
-    display_item_list_->RasterIntoCanvas(item);
-  }
+  display_item_list_->CreateAndAppendDrawingItem<cc::DrawingDisplayItem>(
+      visual_rect, std::move(picture));
 }
 
 void WebDisplayItemListImpl::appendClipItem(
@@ -68,86 +62,50 @@ void WebDisplayItemListImpl::appendClipItem(
     rounded_rects.push_back(rounded_clip_rects[i]);
   }
   bool antialias = true;
-  if (display_item_list_->RetainsIndividualDisplayItems()) {
-    display_item_list_->CreateAndAppendPairedBeginItem<cc::ClipDisplayItem>(
-        clip_rect, rounded_rects, antialias);
-  } else {
-    cc::ClipDisplayItem item(clip_rect, rounded_rects, antialias);
-    display_item_list_->RasterIntoCanvas(item);
-  }
+  display_item_list_->CreateAndAppendPairedBeginItem<cc::ClipDisplayItem>(
+      clip_rect, rounded_rects, antialias);
 }
 
 void WebDisplayItemListImpl::appendEndClipItem() {
-  if (display_item_list_->RetainsIndividualDisplayItems()) {
-    display_item_list_->CreateAndAppendPairedEndItem<cc::EndClipDisplayItem>();
-  } else {
-    display_item_list_->RasterIntoCanvas(cc::EndClipDisplayItem());
-  }
+  display_item_list_->CreateAndAppendPairedEndItem<cc::EndClipDisplayItem>();
 }
 
 void WebDisplayItemListImpl::appendClipPathItem(
     const SkPath& clip_path,
     SkRegion::Op clip_op,
     bool antialias) {
-  if (display_item_list_->RetainsIndividualDisplayItems()) {
-    display_item_list_->CreateAndAppendPairedBeginItem<cc::ClipPathDisplayItem>(
-        clip_path, clip_op, antialias);
-  } else {
-    cc::ClipPathDisplayItem item(clip_path, clip_op, antialias);
-    display_item_list_->RasterIntoCanvas(item);
-  }
+  display_item_list_->CreateAndAppendPairedBeginItem<cc::ClipPathDisplayItem>(
+      clip_path, clip_op, antialias);
 }
 
 void WebDisplayItemListImpl::appendEndClipPathItem() {
-  if (display_item_list_->RetainsIndividualDisplayItems()) {
-    display_item_list_
-        ->CreateAndAppendPairedEndItem<cc::EndClipPathDisplayItem>();
-  } else {
-    display_item_list_->RasterIntoCanvas(cc::EndClipPathDisplayItem());
-  }
+  display_item_list_
+      ->CreateAndAppendPairedEndItem<cc::EndClipPathDisplayItem>();
 }
 
 void WebDisplayItemListImpl::appendFloatClipItem(
     const blink::WebFloatRect& clip_rect) {
-  if (display_item_list_->RetainsIndividualDisplayItems()) {
-    display_item_list_
-        ->CreateAndAppendPairedBeginItem<cc::FloatClipDisplayItem>(clip_rect);
-  } else {
-    cc::FloatClipDisplayItem item(clip_rect);
-    display_item_list_->RasterIntoCanvas(item);
-  }
+  display_item_list_->CreateAndAppendPairedBeginItem<cc::FloatClipDisplayItem>(
+      clip_rect);
 }
 
 void WebDisplayItemListImpl::appendEndFloatClipItem() {
-  if (display_item_list_->RetainsIndividualDisplayItems()) {
-    display_item_list_
-        ->CreateAndAppendPairedEndItem<cc::EndFloatClipDisplayItem>();
-  } else {
-    display_item_list_->RasterIntoCanvas(cc::EndFloatClipDisplayItem());
-  }
+  display_item_list_
+      ->CreateAndAppendPairedEndItem<cc::EndFloatClipDisplayItem>();
 }
 
 void WebDisplayItemListImpl::appendTransformItem(
     const SkMatrix44& matrix) {
   gfx::Transform transform(gfx::Transform::kSkipInitialization);
   transform.matrix() = matrix;
 
-  if (display_item_list_->RetainsIndividualDisplayItems()) {
-    display_item_list_
-        ->CreateAndAppendPairedBeginItem<cc::TransformDisplayItem>(transform);
-  } else {
-    cc::TransformDisplayItem item(transform);
-    display_item_list_->RasterIntoCanvas(item);
-  }
+  display_item_list_->CreateAndAppendPairedBeginItem<cc::TransformDisplayItem>(
+      transform);
 }
 
 void WebDisplayItemListImpl::appendEndTransformItem() {
-  if (display_item_list_->RetainsIndividualDisplayItems()) {
-    display_item_list_
-        ->CreateAndAppendPairedEndItem<cc::EndTransformDisplayItem>();
-  } else {
-    display_item_list_->RasterIntoCanvas(cc::EndTransformDisplayItem());
-  }
+  display_item_list_
+      ->CreateAndAppendPairedEndItem<cc::EndTransformDisplayItem>();
 }
 
 void WebDisplayItemListImpl::appendCompositingItem(
@@ -161,56 +119,36 @@ void WebDisplayItemListImpl::appendCompositingItem(
   // value, but that breaks slimming paint reftests.
 
   const bool kLcdTextRequiresOpaqueLayer = true;
-  if (display_item_list_->RetainsIndividualDisplayItems()) {
-    display_item_list_
-        ->CreateAndAppendPairedBeginItem<cc::CompositingDisplayItem>(
-            static_cast<uint8_t>(gfx::ToFlooredInt(255 * opacity)), xfermode,
-            bounds, sk_ref_sp(color_filter), kLcdTextRequiresOpaqueLayer);
-  } else {
-    cc::CompositingDisplayItem item(
-        static_cast<uint8_t>(gfx::ToFlooredInt(255 * opacity)), xfermode,
-        bounds, sk_ref_sp(color_filter), kLcdTextRequiresOpaqueLayer);
-    display_item_list_->RasterIntoCanvas(item);
-  }
+  display_item_list_
+      ->CreateAndAppendPairedBeginItem<cc::CompositingDisplayItem>(
+          static_cast<uint8_t>(gfx::ToFlooredInt(255 * opacity)), xfermode,
+          bounds, sk_ref_sp(color_filter), kLcdTextRequiresOpaqueLayer);
 }
 
 void WebDisplayItemListImpl::appendEndCompositingItem() {
-  if (display_item_list_->RetainsIndividualDisplayItems()) {
-    display_item_list_
-        ->CreateAndAppendPairedEndItem<cc::EndCompositingDisplayItem>();
-  } else {
-    display_item_list_->RasterIntoCanvas(cc::EndCompositingDisplayItem());
-  }
+  display_item_list_
+      ->CreateAndAppendPairedEndItem<cc::EndCompositingDisplayItem>();
 }
 
 void WebDisplayItemListImpl::appendFilterItem(
     const cc::FilterOperations& filters,
     const blink::WebFloatRect& filter_bounds) {
-  if (display_item_list_->RetainsIndividualDisplayItems()) {
-    display_item_list_
-        ->CreateAndAppendPairedBeginItemWithVisualRect<cc::FilterDisplayItem>(
-            gfx::ToEnclosingRect(filter_bounds), filters, filter_bounds);
-  } else {
-    cc::FilterDisplayItem item(filters, filter_bounds);
-    display_item_list_->RasterIntoCanvas(item);
-  }
+  display_item_list_
+      ->CreateAndAppendPairedBeginItemWithVisualRect<cc::FilterDisplayItem>(
+          gfx::ToEnclosingRect(filter_bounds), filters, filter_bounds);
 }
 
 void WebDisplayItemListImpl::appendEndFilterItem() {
-  if (display_item_list_->RetainsIndividualDisplayItems()) {
-    display_item_list_
-        ->CreateAndAppendPairedEndItem<cc::EndFilterDisplayItem>();
-  } else {
-    display_item_list_->RasterIntoCanvas(cc::EndFilterDisplayItem());
-  }
+  display_item_list_->CreateAndAppendPairedEndItem<cc::EndFilterDisplayItem>();
 }
 
 void WebDisplayItemListImpl::appendScrollItem(
     const blink::WebSize& scroll_offset,
     ScrollContainerId) {
   SkMatrix44 matrix(SkMatrix44::kUninitialized_Constructor);
   matrix.setTranslate(-scroll_offset.width, -scroll_offset.height, 0);
-  // TODO(wkorman): Should we translate the visual rect as well?
+  // TODO(wkorman): http://crbug.com/633636 Should we translate the visual rect
+  // as well? Create a test case and investigate.
   appendTransformItem(matrix);
 }
 

cc/debug/rasterize_and_record_benchmark.cc

@@ -161,7 +161,7 @@ void RasterizeAndRecordBenchmark::RunOnLayer(PictureLayer* layer) {
         if (display_list->ShouldBeAnalyzedForSolidColor()) {
           gfx::Size layer_size = layer->paint_properties().bounds;
           skia::AnalysisCanvas canvas(layer_size.width(), layer_size.height());
-          display_list->Raster(&canvas, nullptr, gfx::Rect(), 1.f);
+          display_list->Raster(&canvas, nullptr, gfx::Rect(layer_size), 1.f);
         }
 
         if (memory_used) {

cc/debug/rasterize_and_record_benchmark.h

@@ -16,7 +16,6 @@
 #include "base/time/time.h"
 #include "cc/debug/micro_benchmark_controller.h"
 #include "cc/playback/recording_source.h"
-#include "ui/gfx/geometry/rect.h"
 
 namespace base {
 class DictionaryValue;
@@ -26,6 +25,7 @@ namespace cc {
 
 class LayerTreeHost;
 class Layer;
+
 class RasterizeAndRecordBenchmark : public MicroBenchmark {
  public:
   explicit RasterizeAndRecordBenchmark(

cc/layers/empty_content_layer_client.cc

@@ -31,7 +31,7 @@ gfx::Rect EmptyContentLayerClient::PaintableRegion() {
 scoped_refptr<DisplayItemList>
 EmptyContentLayerClient::PaintContentsToDisplayList(
     PaintingControlSetting painting_status) {
-  return DisplayItemList::Create(gfx::Rect(), DisplayItemListSettings());
+  return DisplayItemList::Create(DisplayItemListSettings());
 }
 
 bool EmptyContentLayerClient::FillsBoundsCompletely() const {

cc/layers/picture_image_layer.cc

@@ -66,7 +66,7 @@ scoped_refptr<DisplayItemList> PictureImageLayer::PaintContentsToDisplayList(
   settings.use_cached_picture =
       layer_tree_host()->settings().use_cached_picture_raster;
   scoped_refptr<DisplayItemList> display_list =
-      DisplayItemList::Create(PaintableRegion(), settings);
+      DisplayItemList::Create(settings);
 
   SkPictureRecorder recorder;
   SkCanvas* canvas =

cc/layers/picture_layer_impl_unittest.cc

@@ -270,7 +270,7 @@ class PictureLayerImplTest : public TestLayerTreeHostBase {
   void SetInitialDeviceScaleFactor(float device_scale_factor) {
     // Device scale factor is a per-tree property. However, tests can't directly
     // set the pending tree's device scale factor before the pending tree is
-    // created, and setting it after SetupPendingTreeis too late, since
+    // created, and setting it after SetupPendingTree is too late, since
     // draw properties will already have been updated on the tree. To handle
     // this, we initially set only the active tree's device scale factor, and we
     // copy this over to the pending tree inside SetupPendingTree.

cc/playback/discardable_image_map_unittest.cc

@@ -94,7 +94,7 @@ TEST_F(DiscardableImageMapTest, GetDiscardableImagesInRectTest) {
   {
     DiscardableImageMap::ScopedMetadataGenerator generator(&image_map,
                                                            visible_rect.size());
-    display_list->Raster(generator.canvas(), nullptr, visible_rect, 1.f);
+    display_list->Raster(generator.canvas(), nullptr, gfx::Rect(), 1.f);
   }
 
   for (int y = 0; y < 4; ++y) {
@@ -167,7 +167,7 @@ TEST_F(DiscardableImageMapTest, GetDiscardableImagesInRectNonZeroLayer) {
   {
     DiscardableImageMap::ScopedMetadataGenerator generator(&image_map,
                                                            layer_size);
-    display_list->Raster(generator.canvas(), nullptr, visible_rect, 1.f);
+    display_list->Raster(generator.canvas(), nullptr, gfx::Rect(), 1.f);
   }
 
   for (int y = 0; y < 4; ++y) {
@@ -263,7 +263,7 @@ TEST_F(DiscardableImageMapTest, GetDiscardableImagesInRectOnePixelQuery) {
   {
     DiscardableImageMap::ScopedMetadataGenerator generator(&image_map,
                                                            visible_rect.size());
-    display_list->Raster(generator.canvas(), nullptr, visible_rect, 1.f);
+    display_list->Raster(generator.canvas(), nullptr, gfx::Rect(), 1.f);
   }
 
   for (int y = 0; y < 4; ++y) {
@@ -302,7 +302,7 @@ TEST_F(DiscardableImageMapTest, GetDiscardableImagesInRectMassiveImage) {
   {
     DiscardableImageMap::ScopedMetadataGenerator generator(&image_map,
                                                            visible_rect.size());
-    display_list->Raster(generator.canvas(), nullptr, visible_rect, 1.f);
+    display_list->Raster(generator.canvas(), nullptr, gfx::Rect(), 1.f);
   }
   std::vector<PositionDrawImage> images =
       GetDiscardableImagesInRect(image_map, gfx::Rect(0, 0, 1, 1));