Implements core logic for Pixel 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 "ui/views/view.h"
 
 #include <stddef.h>
 
 #include <map>
 #include <memory>
@@ skipping 22 matching lines @@
 #include "ui/events/test/event_generator.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/path.h"
 #include "ui/gfx/transform.h"
 #include "ui/native_theme/native_theme.h"
 #include "ui/strings/grit/ui_strings.h"
 #include "ui/views/background.h"
 #include "ui/views/controls/native/native_view_host.h"
 #include "ui/views/controls/scroll_view.h"
 #include "ui/views/controls/textfield/textfield.h"
+#include "ui/views/paint_info.h"
 #include "ui/views/test/views_test_base.h"
 #include "ui/views/view_observer.h"
 #include "ui/views/widget/native_widget.h"
 #include "ui/views/widget/root_view.h"
 #include "ui/views/window/dialog_client_view.h"
 #include "ui/views/window/dialog_delegate.h"
 
 using base::ASCIIToUTF16;
 
 namespace {
@@ skipping 467 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);
   auto list = base::MakeRefCounted<cc::DisplayItemList>();
-  root_view->Paint(ui::PaintContext(list.get(), 1.f, first_paint));
+  root_view->Paint(PaintInfo::CreateRootPaintInfo(
+      ui::PaintContext(list.get(), 1.f, first_paint, false),
+      first_paint.size()));
 
   // 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;
   auto list = base::MakeRefCounted<cc::DisplayItemList>();
-  root_view->Paint(
-      ui::PaintContext(list.get(), device_scale_factor, pixel_rect));
+  root_view->PaintFromPaintRoot(
+      ui::PaintContext(list.get(), device_scale_factor, pixel_rect, false));
   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 = base::MakeRefCounted<cc::DisplayItemList>();
-  root_view->Paint(
-      ui::PaintContext(list.get(), device_scale_factor, pixel_rect));
+  root_view->PaintFromPaintRoot(
+      ui::PaintContext(list.get(), device_scale_factor, pixel_rect, false));
   EXPECT_FALSE(v1->did_paint_);
   v1->Reset();
 
   // If invalidation does intersect v1, we don't paint with the cache.
   list = base::MakeRefCounted<cc::DisplayItemList>();
-  root_view->Paint(
-      ui::PaintContext(list.get(), device_scale_factor, v1->bounds()));
+  root_view->PaintFromPaintRoot(
+      ui::PaintContext(list.get(), device_scale_factor, v1->bounds(), false));
   EXPECT_TRUE(v1->did_paint_);
   v1->Reset();
 
   // Moving the view should still use the cache when the invalidation doesn't
   // intersect v1.
   list = base::MakeRefCounted<cc::DisplayItemList>();
   v1->SetX(9);
-  root_view->Paint(
-      ui::PaintContext(list.get(), device_scale_factor, pixel_rect));
+  root_view->PaintFromPaintRoot(
+      ui::PaintContext(list.get(), device_scale_factor, pixel_rect, false));
   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 = base::MakeRefCounted<cc::DisplayItemList>();
   v1->SetX(8);
-  root_view->Paint(ui::PaintContext(
-      ui::PaintContext(list.get(), device_scale_factor, pixel_rect),
+  root_view->PaintFromPaintRoot(ui::PaintContext(
+      ui::PaintContext(list.get(), device_scale_factor, pixel_rect, false),
       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;
   auto list = base::MakeRefCounted<cc::DisplayItemList>();
-  root_view->Paint(
-      ui::PaintContext(list.get(), device_scale_factor, pixel_rect));
+  root_view->PaintFromPaintRoot(
+      ui::PaintContext(list.get(), device_scale_factor, pixel_rect, false));
   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 = base::MakeRefCounted<cc::DisplayItemList>();
-  root_view->Paint(
-      ui::PaintContext(list.get(), device_scale_factor, pixel_rect));
+  root_view->PaintFromPaintRoot(
+      ui::PaintContext(list.get(), device_scale_factor, pixel_rect, false));
   EXPECT_FALSE(v1->did_paint_);
   v1->Reset();
 
   // If invalidation does intersect v1, we don't paint with the cache.
   list = base::MakeRefCounted<cc::DisplayItemList>();
-  root_view->Paint(
-      ui::PaintContext(list.get(), device_scale_factor, v1->bounds()));
+  root_view->PaintFromPaintRoot(
+      ui::PaintContext(list.get(), device_scale_factor, v1->bounds(), false));
   EXPECT_TRUE(v1->did_paint_);
   v1->Reset();
 
   // Moving the view should still use the cache when the invalidation doesn't
   // intersect v1.
   list = base::MakeRefCounted<cc::DisplayItemList>();
   v1->SetX(9);
-  root_view->Paint(
-      ui::PaintContext(list.get(), device_scale_factor, pixel_rect));
+  root_view->PaintFromPaintRoot(
+      ui::PaintContext(list.get(), device_scale_factor, pixel_rect, false));
   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 = base::MakeRefCounted<cc::DisplayItemList>();
   v1->SetX(8);
-  root_view->Paint(ui::PaintContext(
-      ui::PaintContext(list.get(), device_scale_factor, pixel_rect),
+  root_view->PaintFromPaintRoot(ui::PaintContext(
+      ui::PaintContext(list.get(), device_scale_factor, pixel_rect, false),
       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,
             list->VisualRectForTesting(item_index++));
   EXPECT_EQ(expected_visual_rect_in_layer_space,
             list->VisualRectForTesting(item_index++));
@@ skipping 10 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);
   auto list = base::MakeRefCounted<cc::DisplayItemList>();
-  root_view->Paint(ui::PaintContext(list.get(), 1.f, first_paint));
+  root_view->PaintFromPaintRoot(
+      ui::PaintContext(list.get(), 1.f, first_paint, false));
   v1->Reset();
   v2->Reset();
 
   gfx::Rect paint_area(1, 1);
   gfx::Rect root_area(root_view->size());
   list = base::MakeRefCounted<cc::DisplayItemList>();
 
   // 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));
+  root_view->PaintFromPaintRoot(
+      ui::PaintContext(list.get(), 1.f, paint_area, false));
   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(list.get(), 1.f, paint_area),
+  root_view->PaintFromPaintRoot(
+      ui::PaintContext(ui::PaintContext(list.get(), 1.f, paint_area, false),
                        ui::PaintContext::CLONE_WITHOUT_INVALIDATION));
   EXPECT_TRUE(v1->did_paint_);
   EXPECT_TRUE(v2->did_paint_);
 }
 
 TEST_F(ViewTest, PaintContainsChildren) {
   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);
   auto list = base::MakeRefCounted<cc::DisplayItemList>();
-  root_view->Paint(ui::PaintContext(list.get(), 1.f, first_paint));
+  root_view->Paint(PaintInfo::CreateRootPaintInfo(
+      ui::PaintContext(list.get(), 1.f, first_paint, false),
+      root_view->size()));
   v1->Reset();
   v2->Reset();
 
   gfx::Rect paint_area(25, 26);
   gfx::Rect root_area(root_view->size());
   list = base::MakeRefCounted<cc::DisplayItemList>();
 
   EXPECT_FALSE(v1->did_paint_);
   EXPECT_FALSE(v2->did_paint_);
-  root_view->Paint(ui::PaintContext(list.get(), 1.f, paint_area));
+  root_view->Paint(PaintInfo::CreateRootPaintInfo(
+      ui::PaintContext(list.get(), 1.f, paint_area, false), root_view->size()));
   EXPECT_TRUE(v1->did_paint_);
   EXPECT_TRUE(v2->did_paint_);
 }
 
 TEST_F(ViewTest, PaintContainsChildrenInRTL) {
   ScopedRTL rtl;
   ScopedTestPaintWidget widget(CreateParams(Widget::InitParams::TYPE_POPUP));
   View* root_view = widget->GetRootView();
 
   TestView* v1 = new TestView;
@@ skipping 12 matching lines @@
 
   v2->SetPaintToLayer();
   // x: 25 - 10(parent x) - 3(x) - 6(width) = 6
   EXPECT_EQ(gfx::Rect(6, 15, 6, 5), v2->layer()->bounds());
   v2->DestroyLayer();
 
   // Paint everything once, since it has to build its cache. Then we can test
   // invalidation.
   gfx::Rect first_paint(1, 1);
   auto list = base::MakeRefCounted<cc::DisplayItemList>();
-  root_view->Paint(ui::PaintContext(list.get(), 1.f, first_paint));
+  root_view->Paint(PaintInfo::CreateRootPaintInfo(
+      ui::PaintContext(list.get(), 1.f, first_paint, false),
+      root_view->size()));
   v1->Reset();
   v2->Reset();
 
   gfx::Rect paint_area(25, 26);
   gfx::Rect root_area(root_view->size());
   list = base::MakeRefCounted<cc::DisplayItemList>();
 
   EXPECT_FALSE(v1->did_paint_);
   EXPECT_FALSE(v2->did_paint_);
-  root_view->Paint(ui::PaintContext(list.get(), 1.f, paint_area));
+  root_view->Paint(PaintInfo::CreateRootPaintInfo(
+      ui::PaintContext(list.get(), 1.f, paint_area, false), root_view->size()));
   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);
   auto list = base::MakeRefCounted<cc::DisplayItemList>();
-  root_view->Paint(ui::PaintContext(list.get(), 1.f, first_paint));
+  root_view->Paint(PaintInfo::CreateRootPaintInfo(
+      ui::PaintContext(list.get(), 1.f, first_paint, false),
+      root_view->size()));
   v1->Reset();
   v2->Reset();
 
   gfx::Rect paint_area(9, 10, 5, 6);
   gfx::Rect root_area(root_view->size());
   list = base::MakeRefCounted<cc::DisplayItemList>();
 
   EXPECT_FALSE(v1->did_paint_);
   EXPECT_FALSE(v2->did_paint_);
-  root_view->Paint(ui::PaintContext(list.get(), 1.f, paint_area));
+  root_view->Paint(PaintInfo::CreateRootPaintInfo(
+      ui::PaintContext(list.get(), 1.f, paint_area, false), root_view->size()));
   EXPECT_TRUE(v1->did_paint_);
   EXPECT_TRUE(v2->did_paint_);
 }
 
 TEST_F(ViewTest, PaintIntersectsChildrenInRTL) {
   ScopedRTL rtl;
   ScopedTestPaintWidget widget(CreateParams(Widget::InitParams::TYPE_POPUP));
   View* root_view = widget->GetRootView();
 
   TestView* v1 = new TestView;
@@ skipping 12 matching lines @@
 
   v2->SetPaintToLayer();
   // x: 25 - 10(parent x) - 3(x) - 6(width) = 6
   EXPECT_EQ(gfx::Rect(6, 15, 6, 5), v2->layer()->bounds());
   v2->DestroyLayer();
 
   // Paint everything once, since it has to build its cache. Then we can test
   // invalidation.
   gfx::Rect first_paint(1, 1);
   auto list = base::MakeRefCounted<cc::DisplayItemList>();
-  root_view->Paint(ui::PaintContext(list.get(), 1.f, first_paint));
+  root_view->Paint(PaintInfo::CreateRootPaintInfo(
+      ui::PaintContext(list.get(), 1.f, first_paint, false),
+      root_view->size()));
   v1->Reset();
   v2->Reset();
 
   gfx::Rect paint_area(2, 10, 5, 6);
   gfx::Rect root_area(root_view->size());
   list = base::MakeRefCounted<cc::DisplayItemList>();
 
   EXPECT_FALSE(v1->did_paint_);
   EXPECT_FALSE(v2->did_paint_);
-  root_view->Paint(ui::PaintContext(list.get(), 1.f, paint_area));
+  root_view->Paint(PaintInfo::CreateRootPaintInfo(
+      ui::PaintContext(list.get(), 1.f, paint_area, false), root_view->size()));
   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);
   auto list = base::MakeRefCounted<cc::DisplayItemList>();
-  root_view->Paint(ui::PaintContext(list.get(), 1.f, first_paint));
+  root_view->Paint(PaintInfo::CreateRootPaintInfo(
+      ui::PaintContext(list.get(), 1.f, first_paint, false),
+      root_view->size()));
   v1->Reset();
   v2->Reset();
 
   gfx::Rect paint_area(9, 10, 2, 3);
   gfx::Rect root_area(root_view->size());
   list = base::MakeRefCounted<cc::DisplayItemList>();
 
   EXPECT_FALSE(v1->did_paint_);
   EXPECT_FALSE(v2->did_paint_);
-  root_view->Paint(ui::PaintContext(list.get(), 1.f, paint_area));
+  root_view->Paint(PaintInfo::CreateRootPaintInfo(
+      ui::PaintContext(list.get(), 1.f, paint_area, false), root_view->size()));
   EXPECT_TRUE(v1->did_paint_);
   EXPECT_FALSE(v2->did_paint_);
 }
 
 TEST_F(ViewTest, PaintIntersectsChildButNotGrandChildInRTL) {
   ScopedRTL rtl;
   ScopedTestPaintWidget widget(CreateParams(Widget::InitParams::TYPE_POPUP));
   View* root_view = widget->GetRootView();
 
   TestView* v1 = new TestView;
@@ skipping 12 matching lines @@
 
   v2->SetPaintToLayer();
   // x: 25 - 10(parent x) - 3(x) - 6(width) = 6
   EXPECT_EQ(gfx::Rect(6, 15, 6, 5), v2->layer()->bounds());
   v2->DestroyLayer();
 
   // Paint everything once, since it has to build its cache. Then we can test
   // invalidation.
   gfx::Rect first_paint(1, 1);
   auto list = base::MakeRefCounted<cc::DisplayItemList>();
-  root_view->Paint(ui::PaintContext(list.get(), 1.f, first_paint));
+  root_view->Paint(PaintInfo::CreateRootPaintInfo(
+      ui::PaintContext(list.get(), 1.f, first_paint, false),
+      root_view->size()));
   v1->Reset();
   v2->Reset();
 
   gfx::Rect paint_area(2, 10, 2, 3);
   gfx::Rect root_area(root_view->size());
   list = base::MakeRefCounted<cc::DisplayItemList>();
 
   EXPECT_FALSE(v1->did_paint_);
   EXPECT_FALSE(v2->did_paint_);
-  root_view->Paint(ui::PaintContext(list.get(), 1.f, paint_area));
+  root_view->Paint(PaintInfo::CreateRootPaintInfo(
+      ui::PaintContext(list.get(), 1.f, paint_area, false), root_view->size()));
   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);
   auto list = base::MakeRefCounted<cc::DisplayItemList>();
-  root_view->Paint(ui::PaintContext(list.get(), 1.f, first_paint));
+  root_view->Paint(PaintInfo::CreateRootPaintInfo(
+      ui::PaintContext(list.get(), 1.f, first_paint, false),
+      root_view->size()));
   v1->Reset();
   v2->Reset();
 
   gfx::Rect paint_area(9, 10, 2, 1);
   gfx::Rect root_area(root_view->size());
   list = base::MakeRefCounted<cc::DisplayItemList>();
 
   EXPECT_FALSE(v1->did_paint_);
   EXPECT_FALSE(v2->did_paint_);
-  root_view->Paint(ui::PaintContext(list.get(), 1.f, paint_area));
+  root_view->Paint(PaintInfo::CreateRootPaintInfo(
+      ui::PaintContext(list.get(), 1.f, paint_area, false), root_view->size()));
   EXPECT_FALSE(v1->did_paint_);
   EXPECT_FALSE(v2->did_paint_);
 }
 
 TEST_F(ViewTest, PaintIntersectsNoChildrenInRTL) {
   ScopedRTL rtl;
   ScopedTestPaintWidget widget(CreateParams(Widget::InitParams::TYPE_POPUP));
   View* root_view = widget->GetRootView();
 
   TestView* v1 = new TestView;
@@ skipping 12 matching lines @@
 
   v2->SetPaintToLayer();
   // x: 25 - 10(parent x) - 3(x) - 6(width) = 6
   EXPECT_EQ(gfx::Rect(6, 15, 6, 5), v2->layer()->bounds());
   v2->DestroyLayer();
 
   // Paint everything once, since it has to build its cache. Then we can test
   // invalidation.
   gfx::Rect first_paint(1, 1);
   auto list = base::MakeRefCounted<cc::DisplayItemList>();
-  root_view->Paint(ui::PaintContext(list.get(), 1.f, first_paint));
+  root_view->Paint(PaintInfo::CreateRootPaintInfo(
+      ui::PaintContext(list.get(), 1.f, first_paint, false),
+      root_view->size()));
   v1->Reset();
   v2->Reset();
 
   gfx::Rect paint_area(2, 10, 2, 1);
   gfx::Rect root_area(root_view->size());
   list = base::MakeRefCounted<cc::DisplayItemList>();
 
   EXPECT_FALSE(v1->did_paint_);
   EXPECT_FALSE(v2->did_paint_);
-  root_view->Paint(ui::PaintContext(list.get(), 1.f, paint_area));
+  root_view->Paint(PaintInfo::CreateRootPaintInfo(
+      ui::PaintContext(list.get(), 1.f, paint_area, false), root_view->size()));
   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);
   auto list = base::MakeRefCounted<cc::DisplayItemList>();
-  root_view->Paint(ui::PaintContext(list.get(), 1.f, first_paint));
+  root_view->Paint(PaintInfo::CreateRootPaintInfo(
+      ui::PaintContext(list.get(), 1.f, first_paint, false),
+      root_view->size()));
   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 = base::MakeRefCounted<cc::DisplayItemList>();
 
   EXPECT_FALSE(v1->did_paint_);
   EXPECT_FALSE(v2->did_paint_);
-  root_view->Paint(ui::PaintContext(list.get(), 1.f, paint_area));
+  root_view->Paint(PaintInfo::CreateRootPaintInfo(
+      ui::PaintContext(list.get(), 1.f, paint_area, false), root_view->size()));
   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(list.get(), 1.f, paint_area));
+  root_view->Paint(PaintInfo::CreateRootPaintInfo(
+      ui::PaintContext(list.get(), 1.f, paint_area, false), root_view->size()));
   EXPECT_TRUE(v1->did_paint_);
   EXPECT_FALSE(v2->did_paint_);
 }
 
 TEST_F(ViewTest, PaintIntersectsOneChildInRTL) {
   ScopedRTL rtl;
   ScopedTestPaintWidget widget(CreateParams(Widget::InitParams::TYPE_POPUP));
   View* root_view = widget->GetRootView();
 
   TestView* v1 = new TestView;
@@ skipping 12 matching lines @@
 
   v2->SetPaintToLayer();
   // x: 25 - 3(x) - 6(width) = 16
   EXPECT_EQ(gfx::Rect(16, 4, 6, 5), v2->layer()->bounds());
   v2->DestroyLayer();
 
   // Paint everything once, since it has to build its cache. Then we can test
   // invalidation.
   gfx::Rect first_paint(1, 1);
   auto list = base::MakeRefCounted<cc::DisplayItemList>();
-  root_view->Paint(ui::PaintContext(list.get(), 1.f, first_paint));
+  root_view->Paint(PaintInfo::CreateRootPaintInfo(
+      ui::PaintContext(list.get(), 1.f, first_paint, false),
+      root_view->size()));
   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 = base::MakeRefCounted<cc::DisplayItemList>();
 
   EXPECT_FALSE(v1->did_paint_);
   EXPECT_FALSE(v2->did_paint_);
-  root_view->Paint(ui::PaintContext(list.get(), 1.f, paint_area));
+  root_view->Paint(PaintInfo::CreateRootPaintInfo(
+      ui::PaintContext(list.get(), 1.f, paint_area, false), root_view->size()));
   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(list.get(), 1.f, paint_area));
+  root_view->Paint(PaintInfo::CreateRootPaintInfo(
+      ui::PaintContext(list.get(), 1.f, paint_area, false), root_view->size()));
   EXPECT_FALSE(v1->did_paint_);
   EXPECT_TRUE(v2->did_paint_);
 }
 
 TEST_F(ViewTest, PaintInPromotedToLayer) {
   ScopedTestPaintWidget widget(CreateParams(Widget::InitParams::TYPE_POPUP));
   View* root_view = widget->GetRootView();
 
   TestView* v1 = new TestView;
   v1->SetPaintToLayer();
   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);
   auto list = base::MakeRefCounted<cc::DisplayItemList>();
-  v1->Paint(ui::PaintContext(list.get(), 1.f, first_paint));
+  v1->Paint(PaintInfo::CreateRootPaintInfo(
+      ui::PaintContext(list.get(), 1.f, first_paint, false), v1->size()));
   v1->Reset();
   v2->Reset();
 
   {
     gfx::Rect paint_area(25, 26);
     gfx::Rect view_area(root_view->size());
     auto list = base::MakeRefCounted<cc::DisplayItemList>();
 
     // The promoted views are not painted as they are separate paint roots.
-    root_view->Paint(ui::PaintContext(list.get(), 1.f, paint_area));
+    root_view->Paint(PaintInfo::CreateRootPaintInfo(
+        ui::PaintContext(list.get(), 1.f, paint_area, false),
+        root_view->size()));
     EXPECT_FALSE(v1->did_paint_);
     EXPECT_FALSE(v2->did_paint_);
   }
 
   {
     gfx::Rect paint_area(1, 1);
     gfx::Rect view_area(v1->size());
     auto list = base::MakeRefCounted<cc::DisplayItemList>();
 
     // 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));
+    v1->Paint(PaintInfo::CreateRootPaintInfo(
+        ui::PaintContext(list.get(), 1.f, paint_area, false), v1->size()));
     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());
     auto list = base::MakeRefCounted<cc::DisplayItemList>();
 
     // 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));
+    v1->Paint(PaintInfo::CreateRootPaintInfo(
+        ui::PaintContext(list.get(), 1.f, paint_area, false), v1->size()));
     EXPECT_TRUE(v1->did_paint_);
     EXPECT_TRUE(v2->did_paint_);
   }
 }
 
 // A derived class for testing paint.
 class TestPaintView : public TestView {
  public:
   TestPaintView() : TestView(), canvas_bounds_(gfx::Rect()) {}
   ~TestPaintView() override {}
@@ skipping 22 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());
 
   auto list = base::MakeRefCounted<cc::DisplayItemList>();
-  ui::PaintContext context(list.get(), 1.f, gfx::Rect());
+  ui::PaintContext context(list.get(), 1.f, gfx::Rect(), false);
 
-  v1->Paint(context);
+  v1->Paint(PaintInfo::CreateRootPaintInfo(context, gfx::Size()));
   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()));
 }
 
 void TestView::SchedulePaintInRect(const gfx::Rect& rect) {
   scheduled_paint_rects_.push_back(rect);
   View::SchedulePaintInRect(rect);
@@ skipping 3744 matching lines @@
   EXPECT_TRUE(parent_view->received_layer_change_notification());
   EXPECT_EQ(1, parent_view->layer_change_count());
 
   parent_view->Reset();
   child_view->SetPaintToLayer(ui::LAYER_SOLID_COLOR);
   EXPECT_TRUE(parent_view->received_layer_change_notification());
   EXPECT_EQ(1, parent_view->layer_change_count());
 }
 
 }  // namespace views