Raster display item lists via a visual rect RTree.

ui/views/view_unittest.cc

 // Copyright (c) 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 <map>
 
 #include "base/i18n/rtl.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/rand_util.h"
 #include "base/strings/string_util.h"
@@ skipping 502 matching lines @@
   v1->AddChildView(v11);
 
   // |v2| is not.
   TestView* v2 = new TestView;
   v2->SetBounds(3, 4, 6, 5);
   root_view->AddChildView(v2);
 
   // Paint "everything".
   gfx::Rect first_paint(1, 1);
   scoped_refptr<cc::DisplayItemList> list =
-      cc::DisplayItemList::Create(first_paint, cc::DisplayItemListSettings());
+      cc::DisplayItemList::Create(cc::DisplayItemListSettings());
   root_view->Paint(ui::PaintContext(list.get(), 1.f, first_paint));
 
   // The empty view has nothing to paint so it doesn't try build a cache, nor do
   // its children which would be clipped by its (empty) self.
   EXPECT_FALSE(v1->did_paint_);
   EXPECT_FALSE(v11->did_paint_);
   EXPECT_TRUE(v2->did_paint_);
 }
 
 TEST_F(ViewTest, PaintWithMovedViewUsesCache) {
   ScopedTestPaintWidget widget(CreateParams(Widget::InitParams::TYPE_POPUP));
   View* root_view = widget->GetRootView();
   TestView* v1 = new TestView;
   v1->SetBounds(10, 11, 12, 13);
   root_view->AddChildView(v1);
 
   // Paint everything once, since it has to build its cache. Then we can test
   // invalidation.
   gfx::Rect pixel_rect = gfx::Rect(1, 1);
   float device_scale_factor = 1.f;
   scoped_refptr<cc::DisplayItemList> list =
-      cc::DisplayItemList::Create(pixel_rect, cc::DisplayItemListSettings());
+      cc::DisplayItemList::Create(cc::DisplayItemListSettings());
   root_view->Paint(
       ui::PaintContext(list.get(), device_scale_factor, pixel_rect));
   EXPECT_TRUE(v1->did_paint_);
   v1->Reset();
   // The visual rects for (clip, drawing, transform) should be in layer space.
   gfx::Rect expected_visual_rect_in_layer_space(10, 11, 12, 13);
   int item_index = 3;
   EXPECT_EQ(expected_visual_rect_in_layer_space,
             list->VisualRectForTesting(item_index++));
   EXPECT_EQ(expected_visual_rect_in_layer_space,
             list->VisualRectForTesting(item_index++));
   EXPECT_EQ(expected_visual_rect_in_layer_space,
             list->VisualRectForTesting(item_index));
 
   // If invalidation doesn't intersect v1, we paint with the cache.
-  list = cc::DisplayItemList::Create(pixel_rect, cc::DisplayItemListSettings());
+  list = cc::DisplayItemList::Create(cc::DisplayItemListSettings());
   root_view->Paint(
       ui::PaintContext(list.get(), device_scale_factor, pixel_rect));
   EXPECT_FALSE(v1->did_paint_);
   v1->Reset();
 
   // If invalidation does intersect v1, we don't paint with the cache.
-  list = cc::DisplayItemList::Create(pixel_rect, cc::DisplayItemListSettings());
+  list = cc::DisplayItemList::Create(cc::DisplayItemListSettings());
   root_view->Paint(
       ui::PaintContext(list.get(), device_scale_factor, v1->bounds()));
   EXPECT_TRUE(v1->did_paint_);
   v1->Reset();
 
   // Moving the view should still use the cache when the invalidation doesn't
   // intersect v1.
-  list = cc::DisplayItemList::Create(pixel_rect, cc::DisplayItemListSettings());
+  list = cc::DisplayItemList::Create(cc::DisplayItemListSettings());
   v1->SetX(9);
   root_view->Paint(
       ui::PaintContext(list.get(), device_scale_factor, pixel_rect));
   EXPECT_FALSE(v1->did_paint_);
   v1->Reset();
   item_index = 3;
   expected_visual_rect_in_layer_space.SetRect(9, 11, 12, 13);
   EXPECT_EQ(expected_visual_rect_in_layer_space,
             list->VisualRectForTesting(item_index++));
   EXPECT_EQ(expected_visual_rect_in_layer_space,
             list->VisualRectForTesting(item_index++));
   EXPECT_EQ(expected_visual_rect_in_layer_space,
             list->VisualRectForTesting(item_index));
 
   // Moving the view should not use the cache when painting without
   // invalidation.
-  list = cc::DisplayItemList::Create(pixel_rect, cc::DisplayItemListSettings());
+  list = cc::DisplayItemList::Create(cc::DisplayItemListSettings());
   v1->SetX(8);
   root_view->Paint(ui::PaintContext(
       ui::PaintContext(list.get(), device_scale_factor, pixel_rect),
       ui::PaintContext::CLONE_WITHOUT_INVALIDATION));
   EXPECT_TRUE(v1->did_paint_);
   v1->Reset();
   item_index = 3;
   expected_visual_rect_in_layer_space.SetRect(8, 11, 12, 13);
   EXPECT_EQ(expected_visual_rect_in_layer_space,
             list->VisualRectForTesting(item_index++));
   EXPECT_EQ(expected_visual_rect_in_layer_space,
             list->VisualRectForTesting(item_index++));
   EXPECT_EQ(expected_visual_rect_in_layer_space,
             list->VisualRectForTesting(item_index));
 }
 
 TEST_F(ViewTest, PaintWithMovedViewUsesCacheInRTL) {
   ScopedRTL rtl;
   ScopedTestPaintWidget widget(CreateParams(Widget::InitParams::TYPE_POPUP));
   View* root_view = widget->GetRootView();
   TestView* v1 = new TestView;
   v1->SetBounds(10, 11, 12, 13);
   root_view->AddChildView(v1);
 
   // Paint everything once, since it has to build its cache. Then we can test
   // invalidation.
   gfx::Rect pixel_rect = gfx::Rect(1, 1);
   float device_scale_factor = 1.f;
   scoped_refptr<cc::DisplayItemList> list =
-      cc::DisplayItemList::Create(pixel_rect, cc::DisplayItemListSettings());
+      cc::DisplayItemList::Create(cc::DisplayItemListSettings());
   root_view->Paint(
       ui::PaintContext(list.get(), device_scale_factor, pixel_rect));
   EXPECT_TRUE(v1->did_paint_);
   v1->Reset();
   // The visual rects for (clip, drawing, transform) should be in layer space.
   // x: 25 - 10(x) - 12(width) = 3
   gfx::Rect expected_visual_rect_in_layer_space(3, 11, 12, 13);
   int item_index = 3;
   EXPECT_EQ(expected_visual_rect_in_layer_space,
             list->VisualRectForTesting(item_index++));
   EXPECT_EQ(expected_visual_rect_in_layer_space,
             list->VisualRectForTesting(item_index++));
   EXPECT_EQ(expected_visual_rect_in_layer_space,
             list->VisualRectForTesting(item_index));
 
   // If invalidation doesn't intersect v1, we paint with the cache.
-  list = cc::DisplayItemList::Create(pixel_rect, cc::DisplayItemListSettings());
+  list = cc::DisplayItemList::Create(cc::DisplayItemListSettings());
   root_view->Paint(
       ui::PaintContext(list.get(), device_scale_factor, pixel_rect));
   EXPECT_FALSE(v1->did_paint_);
   v1->Reset();
 
   // If invalidation does intersect v1, we don't paint with the cache.
-  list = cc::DisplayItemList::Create(pixel_rect, cc::DisplayItemListSettings());
+  list = cc::DisplayItemList::Create(cc::DisplayItemListSettings());
   root_view->Paint(
       ui::PaintContext(list.get(), device_scale_factor, v1->bounds()));
   EXPECT_TRUE(v1->did_paint_);
   v1->Reset();
 
   // Moving the view should still use the cache when the invalidation doesn't
   // intersect v1.
-  list = cc::DisplayItemList::Create(pixel_rect, cc::DisplayItemListSettings());
+  list = cc::DisplayItemList::Create(cc::DisplayItemListSettings());
   v1->SetX(9);
   root_view->Paint(
       ui::PaintContext(list.get(), device_scale_factor, pixel_rect));
   EXPECT_FALSE(v1->did_paint_);
   v1->Reset();
   item_index = 3;
   // x: 25 - 9(x) - 12(width) = 4
   expected_visual_rect_in_layer_space.SetRect(4, 11, 12, 13);
   EXPECT_EQ(expected_visual_rect_in_layer_space,
             list->VisualRectForTesting(item_index++));
   EXPECT_EQ(expected_visual_rect_in_layer_space,
             list->VisualRectForTesting(item_index++));
   EXPECT_EQ(expected_visual_rect_in_layer_space,
             list->VisualRectForTesting(item_index));
 
   // Moving the view should not use the cache when painting without
   // invalidation.
-  list = cc::DisplayItemList::Create(pixel_rect, cc::DisplayItemListSettings());
+  list = cc::DisplayItemList::Create(cc::DisplayItemListSettings());
   v1->SetX(8);
   root_view->Paint(ui::PaintContext(
       ui::PaintContext(list.get(), device_scale_factor, pixel_rect),
       ui::PaintContext::CLONE_WITHOUT_INVALIDATION));
   EXPECT_TRUE(v1->did_paint_);
   v1->Reset();
   item_index = 3;
   // x: 25 - 8(x) - 12(width) = 5
   expected_visual_rect_in_layer_space.SetRect(5, 11, 12, 13);
   EXPECT_EQ(expected_visual_rect_in_layer_space,
@@ skipping 13 matching lines @@
   root_view->AddChildView(v1);
 
   TestView* v2 = new TestView;
   v2->SetBounds(3, 4, 6, 5);
   v1->AddChildView(v2);
 
   // Paint everything once, since it has to build its cache. Then we can test
   // invalidation.
   gfx::Rect first_paint(1, 1);
   scoped_refptr<cc::DisplayItemList> list =
-      cc::DisplayItemList::Create(first_paint, cc::DisplayItemListSettings());
+      cc::DisplayItemList::Create(cc::DisplayItemListSettings());
   root_view->Paint(ui::PaintContext(list.get(), 1.f, first_paint));
   v1->Reset();
   v2->Reset();
 
   gfx::Rect paint_area(1, 1);
   gfx::Rect root_area(root_view->size());
-  list = cc::DisplayItemList::Create(root_area, cc::DisplayItemListSettings());
+  list = cc::DisplayItemList::Create(cc::DisplayItemListSettings());
 
   // With a known invalidation, v1 and v2 are not painted.
   EXPECT_FALSE(v1->did_paint_);
   EXPECT_FALSE(v2->did_paint_);
   root_view->Paint(ui::PaintContext(list.get(), 1.f, paint_area));
   EXPECT_FALSE(v1->did_paint_);
   EXPECT_FALSE(v2->did_paint_);
 
   // With unknown invalidation, v1 and v2 are painted.
   root_view->Paint(
@@ skipping 12 matching lines @@
   root_view->AddChildView(v1);
 
   TestView* v2 = new TestView;
   v2->SetBounds(3, 4, 6, 5);
   v1->AddChildView(v2);
 
   // Paint everything once, since it has to build its cache. Then we can test
   // invalidation.
   gfx::Rect first_paint(1, 1);
   scoped_refptr<cc::DisplayItemList> list =
-      cc::DisplayItemList::Create(first_paint, cc::DisplayItemListSettings());
+      cc::DisplayItemList::Create(cc::DisplayItemListSettings());
   root_view->Paint(ui::PaintContext(list.get(), 1.f, first_paint));
   v1->Reset();
   v2->Reset();
 
   gfx::Rect paint_area(25, 26);
   gfx::Rect root_area(root_view->size());
-  list = cc::DisplayItemList::Create(root_area, cc::DisplayItemListSettings());
+  list = cc::DisplayItemList::Create(cc::DisplayItemListSettings());
 
   EXPECT_FALSE(v1->did_paint_);
   EXPECT_FALSE(v2->did_paint_);
   root_view->Paint(ui::PaintContext(list.get(), 1.f, paint_area));
   EXPECT_TRUE(v1->did_paint_);
   EXPECT_TRUE(v2->did_paint_);
 }
 
 TEST_F(ViewTest, PaintContainsChildrenInRTL) {
   ScopedRTL rtl;
@@ skipping 16 matching lines @@
 
   v2->SetPaintToLayer(true);
   // x: 25 - 10(parent x) - 3(x) - 6(width) = 6
   EXPECT_EQ(gfx::Rect(6, 15, 6, 5), v2->layer()->bounds());
   v2->SetPaintToLayer(false);
 
   // Paint everything once, since it has to build its cache. Then we can test
   // invalidation.
   gfx::Rect first_paint(1, 1);
   scoped_refptr<cc::DisplayItemList> list =
-      cc::DisplayItemList::Create(first_paint, cc::DisplayItemListSettings());
+      cc::DisplayItemList::Create(cc::DisplayItemListSettings());
   root_view->Paint(ui::PaintContext(list.get(), 1.f, first_paint));
   v1->Reset();
   v2->Reset();
 
   gfx::Rect paint_area(25, 26);
   gfx::Rect root_area(root_view->size());
-  list = cc::DisplayItemList::Create(root_area, cc::DisplayItemListSettings());
+  list = cc::DisplayItemList::Create(cc::DisplayItemListSettings());
 
   EXPECT_FALSE(v1->did_paint_);
   EXPECT_FALSE(v2->did_paint_);
   root_view->Paint(ui::PaintContext(list.get(), 1.f, paint_area));
   EXPECT_TRUE(v1->did_paint_);
   EXPECT_TRUE(v2->did_paint_);
 }
 
 TEST_F(ViewTest, PaintIntersectsChildren) {
   ScopedTestPaintWidget widget(CreateParams(Widget::InitParams::TYPE_POPUP));
   View* root_view = widget->GetRootView();
 
   TestView* v1 = new TestView;
   v1->SetBounds(10, 11, 12, 13);
   root_view->AddChildView(v1);
 
   TestView* v2 = new TestView;
   v2->SetBounds(3, 4, 6, 5);
   v1->AddChildView(v2);
 
   // Paint everything once, since it has to build its cache. Then we can test
   // invalidation.
   gfx::Rect first_paint(1, 1);
   scoped_refptr<cc::DisplayItemList> list =
-      cc::DisplayItemList::Create(first_paint, cc::DisplayItemListSettings());
+      cc::DisplayItemList::Create(cc::DisplayItemListSettings());
   root_view->Paint(ui::PaintContext(list.get(), 1.f, first_paint));
   v1->Reset();
   v2->Reset();
 
   gfx::Rect paint_area(9, 10, 5, 6);
   gfx::Rect root_area(root_view->size());
-  list = cc::DisplayItemList::Create(root_area, cc::DisplayItemListSettings());
+  list = cc::DisplayItemList::Create(cc::DisplayItemListSettings());
 
   EXPECT_FALSE(v1->did_paint_);
   EXPECT_FALSE(v2->did_paint_);
   root_view->Paint(ui::PaintContext(list.get(), 1.f, paint_area));
   EXPECT_TRUE(v1->did_paint_);
   EXPECT_TRUE(v2->did_paint_);
 }
 
 TEST_F(ViewTest, PaintIntersectsChildrenInRTL) {
   ScopedRTL rtl;
@@ skipping 16 matching lines @@
 
   v2->SetPaintToLayer(true);
   // x: 25 - 10(parent x) - 3(x) - 6(width) = 6
   EXPECT_EQ(gfx::Rect(6, 15, 6, 5), v2->layer()->bounds());
   v2->SetPaintToLayer(false);
 
   // Paint everything once, since it has to build its cache. Then we can test
   // invalidation.
   gfx::Rect first_paint(1, 1);
   scoped_refptr<cc::DisplayItemList> list =
-      cc::DisplayItemList::Create(first_paint, cc::DisplayItemListSettings());
+      cc::DisplayItemList::Create(cc::DisplayItemListSettings());
   root_view->Paint(ui::PaintContext(list.get(), 1.f, first_paint));
   v1->Reset();
   v2->Reset();
 
   gfx::Rect paint_area(2, 10, 5, 6);
   gfx::Rect root_area(root_view->size());
-  list = cc::DisplayItemList::Create(root_area, cc::DisplayItemListSettings());
+  list = cc::DisplayItemList::Create(cc::DisplayItemListSettings());
 
   EXPECT_FALSE(v1->did_paint_);
   EXPECT_FALSE(v2->did_paint_);
   root_view->Paint(ui::PaintContext(list.get(), 1.f, paint_area));
   EXPECT_TRUE(v1->did_paint_);
   EXPECT_TRUE(v2->did_paint_);
 }
 
 TEST_F(ViewTest, PaintIntersectsChildButNotGrandChild) {
   ScopedTestPaintWidget widget(CreateParams(Widget::InitParams::TYPE_POPUP));
   View* root_view = widget->GetRootView();
 
   TestView* v1 = new TestView;
   v1->SetBounds(10, 11, 12, 13);
   root_view->AddChildView(v1);
 
   TestView* v2 = new TestView;
   v2->SetBounds(3, 4, 6, 5);
   v1->AddChildView(v2);
 
   // Paint everything once, since it has to build its cache. Then we can test
   // invalidation.
   gfx::Rect first_paint(1, 1);
   scoped_refptr<cc::DisplayItemList> list =
-      cc::DisplayItemList::Create(first_paint, cc::DisplayItemListSettings());
+      cc::DisplayItemList::Create(cc::DisplayItemListSettings());
   root_view->Paint(ui::PaintContext(list.get(), 1.f, first_paint));
   v1->Reset();
   v2->Reset();
 
   gfx::Rect paint_area(9, 10, 2, 3);
   gfx::Rect root_area(root_view->size());
-  list = cc::DisplayItemList::Create(root_area, cc::DisplayItemListSettings());
+  list = cc::DisplayItemList::Create(cc::DisplayItemListSettings());
 
   EXPECT_FALSE(v1->did_paint_);
   EXPECT_FALSE(v2->did_paint_);
   root_view->Paint(ui::PaintContext(list.get(), 1.f, paint_area));
   EXPECT_TRUE(v1->did_paint_);
   EXPECT_FALSE(v2->did_paint_);
 }
 
 TEST_F(ViewTest, PaintIntersectsChildButNotGrandChildInRTL) {
   ScopedRTL rtl;
@@ skipping 16 matching lines @@
 
   v2->SetPaintToLayer(true);
   // x: 25 - 10(parent x) - 3(x) - 6(width) = 6
   EXPECT_EQ(gfx::Rect(6, 15, 6, 5), v2->layer()->bounds());
   v2->SetPaintToLayer(false);
 
   // Paint everything once, since it has to build its cache. Then we can test
   // invalidation.
   gfx::Rect first_paint(1, 1);
   scoped_refptr<cc::DisplayItemList> list =
-      cc::DisplayItemList::Create(first_paint, cc::DisplayItemListSettings());
+      cc::DisplayItemList::Create(cc::DisplayItemListSettings());
   root_view->Paint(ui::PaintContext(list.get(), 1.f, first_paint));
   v1->Reset();
   v2->Reset();
 
   gfx::Rect paint_area(2, 10, 2, 3);
   gfx::Rect root_area(root_view->size());
-  list = cc::DisplayItemList::Create(root_area, cc::DisplayItemListSettings());
+  list = cc::DisplayItemList::Create(cc::DisplayItemListSettings());
 
   EXPECT_FALSE(v1->did_paint_);
   EXPECT_FALSE(v2->did_paint_);
   root_view->Paint(ui::PaintContext(list.get(), 1.f, paint_area));
   EXPECT_TRUE(v1->did_paint_);
   EXPECT_FALSE(v2->did_paint_);
 }
 
 TEST_F(ViewTest, PaintIntersectsNoChildren) {
   ScopedTestPaintWidget widget(CreateParams(Widget::InitParams::TYPE_POPUP));
   View* root_view = widget->GetRootView();
 
   TestView* v1 = new TestView;
   v1->SetBounds(10, 11, 12, 13);
   root_view->AddChildView(v1);
 
   TestView* v2 = new TestView;
   v2->SetBounds(3, 4, 6, 5);
   v1->AddChildView(v2);
 
   // Paint everything once, since it has to build its cache. Then we can test
   // invalidation.
   gfx::Rect first_paint(1, 1);
   scoped_refptr<cc::DisplayItemList> list =
-      cc::DisplayItemList::Create(first_paint, cc::DisplayItemListSettings());
+      cc::DisplayItemList::Create(cc::DisplayItemListSettings());
   root_view->Paint(ui::PaintContext(list.get(), 1.f, first_paint));
   v1->Reset();
   v2->Reset();
 
   gfx::Rect paint_area(9, 10, 2, 1);
   gfx::Rect root_area(root_view->size());
-  list = cc::DisplayItemList::Create(root_area, cc::DisplayItemListSettings());
+  list = cc::DisplayItemList::Create(cc::DisplayItemListSettings());
 
   EXPECT_FALSE(v1->did_paint_);
   EXPECT_FALSE(v2->did_paint_);
   root_view->Paint(ui::PaintContext(list.get(), 1.f, paint_area));
   EXPECT_FALSE(v1->did_paint_);
   EXPECT_FALSE(v2->did_paint_);
 }
 
 TEST_F(ViewTest, PaintIntersectsNoChildrenInRTL) {
   ScopedRTL rtl;
@@ skipping 16 matching lines @@
 
   v2->SetPaintToLayer(true);
   // x: 25 - 10(parent x) - 3(x) - 6(width) = 6
   EXPECT_EQ(gfx::Rect(6, 15, 6, 5), v2->layer()->bounds());
   v2->SetPaintToLayer(false);
 
   // Paint everything once, since it has to build its cache. Then we can test
   // invalidation.
   gfx::Rect first_paint(1, 1);
   scoped_refptr<cc::DisplayItemList> list =
-      cc::DisplayItemList::Create(first_paint, cc::DisplayItemListSettings());
+      cc::DisplayItemList::Create(cc::DisplayItemListSettings());
   root_view->Paint(ui::PaintContext(list.get(), 1.f, first_paint));
   v1->Reset();
   v2->Reset();
 
   gfx::Rect paint_area(2, 10, 2, 1);
   gfx::Rect root_area(root_view->size());
-  list = cc::DisplayItemList::Create(root_area, cc::DisplayItemListSettings());
+  list = cc::DisplayItemList::Create(cc::DisplayItemListSettings());
 
   EXPECT_FALSE(v1->did_paint_);
   EXPECT_FALSE(v2->did_paint_);
   root_view->Paint(ui::PaintContext(list.get(), 1.f, paint_area));
   EXPECT_FALSE(v1->did_paint_);
   EXPECT_FALSE(v2->did_paint_);
 }
 
 TEST_F(ViewTest, PaintIntersectsOneChild) {
   ScopedTestPaintWidget widget(CreateParams(Widget::InitParams::TYPE_POPUP));
   View* root_view = widget->GetRootView();
 
   TestView* v1 = new TestView;
   v1->SetBounds(10, 11, 12, 13);
   root_view->AddChildView(v1);
 
   TestView* v2 = new TestView;
   v2->SetBounds(3, 4, 6, 5);
   root_view->AddChildView(v2);
 
   // Paint everything once, since it has to build its cache. Then we can test
   // invalidation.
   gfx::Rect first_paint(1, 1);
   scoped_refptr<cc::DisplayItemList> list =
-      cc::DisplayItemList::Create(first_paint, cc::DisplayItemListSettings());
+      cc::DisplayItemList::Create(cc::DisplayItemListSettings());
   root_view->Paint(ui::PaintContext(list.get(), 1.f, first_paint));
   v1->Reset();
   v2->Reset();
 
   // Intersects with the second child only.
   gfx::Rect paint_area(3, 3, 1, 2);
   gfx::Rect root_area(root_view->size());
-  list = cc::DisplayItemList::Create(root_area, cc::DisplayItemListSettings());
+  list = cc::DisplayItemList::Create(cc::DisplayItemListSettings());
 
   EXPECT_FALSE(v1->did_paint_);
   EXPECT_FALSE(v2->did_paint_);
   root_view->Paint(ui::PaintContext(list.get(), 1.f, paint_area));
   EXPECT_FALSE(v1->did_paint_);
   EXPECT_TRUE(v2->did_paint_);
 
   // Intersects with the first child only.
   paint_area = gfx::Rect(20, 10, 1, 2);
 
@@ skipping 27 matching lines @@
 
   v2->SetPaintToLayer(true);
   // x: 25 - 3(x) - 6(width) = 16
   EXPECT_EQ(gfx::Rect(16, 4, 6, 5), v2->layer()->bounds());
   v2->SetPaintToLayer(false);
 
   // Paint everything once, since it has to build its cache. Then we can test
   // invalidation.
   gfx::Rect first_paint(1, 1);
   scoped_refptr<cc::DisplayItemList> list =
-      cc::DisplayItemList::Create(first_paint, cc::DisplayItemListSettings());
+      cc::DisplayItemList::Create(cc::DisplayItemListSettings());
   root_view->Paint(ui::PaintContext(list.get(), 1.f, first_paint));
   v1->Reset();
   v2->Reset();
 
   // Intersects with the first child only.
   gfx::Rect paint_area(3, 10, 1, 2);
   gfx::Rect root_area(root_view->size());
-  list = cc::DisplayItemList::Create(root_area, cc::DisplayItemListSettings());
+  list = cc::DisplayItemList::Create(cc::DisplayItemListSettings());
 
   EXPECT_FALSE(v1->did_paint_);
   EXPECT_FALSE(v2->did_paint_);
   root_view->Paint(ui::PaintContext(list.get(), 1.f, paint_area));
   EXPECT_TRUE(v1->did_paint_);
   EXPECT_FALSE(v2->did_paint_);
 
   // Intersects with the second child only.
   paint_area = gfx::Rect(21, 3, 1, 2);
 
@@ skipping 16 matching lines @@
   root_view->AddChildView(v1);
 
   TestView* v2 = new TestView;
   v2->SetBounds(3, 4, 6, 5);
   v1->AddChildView(v2);
 
   // Paint everything once, since it has to build its cache. Then we can test
   // invalidation.
   gfx::Rect first_paint(1, 1);
   scoped_refptr<cc::DisplayItemList> list =
-      cc::DisplayItemList::Create(first_paint, cc::DisplayItemListSettings());
+      cc::DisplayItemList::Create(cc::DisplayItemListSettings());
   v1->Paint(ui::PaintContext(list.get(), 1.f, first_paint));
   v1->Reset();
   v2->Reset();
 
   {
     gfx::Rect paint_area(25, 26);
     gfx::Rect view_area(root_view->size());
     scoped_refptr<cc::DisplayItemList> list =
-        cc::DisplayItemList::Create(view_area, cc::DisplayItemListSettings());
+        cc::DisplayItemList::Create(cc::DisplayItemListSettings());
 
     // The promoted views are not painted as they are separate paint roots.
     root_view->Paint(ui::PaintContext(list.get(), 1.f, paint_area));
     EXPECT_FALSE(v1->did_paint_);
     EXPECT_FALSE(v2->did_paint_);
   }
 
   {
     gfx::Rect paint_area(1, 1);
     gfx::Rect view_area(v1->size());
     scoped_refptr<cc::DisplayItemList> list =
-        cc::DisplayItemList::Create(view_area, cc::DisplayItemListSettings());
+        cc::DisplayItemList::Create(cc::DisplayItemListSettings());
 
     // The |v1| view is painted. If it used its offset incorrect, it would think
     // its at (10,11) instead of at (0,0) since it is the paint root.
     v1->Paint(ui::PaintContext(list.get(), 1.f, paint_area));
     EXPECT_TRUE(v1->did_paint_);
     EXPECT_FALSE(v2->did_paint_);
   }
 
   v1->Reset();
 
   {
     gfx::Rect paint_area(3, 3, 1, 2);
     gfx::Rect view_area(v1->size());
     scoped_refptr<cc::DisplayItemList> list =
-        cc::DisplayItemList::Create(view_area, cc::DisplayItemListSettings());
+        cc::DisplayItemList::Create(cc::DisplayItemListSettings());
 
     // The |v2| view is painted also. If it used its offset incorrect, it would
     // think its at (13,15) instead of at (3,4) since |v1| is the paint root.
     v1->Paint(ui::PaintContext(list.get(), 1.f, paint_area));
     EXPECT_TRUE(v1->did_paint_);
     EXPECT_TRUE(v2->did_paint_);
   }
 }
 
 // A derived class for testing paint.
@@ skipping 26 matching lines @@
 
   // Set bounds for |v1| such that it has an offset to its parent and only part
   // of it is visible. The visible bounds does not intersect with |root_view|'s
   // bounds.
   v1->SetBounds(0, -1000, 100, 1100);
   root_view->AddChildView(v1);
   EXPECT_EQ(gfx::Rect(0, 0, 100, 1100), v1->GetLocalBounds());
   EXPECT_EQ(gfx::Rect(0, 1000, 100, 100), v1->GetVisibleBounds());
 
   scoped_refptr<cc::DisplayItemList> list =
-      cc::DisplayItemList::Create(gfx::Rect(), cc::DisplayItemListSettings());
+      cc::DisplayItemList::Create(cc::DisplayItemListSettings());
   ui::PaintContext context(list.get(), 1.f, gfx::Rect());
 
   v1->Paint(context);
   EXPECT_TRUE(v1->did_paint_);
 
   // Check that the canvas produced by |v1| for paint contains all of |v1|'s
   // visible bounds.
   EXPECT_TRUE(v1->canvas_bounds().Contains(v1->GetVisibleBounds()));
 }
 
@@ skipping 3099 matching lines @@
 
   // The View should continue receiving events after the |handler| is deleted.
   v->Reset();
   ui::MouseEvent released(ui::ET_MOUSE_RELEASED, gfx::Point(), gfx::Point(),
                           ui::EventTimeForNow(), 0, 0);
   root->OnMouseReleased(released);
   EXPECT_EQ(ui::ET_MOUSE_RELEASED, v->last_mouse_event_type_);
 }
 
 }  // namespace views