ui: Introduce CanvasPainter, remove PaintContext(gfx::Canvas*).

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/memory/scoped_ptr.h"
 #include "base/rand_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
+#include "cc/playback/display_item_list.h"
+#include "cc/playback/display_item_list_settings.h"
 #include "ui/base/accelerators/accelerator.h"
 #include "ui/base/clipboard/clipboard.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/compositor/compositor.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animator.h"
 #include "ui/compositor/paint_context.h"
 #include "ui/compositor/test/draw_waiter_for_test.h"
 #include "ui/events/event.h"
 #include "ui/events/event_utils.h"
@@ skipping 416 matching lines @@
   root_view->SetBounds(0, 0, 25, 26);
 
   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);
 
-  gfx::Canvas canvas(root_view->size(), 1.f, true);
+  // 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());
+  root_view->Paint(ui::PaintContext(list.get(), 1.f, first_paint, 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());
 
+  // 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(&canvas));
-  EXPECT_TRUE(v1->did_paint_);
-  EXPECT_TRUE(v2->did_paint_);
-
-  v1->Reset();
-  v2->Reset();
+  root_view->Paint(ui::PaintContext(list.get(), 1.f, root_area, paint_area));
   EXPECT_FALSE(v1->did_paint_);
   EXPECT_FALSE(v2->did_paint_);
+
+  // With unknown invalidation, v1 and v2 are painted.
   root_view->Paint(
-      ui::PaintContext(ui::PaintContext(&canvas, paint_area),
+      ui::PaintContext(ui::PaintContext(list.get(), 1.f, root_area, paint_area),
                        ui::PaintContext::CLONE_WITHOUT_INVALIDATION));
   EXPECT_TRUE(v1->did_paint_);
   EXPECT_TRUE(v2->did_paint_);
 }
 
 TEST_F(ViewTest, PaintContainsChildren) {
   Widget* widget = new Widget;
   Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_POPUP);
   widget->Init(params);
   View* root_view = widget->GetRootView();
   root_view->SetBounds(0, 0, 25, 26);
 
   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);
 
-  gfx::Canvas canvas(root_view->size(), 1.f, true);
+  // 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());
+  root_view->Paint(ui::PaintContext(list.get(), 1.f, first_paint, 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());
 
   EXPECT_FALSE(v1->did_paint_);
   EXPECT_FALSE(v2->did_paint_);
-  root_view->Paint(ui::PaintContext(&canvas, paint_area));
+  root_view->Paint(ui::PaintContext(list.get(), 1.f, root_area, paint_area));
   EXPECT_TRUE(v1->did_paint_);
   EXPECT_TRUE(v2->did_paint_);
 }
 
 TEST_F(ViewTest, PaintContainsChildrenInRTL) {
   ScopedRTL rtl;
 
   Widget* widget = new Widget;
   Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_POPUP);
   widget->Init(params);
@@ skipping 12 matching lines @@
   v1->SetPaintToLayer(true);
   // x: 25 - 10(x) - 12(width) = 3
   EXPECT_EQ(gfx::Rect(3, 11, 12, 13), v1->layer()->bounds());
   v1->SetPaintToLayer(false);
 
   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);
 
-  gfx::Canvas canvas(root_view->size(), 1.f, true);
+  // 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());
+  root_view->Paint(ui::PaintContext(list.get(), 1.f, first_paint, 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());
 
   EXPECT_FALSE(v1->did_paint_);
   EXPECT_FALSE(v2->did_paint_);
-  root_view->Paint(ui::PaintContext(&canvas, paint_area));
+  root_view->Paint(ui::PaintContext(list.get(), 1.f, root_area, paint_area));
   EXPECT_TRUE(v1->did_paint_);
   EXPECT_TRUE(v2->did_paint_);
 }
 
 TEST_F(ViewTest, PaintIntersectsChildren) {
   Widget* widget = new Widget;
   Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_POPUP);
   widget->Init(params);
   View* root_view = widget->GetRootView();
   root_view->SetBounds(0, 0, 25, 26);
 
   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);
 
-  gfx::Canvas canvas(root_view->size(), 1.f, true);
+  // 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());
+  root_view->Paint(ui::PaintContext(list.get(), 1.f, first_paint, 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());
 
   EXPECT_FALSE(v1->did_paint_);
   EXPECT_FALSE(v2->did_paint_);
-  root_view->Paint(ui::PaintContext(&canvas, paint_area));
+  root_view->Paint(ui::PaintContext(list.get(), 1.f, root_area, paint_area));
   EXPECT_TRUE(v1->did_paint_);
   EXPECT_TRUE(v2->did_paint_);
 }
 
 TEST_F(ViewTest, PaintIntersectsChildrenInRTL) {
   ScopedRTL rtl;
 
   Widget* widget = new Widget;
   Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_POPUP);
   widget->Init(params);
@@ skipping 12 matching lines @@
   v1->SetPaintToLayer(true);
   // x: 25 - 10(x) - 12(width) = 3
   EXPECT_EQ(gfx::Rect(3, 11, 12, 13), v1->layer()->bounds());
   v1->SetPaintToLayer(false);
 
   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);
 
-  gfx::Canvas canvas(root_view->size(), 1.f, true);
+  // 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());
+  root_view->Paint(ui::PaintContext(list.get(), 1.f, first_paint, 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());
 
   EXPECT_FALSE(v1->did_paint_);
   EXPECT_FALSE(v2->did_paint_);
-  root_view->Paint(ui::PaintContext(&canvas, paint_area));
+  root_view->Paint(ui::PaintContext(list.get(), 1.f, root_area, paint_area));
   EXPECT_TRUE(v1->did_paint_);
   EXPECT_TRUE(v2->did_paint_);
 }
 
 TEST_F(ViewTest, PaintIntersectsChildButNotGrandChild) {
   Widget* widget = new Widget;
   Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_POPUP);
   widget->Init(params);
   View* root_view = widget->GetRootView();
   root_view->SetBounds(0, 0, 25, 26);
 
   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);
 
-  gfx::Canvas canvas(root_view->size(), 1.f, true);
+  // 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());
+  root_view->Paint(ui::PaintContext(list.get(), 1.f, first_paint, 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());
 
   EXPECT_FALSE(v1->did_paint_);
   EXPECT_FALSE(v2->did_paint_);
-  root_view->Paint(ui::PaintContext(&canvas, paint_area));
+  root_view->Paint(ui::PaintContext(list.get(), 1.f, root_area, paint_area));
   EXPECT_TRUE(v1->did_paint_);
   EXPECT_FALSE(v2->did_paint_);
 }
 
 TEST_F(ViewTest, PaintIntersectsChildButNotGrandChildInRTL) {
   ScopedRTL rtl;
 
   Widget* widget = new Widget;
   Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_POPUP);
   widget->Init(params);
@@ skipping 12 matching lines @@
   v1->SetPaintToLayer(true);
   // x: 25 - 10(x) - 12(width) = 3
   EXPECT_EQ(gfx::Rect(3, 11, 12, 13), v1->layer()->bounds());
   v1->SetPaintToLayer(false);
 
   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);
 
-  gfx::Canvas canvas(root_view->size(), 1.f, true);
+  // 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());
+  root_view->Paint(ui::PaintContext(list.get(), 1.f, first_paint, 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());
 
   EXPECT_FALSE(v1->did_paint_);
   EXPECT_FALSE(v2->did_paint_);
-  root_view->Paint(ui::PaintContext(&canvas, paint_area));
+  root_view->Paint(ui::PaintContext(list.get(), 1.f, root_area, paint_area));
   EXPECT_TRUE(v1->did_paint_);
   EXPECT_FALSE(v2->did_paint_);
 }
 
 TEST_F(ViewTest, PaintIntersectsNoChildren) {
   Widget* widget = new Widget;
   Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_POPUP);
   widget->Init(params);
   View* root_view = widget->GetRootView();
   root_view->SetBounds(0, 0, 25, 26);
 
   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);
 
-  gfx::Canvas canvas(root_view->size(), 1.f, true);
+  // 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());
+  root_view->Paint(ui::PaintContext(list.get(), 1.f, first_paint, 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());
 
   EXPECT_FALSE(v1->did_paint_);
   EXPECT_FALSE(v2->did_paint_);
-  root_view->Paint(ui::PaintContext(&canvas, paint_area));
+  root_view->Paint(ui::PaintContext(list.get(), 1.f, root_area, paint_area));
   EXPECT_FALSE(v1->did_paint_);
   EXPECT_FALSE(v2->did_paint_);
 }
 
 TEST_F(ViewTest, PaintIntersectsNoChildrenInRTL) {
   ScopedRTL rtl;
 
   Widget* widget = new Widget;
   Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_POPUP);
   widget->Init(params);
@@ skipping 12 matching lines @@
   v1->SetPaintToLayer(true);
   // x: 25 - 10(x) - 12(width) = 3
   EXPECT_EQ(gfx::Rect(3, 11, 12, 13), v1->layer()->bounds());
   v1->SetPaintToLayer(false);
 
   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);
 
-  gfx::Canvas canvas(root_view->size(), 1.f, true);
+  // 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());
+  root_view->Paint(ui::PaintContext(list.get(), 1.f, first_paint, 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());
 
   EXPECT_FALSE(v1->did_paint_);
   EXPECT_FALSE(v2->did_paint_);
-  root_view->Paint(ui::PaintContext(&canvas, paint_area));
+  root_view->Paint(ui::PaintContext(list.get(), 1.f, root_area, paint_area));
   EXPECT_FALSE(v1->did_paint_);
   EXPECT_FALSE(v2->did_paint_);
 }
 
 TEST_F(ViewTest, PaintIntersectsOneChild) {
   Widget* widget = new Widget;
   Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_POPUP);
   widget->Init(params);
   View* root_view = widget->GetRootView();
   root_view->SetBounds(0, 0, 25, 26);
 
   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);
 
-  gfx::Canvas canvas(root_view->size(), 1.f, true);
+  // 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());
+  root_view->Paint(ui::PaintContext(list.get(), 1.f, first_paint, 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());
 
   EXPECT_FALSE(v1->did_paint_);
   EXPECT_FALSE(v2->did_paint_);
-  root_view->Paint(ui::PaintContext(&canvas, paint_area));
+  root_view->Paint(ui::PaintContext(list.get(), 1.f, root_area, 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);
 
   v1->Reset();
   v2->Reset();
   EXPECT_FALSE(v1->did_paint_);
   EXPECT_FALSE(v2->did_paint_);
-  root_view->Paint(ui::PaintContext(&canvas, paint_area));
+  root_view->Paint(ui::PaintContext(list.get(), 1.f, root_area, paint_area));
   EXPECT_TRUE(v1->did_paint_);
   EXPECT_FALSE(v2->did_paint_);
 }
 
 TEST_F(ViewTest, PaintIntersectsOneChildInRTL) {
   ScopedRTL rtl;
 
   Widget* widget = new Widget;
   Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_POPUP);
   widget->Init(params);
@@ skipping 12 matching lines @@
   v1->SetPaintToLayer(true);
   // x: 25 - 10(x) - 12(width) = 3
   EXPECT_EQ(gfx::Rect(3, 11, 12, 13), v1->layer()->bounds());
   v1->SetPaintToLayer(false);
 
   v2->SetPaintToLayer(true);
   // x: 25 - 3(x) - 6(width) = 16
   EXPECT_EQ(gfx::Rect(16, 4, 6, 5), v2->layer()->bounds());
   v2->SetPaintToLayer(false);
 
-  gfx::Canvas canvas(root_view->size(), 1.f, true);
+  // 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());
+  root_view->Paint(ui::PaintContext(list.get(), 1.f, first_paint, 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());
 
   EXPECT_FALSE(v1->did_paint_);
   EXPECT_FALSE(v2->did_paint_);
-  root_view->Paint(ui::PaintContext(&canvas, paint_area));
+  root_view->Paint(ui::PaintContext(list.get(), 1.f, root_area, 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);
 
   v1->Reset();
   v2->Reset();
   EXPECT_FALSE(v1->did_paint_);
   EXPECT_FALSE(v2->did_paint_);
-  root_view->Paint(ui::PaintContext(&canvas, paint_area));
+  root_view->Paint(ui::PaintContext(list.get(), 1.f, root_area, paint_area));
   EXPECT_FALSE(v1->did_paint_);
   EXPECT_TRUE(v2->did_paint_);
 }
 
 TEST_F(ViewTest, PaintInPromotedToLayer) {
   Widget* widget = new Widget;
   Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_POPUP);
   widget->Init(params);
   View* root_view = widget->GetRootView();
   root_view->SetBounds(0, 0, 25, 26);
 
   TestView* v1 = new TestView;
   v1->SetPaintToLayer(true);
   v1->SetBounds(10, 11, 12, 13);
   root_view->AddChildView(v1);
 
   TestView* v2 = new TestView;
   v2->SetBounds(3, 4, 6, 5);
   v1->AddChildView(v2);
 
-  EXPECT_FALSE(v1->did_paint_);
-  EXPECT_FALSE(v2->did_paint_);
+  // 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());
+  v1->Paint(ui::PaintContext(list.get(), 1.f, first_paint, first_paint));
+  v1->Reset();
+  v2->Reset();
 
   {
-    gfx::Canvas canvas(root_view->size(), 1.f, true);
     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());
 
     // The promoted views are not painted as they are separate paint roots.
-    root_view->Paint(ui::PaintContext(&canvas, paint_area));
+    root_view->Paint(ui::PaintContext(list.get(), 1.f, view_area, paint_area));
     EXPECT_FALSE(v1->did_paint_);
     EXPECT_FALSE(v2->did_paint_);
   }
 
   {
-    gfx::Canvas canvas(v1->size(), 1.f, true);
     gfx::Rect paint_area(1, 1);
+    gfx::Rect view_area(v1->size());
+    scoped_refptr<cc::DisplayItemList> list =
+        cc::DisplayItemList::Create(view_area, 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(&canvas, paint_area));
+    v1->Paint(ui::PaintContext(list.get(), 1.f, view_area, paint_area));
     EXPECT_TRUE(v1->did_paint_);
     EXPECT_FALSE(v2->did_paint_);
   }
 
   v1->Reset();
 
   {
-    gfx::Canvas canvas(v1->size(), 1.f, true);
     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());
 
     // 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(&canvas, paint_area));
+    v1->Paint(ui::PaintContext(list.get(), 1.f, view_area, paint_area));
     EXPECT_TRUE(v1->did_paint_);
     EXPECT_TRUE(v2->did_paint_);
   }
 }
 
 void TestView::SchedulePaintInRect(const gfx::Rect& rect) {
   scheduled_paint_rects_.push_back(rect);
   View::SchedulePaintInRect(rect);
 }
 
@@ skipping 3032 matching lines @@
   // notification.
   TestView* test_view_child_2 = new TestView();
   test_view->AddChildView(test_view_child_2);
   EXPECT_TRUE(test_view_child_2->native_theme_);
   EXPECT_EQ(widget->GetNativeTheme(), test_view_child_2->native_theme_);
 
   widget->CloseNow();
 }
 
 }  // namespace views