Update SetPaintToLayer to accept LayerType

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>
 
 #include "base/i18n/rtl.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.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 "build/build_config.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/layer_type.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"
 #include "ui/events/keycodes/keyboard_codes.h"
 #include "ui/events/scoped_target_handler.h"
 #include "ui/events/test/event_generator.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/path.h"
 #include "ui/gfx/transform.h"
@@ skipping 112 matching lines @@
 
 // Constructs a View tree with the specified depth.
 void ConstructTree(views::View* view, int depth) {
   if (depth == 0)
     return;
   int count = base::RandInt(1, 5);
   for (int i = 0; i < count; i++) {
     views::View* v = new views::View;
     view->AddChildView(v);
     if (base::RandDouble() > 0.5)
-      v->SetPaintToLayer(true);
+      v->SetPaintToLayer(ui::LAYER_TEXTURED);
     if (base::RandDouble() < 0.2)
       v->SetVisible(false);
 
     ConstructTree(v, depth - 1);
   }
 }
 
 void ScrambleTree(views::View* view) {
   int count = view->child_count();
   if (count == 0)
     return;
   for (int i = 0; i < count; i++) {
     ScrambleTree(view->child_at(i));
   }
 
   if (count > 1) {
     int a = base::RandInt(0, count - 1);
     int b = base::RandInt(0, count - 1);
 
     views::View* view_a = view->child_at(a);
     views::View* view_b = view->child_at(b);
     view->ReorderChildView(view_a, b);
     view->ReorderChildView(view_b, a);
   }
 
   if (!view->layer() && base::RandDouble() < 0.1)
-    view->SetPaintToLayer(true);
+    view->SetPaintToLayer(ui::LAYER_TEXTURED);
 
   if (base::RandDouble() < 0.1)
     view->SetVisible(!view->visible());
 }
 
 class ScopedRTL {
  public:
   ScopedRTL() {
     locale_ = base::i18n::GetConfiguredLocale();
     base::i18n::SetICUDefaultLocale("he");
@@ skipping 578 matching lines @@
 
   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);
 
   // Verify where the layers actually appear.
-  v1->SetPaintToLayer(true);
+  v1->SetPaintToLayer(ui::LAYER_TEXTURED);
   // x: 25 - 10(x) - 12(width) = 3
   EXPECT_EQ(gfx::Rect(3, 11, 12, 13), v1->layer()->bounds());
-  v1->SetPaintToLayer(false);
+  v1->SetPaintToLayer(ui::LAYER_NOT_DRAWN);
 
-  v2->SetPaintToLayer(true);
+  v2->SetPaintToLayer(ui::LAYER_TEXTURED);
   // x: 25 - 10(parent x) - 3(x) - 6(width) = 6
   EXPECT_EQ(gfx::Rect(6, 15, 6, 5), v2->layer()->bounds());
-  v2->SetPaintToLayer(false);
+  v2->SetPaintToLayer(ui::LAYER_NOT_DRAWN);
 
   // 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(cc::DisplayItemListSettings());
   root_view->Paint(ui::PaintContext(list.get(), 1.f, first_paint));
   v1->Reset();
   v2->Reset();
 
@@ skipping 47 matching lines @@
 
   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);
 
   // Verify where the layers actually appear.
-  v1->SetPaintToLayer(true);
+  v1->SetPaintToLayer(ui::LAYER_TEXTURED);
   // x: 25 - 10(x) - 12(width) = 3
   EXPECT_EQ(gfx::Rect(3, 11, 12, 13), v1->layer()->bounds());
-  v1->SetPaintToLayer(false);
+  v1->SetPaintToLayer(ui::LAYER_NOT_DRAWN);
 
-  v2->SetPaintToLayer(true);
+  v2->SetPaintToLayer(ui::LAYER_TEXTURED);
   // x: 25 - 10(parent x) - 3(x) - 6(width) = 6
   EXPECT_EQ(gfx::Rect(6, 15, 6, 5), v2->layer()->bounds());
-  v2->SetPaintToLayer(false);
+  v2->SetPaintToLayer(ui::LAYER_NOT_DRAWN);
 
   // 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(cc::DisplayItemListSettings());
   root_view->Paint(ui::PaintContext(list.get(), 1.f, first_paint));
   v1->Reset();
   v2->Reset();
 
@@ skipping 47 matching lines @@
 
   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);
 
   // Verify where the layers actually appear.
-  v1->SetPaintToLayer(true);
+  v1->SetPaintToLayer(ui::LAYER_TEXTURED);
   // x: 25 - 10(x) - 12(width) = 3
   EXPECT_EQ(gfx::Rect(3, 11, 12, 13), v1->layer()->bounds());
-  v1->SetPaintToLayer(false);
+  v1->SetPaintToLayer(ui::LAYER_NOT_DRAWN);
 
-  v2->SetPaintToLayer(true);
+  v2->SetPaintToLayer(ui::LAYER_TEXTURED);
   // x: 25 - 10(parent x) - 3(x) - 6(width) = 6
   EXPECT_EQ(gfx::Rect(6, 15, 6, 5), v2->layer()->bounds());
-  v2->SetPaintToLayer(false);
+  v2->SetPaintToLayer(ui::LAYER_NOT_DRAWN);
 
   // 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(cc::DisplayItemListSettings());
   root_view->Paint(ui::PaintContext(list.get(), 1.f, first_paint));
   v1->Reset();
   v2->Reset();
 
@@ skipping 47 matching lines @@
 
   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);
 
   // Verify where the layers actually appear.
-  v1->SetPaintToLayer(true);
+  v1->SetPaintToLayer(ui::LAYER_TEXTURED);
   // x: 25 - 10(x) - 12(width) = 3
   EXPECT_EQ(gfx::Rect(3, 11, 12, 13), v1->layer()->bounds());
-  v1->SetPaintToLayer(false);
+  v1->SetPaintToLayer(ui::LAYER_NOT_DRAWN);
 
-  v2->SetPaintToLayer(true);
+  v2->SetPaintToLayer(ui::LAYER_TEXTURED);
   // x: 25 - 10(parent x) - 3(x) - 6(width) = 6
   EXPECT_EQ(gfx::Rect(6, 15, 6, 5), v2->layer()->bounds());
-  v2->SetPaintToLayer(false);
+  v2->SetPaintToLayer(ui::LAYER_NOT_DRAWN);
 
   // 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(cc::DisplayItemListSettings());
   root_view->Paint(ui::PaintContext(list.get(), 1.f, first_paint));
   v1->Reset();
   v2->Reset();
 
@@ skipping 59 matching lines @@
 
   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);
 
   // Verify where the layers actually appear.
-  v1->SetPaintToLayer(true);
+  v1->SetPaintToLayer(ui::LAYER_TEXTURED);
   // x: 25 - 10(x) - 12(width) = 3
   EXPECT_EQ(gfx::Rect(3, 11, 12, 13), v1->layer()->bounds());
-  v1->SetPaintToLayer(false);
+  v1->SetPaintToLayer(ui::LAYER_NOT_DRAWN);
 
-  v2->SetPaintToLayer(true);
+  v2->SetPaintToLayer(ui::LAYER_TEXTURED);
   // x: 25 - 3(x) - 6(width) = 16
   EXPECT_EQ(gfx::Rect(16, 4, 6, 5), v2->layer()->bounds());
-  v2->SetPaintToLayer(false);
+  v2->SetPaintToLayer(ui::LAYER_NOT_DRAWN);
 
   // 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(cc::DisplayItemListSettings());
   root_view->Paint(ui::PaintContext(list.get(), 1.f, first_paint));
   v1->Reset();
   v2->Reset();
 
@@ skipping 18 matching lines @@
   root_view->Paint(ui::PaintContext(list.get(), 1.f, paint_area));
   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(true);
+  v1->SetPaintToLayer(ui::LAYER_TEXTURED);
   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);
@@ skipping 63 matching lines @@
 };
 
 TEST_F(ViewTest, PaintLocalBounds) {
   ScopedTestPaintWidget widget(CreateParams(Widget::InitParams::TYPE_POPUP));
   View* root_view = widget->GetRootView();
   // Make |root_view|'s bounds larger so |v1|'s visible bounds is not clipped by
   // |root_view|.
   root_view->SetBounds(0, 0, 200, 200);
 
   TestPaintView* v1 = new TestPaintView;
-  v1->SetPaintToLayer(true);
+  v1->SetPaintToLayer(ui::LAYER_TEXTURED);
 
   // 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 =
@@ skipping 2482 matching lines @@
 
 TEST_F(ViewLayerTest, LayerToggling) {
   // Because we lazily create textures the calls to DrawTree are necessary to
   // ensure we trigger creation of textures.
   ui::Layer* root_layer = widget()->GetLayer();
   View* content_view = new View;
   widget()->SetContentsView(content_view);
 
   // Create v1, give it a bounds and verify everything is set up correctly.
   View* v1 = new View;
-  v1->SetPaintToLayer(true);
+  v1->SetPaintToLayer(ui::LAYER_TEXTURED);
   EXPECT_TRUE(v1->layer() != NULL);
   v1->SetBoundsRect(gfx::Rect(20, 30, 140, 150));
   content_view->AddChildView(v1);
   ASSERT_TRUE(v1->layer() != NULL);
   EXPECT_EQ(root_layer, v1->layer()->parent());
   EXPECT_EQ(gfx::Rect(20, 30, 140, 150), v1->layer()->bounds());
 
   // Create v2 as a child of v1 and do basic assertion testing.
   View* v2 = new View;
   v1->AddChildView(v2);
   EXPECT_TRUE(v2->layer() == NULL);
   v2->SetBoundsRect(gfx::Rect(10, 20, 30, 40));
-  v2->SetPaintToLayer(true);
+  v2->SetPaintToLayer(ui::LAYER_TEXTURED);
   ASSERT_TRUE(v2->layer() != NULL);
   EXPECT_EQ(v1->layer(), v2->layer()->parent());
   EXPECT_EQ(gfx::Rect(10, 20, 30, 40), v2->layer()->bounds());
 
   // Turn off v1s layer. v2 should still have a layer but its parent should have
   // changed.
-  v1->SetPaintToLayer(false);
+  v1->SetPaintToLayer(ui::LAYER_NOT_DRAWN);
   EXPECT_TRUE(v1->layer() == NULL);
   EXPECT_TRUE(v2->layer() != NULL);
   EXPECT_EQ(root_layer, v2->layer()->parent());
   ASSERT_EQ(1u, root_layer->children().size());
   EXPECT_EQ(root_layer->children()[0], v2->layer());
   // The bounds of the layer should have changed to be relative to the root view
   // now.
   EXPECT_EQ(gfx::Rect(30, 50, 30, 40), v2->layer()->bounds());
 
   // Make v1 have a layer again and verify v2s layer is wired up correctly.
@@ skipping 18 matching lines @@
 
   // Create v1, give it a bounds and verify everything is set up correctly.
   View* v1 = new View;
   content_view->AddChildView(v1);
   v1->SetBoundsRect(gfx::Rect(20, 30, 140, 150));
 
   View* v2 = new View;
   v1->AddChildView(v2);
 
   View* v3 = new View;
-  v3->SetPaintToLayer(true);
+  v3->SetPaintToLayer(ui::LAYER_TEXTURED);
   v2->AddChildView(v3);
   ASSERT_TRUE(v3->layer() != NULL);
 
   // At this point we have v1-v2-v3. v3 has a layer, v1 and v2 don't.
 
-  v1->SetPaintToLayer(true);
+  v1->SetPaintToLayer(ui::LAYER_TEXTURED);
   EXPECT_EQ(v1->layer(), v3->layer()->parent());
 }
 
 TEST_F(ViewLayerTest, LayerAnimator) {
   View* content_view = new View;
   widget()->SetContentsView(content_view);
 
   View* v1 = new View;
   content_view->AddChildView(v1);
-  v1->SetPaintToLayer(true);
+  v1->SetPaintToLayer(ui::LAYER_TEXTURED);
   EXPECT_TRUE(v1->layer() != NULL);
 
   TestLayerAnimator* animator = new TestLayerAnimator();
   v1->layer()->SetAnimator(animator);
 
   gfx::Rect bounds(1, 2, 3, 4);
   v1->SetBoundsRect(bounds);
   EXPECT_EQ(bounds, animator->last_bounds());
   // TestLayerAnimator doesn't update the layer.
   EXPECT_NE(bounds, v1->layer()->bounds());
 }
 
 // Verifies the bounds of a layer are updated if the bounds of ancestor that
 // doesn't have a layer change.
 TEST_F(ViewLayerTest, BoundsChangeWithLayer) {
   View* content_view = new View;
   widget()->SetContentsView(content_view);
 
   View* v1 = new View;
   content_view->AddChildView(v1);
   v1->SetBoundsRect(gfx::Rect(20, 30, 140, 150));
 
   View* v2 = new View;
   v2->SetBoundsRect(gfx::Rect(10, 11, 40, 50));
   v1->AddChildView(v2);
-  v2->SetPaintToLayer(true);
+  v2->SetPaintToLayer(ui::LAYER_TEXTURED);
   ASSERT_TRUE(v2->layer() != NULL);
   EXPECT_EQ(gfx::Rect(30, 41, 40, 50), v2->layer()->bounds());
 
   v1->SetPosition(gfx::Point(25, 36));
   EXPECT_EQ(gfx::Rect(35, 47, 40, 50), v2->layer()->bounds());
 
   v2->SetPosition(gfx::Point(11, 12));
   EXPECT_EQ(gfx::Rect(36, 48, 40, 50), v2->layer()->bounds());
 
   // Bounds of the layer should change even if the view is not invisible.
@@ skipping 11 matching lines @@
   ScopedRTL rtl;
 
   View* view = new View;
   widget()->SetContentsView(view);
 
   int content_width = view->width();
 
   // |v1| is initially not attached to anything. So its layer will have the same
   // bounds as the view.
   View* v1 = new View;
-  v1->SetPaintToLayer(true);
+  v1->SetPaintToLayer(ui::LAYER_TEXTURED);
   v1->SetBounds(10, 10, 20, 10);
   EXPECT_EQ(gfx::Rect(10, 10, 20, 10),
             v1->layer()->bounds());
 
   // Once |v1| is attached to the widget, its layer will get RTL-appropriate
   // bounds.
   view->AddChildView(v1);
   EXPECT_EQ(gfx::Rect(content_width - 30, 10, 20, 10),
             v1->layer()->bounds());
   gfx::Rect l1bounds = v1->layer()->bounds();
 
   // Now attach a View to the widget first, then create a layer for it. Make
   // sure the bounds are correct.
   View* v2 = new View;
   v2->SetBounds(50, 10, 30, 10);
   EXPECT_FALSE(v2->layer());
   view->AddChildView(v2);
-  v2->SetPaintToLayer(true);
+  v2->SetPaintToLayer(ui::LAYER_TEXTURED);
   EXPECT_EQ(gfx::Rect(content_width - 80, 10, 30, 10),
             v2->layer()->bounds());
   gfx::Rect l2bounds = v2->layer()->bounds();
 
-  view->SetPaintToLayer(true);
+  view->SetPaintToLayer(ui::LAYER_TEXTURED);
   EXPECT_EQ(l1bounds, v1->layer()->bounds());
   EXPECT_EQ(l2bounds, v2->layer()->bounds());
 
   // Move one of the views. Make sure the layer is positioned correctly
   // afterwards.
   v1->SetBounds(v1->x() - 5, v1->y(), v1->width(), v1->height());
   l1bounds.set_x(l1bounds.x() + 5);
   EXPECT_EQ(l1bounds, v1->layer()->bounds());
 
-  view->SetPaintToLayer(false);
+  view->SetPaintToLayer(ui::LAYER_NOT_DRAWN);
   EXPECT_EQ(l1bounds, v1->layer()->bounds());
   EXPECT_EQ(l2bounds, v2->layer()->bounds());
 
   // Move a view again.
   v2->SetBounds(v2->x() + 5, v2->y(), v2->width(), v2->height());
   l2bounds.set_x(l2bounds.x() - 5);
   EXPECT_EQ(l2bounds, v2->layer()->bounds());
 }
 
 // Make sure that resizing a parent in RTL correctly repositions its children.
 TEST_F(ViewLayerTest, ResizeParentInRTL) {
   ScopedRTL rtl;
 
   View* view = new View;
   widget()->SetContentsView(view);
 
   int content_width = view->width();
 
   // Create a paints-to-layer view |v1|.
   View* v1 = new View;
-  v1->SetPaintToLayer(true);
+  v1->SetPaintToLayer(ui::LAYER_TEXTURED);
   v1->SetBounds(10, 10, 20, 10);
   view->AddChildView(v1);
   EXPECT_EQ(gfx::Rect(content_width - 30, 10, 20, 10),
             v1->layer()->bounds());
 
   // Attach a paints-to-layer child view to |v1|.
   View* v2 = new View;
-  v2->SetPaintToLayer(true);
+  v2->SetPaintToLayer(ui::LAYER_TEXTURED);
   v2->SetBounds(3, 5, 6, 4);
   EXPECT_EQ(gfx::Rect(3, 5, 6, 4),
             v2->layer()->bounds());
   v1->AddChildView(v2);
   // Check that |v2| now has RTL-appropriate bounds.
   EXPECT_EQ(gfx::Rect(11, 5, 6, 4),
             v2->layer()->bounds());
 
   // Attach a non-layer child view to |v1|, and give it a paints-to-layer child.
   View* v3 = new View;
   v3->SetBounds(1, 1, 18, 8);
   View* v4 = new View;
-  v4->SetPaintToLayer(true);
+  v4->SetPaintToLayer(ui::LAYER_TEXTURED);
   v4->SetBounds(2, 4, 6, 4);
   EXPECT_EQ(gfx::Rect(2, 4, 6, 4),
             v4->layer()->bounds());
   v3->AddChildView(v4);
   EXPECT_EQ(gfx::Rect(10, 4, 6, 4),
             v4->layer()->bounds());
   v1->AddChildView(v3);
   // Check that |v4| now has RTL-appropriate bounds.
   EXPECT_EQ(gfx::Rect(11, 5, 6, 4),
             v4->layer()->bounds());
@@ skipping 51 matching lines @@
 
 // Makes sure that layer visibility is correct after toggling View visibility.
 TEST_F(ViewLayerTest, ToggleVisibilityWithLayer) {
   View* content_view = new View;
   widget()->SetContentsView(content_view);
 
   // The view isn't attached to a widget or a parent view yet. But it should
   // still have a layer, but the layer should not be attached to the root
   // layer.
   View* v1 = new View;
-  v1->SetPaintToLayer(true);
+  v1->SetPaintToLayer(ui::LAYER_TEXTURED);
   EXPECT_TRUE(v1->layer());
   EXPECT_FALSE(LayerIsAncestor(widget()->GetCompositor()->root_layer(),
                                v1->layer()));
 
   // Once the view is attached to a widget, its layer should be attached to the
   // root layer and visible.
   content_view->AddChildView(v1);
   EXPECT_TRUE(LayerIsAncestor(widget()->GetCompositor()->root_layer(),
                               v1->layer()));
   EXPECT_TRUE(v1->layer()->IsDrawn());
@@ skipping 15 matching lines @@
 // from the parent.
 TEST_F(ViewLayerTest, OrphanLayerAfterViewRemove) {
   View* content_view = new View;
   widget()->SetContentsView(content_view);
 
   View* v1 = new View;
   content_view->AddChildView(v1);
 
   View* v2 = new View;
   v1->AddChildView(v2);
-  v2->SetPaintToLayer(true);
+  v2->SetPaintToLayer(ui::LAYER_TEXTURED);
   EXPECT_TRUE(LayerIsAncestor(widget()->GetCompositor()->root_layer(),
                               v2->layer()));
   EXPECT_TRUE(v2->layer()->IsDrawn());
 
   content_view->RemoveChildView(v1);
 
   EXPECT_FALSE(LayerIsAncestor(widget()->GetCompositor()->root_layer(),
                                v2->layer()));
 
   // Reparent |v2|.
@@ skipping 22 matching lines @@
 };
 
 // Makes sure child views with layers aren't painted when paint starts at an
 // ancestor.
 TEST_F(ViewLayerTest, DontPaintChildrenWithLayers) {
   // TODO(sad): DrawWaiterForTest does not work with mus. crbug.com/618136
   if (IsMus())
     return;
   PaintTrackingView* content_view = new PaintTrackingView;
   widget()->SetContentsView(content_view);
-  content_view->SetPaintToLayer(true);
+  content_view->SetPaintToLayer(ui::LAYER_TEXTURED);
   GetRootLayer()->GetCompositor()->ScheduleDraw();
   ui::DrawWaiterForTest::WaitForCompositingEnded(
       GetRootLayer()->GetCompositor());
   GetRootLayer()->SchedulePaint(gfx::Rect(0, 0, 10, 10));
   content_view->set_painted(false);
   // content_view no longer has a dirty rect. Paint from the root and make sure
   // PaintTrackingView isn't painted.
   GetRootLayer()->GetCompositor()->ScheduleDraw();
   ui::DrawWaiterForTest::WaitForCompositingEnded(
       GetRootLayer()->GetCompositor());
@@ skipping 29 matching lines @@
 }
 
 TEST_F(ViewLayerTest, ParentPaintWhenSwitchingPaintToLayerFromFalseToTrue) {
   TestView parent_view;
   parent_view.SetBounds(10, 11, 12, 13);
 
   TestView* child_view = new TestView;
   parent_view.AddChildView(child_view);
 
   parent_view.scheduled_paint_rects_.clear();
-  child_view->SetPaintToLayer(true);
+  child_view->SetPaintToLayer(ui::LAYER_TEXTURED);
   EXPECT_EQ(1U, parent_view.scheduled_paint_rects_.size());
 }
 
 TEST_F(ViewLayerTest, NoParentPaintWhenSwitchingPaintToLayerFromTrueToTrue) {
   TestView parent_view;
   parent_view.SetBounds(10, 11, 12, 13);
 
   TestView* child_view = new TestView;
-  child_view->SetPaintToLayer(true);
+  child_view->SetPaintToLayer(ui::LAYER_TEXTURED);
   parent_view.AddChildView(child_view);
 
   parent_view.scheduled_paint_rects_.clear();
   EXPECT_EQ(0U, parent_view.scheduled_paint_rects_.size());
 }
 
 // Tests that the visibility of child layers are updated correctly when a View's
 // visibility changes.
 TEST_F(ViewLayerTest, VisibilityChildLayers) {
   View* v1 = new View;
-  v1->SetPaintToLayer(true);
+  v1->SetPaintToLayer(ui::LAYER_TEXTURED);
   widget()->SetContentsView(v1);
 
   View* v2 = new View;
   v1->AddChildView(v2);
 
   View* v3 = new View;
   v2->AddChildView(v3);
   v3->SetVisible(false);
 
   View* v4 = new View;
-  v4->SetPaintToLayer(true);
+  v4->SetPaintToLayer(ui::LAYER_TEXTURED);
   v3->AddChildView(v4);
 
   EXPECT_TRUE(v1->layer()->IsDrawn());
   EXPECT_FALSE(v4->layer()->IsDrawn());
 
   v2->SetVisible(false);
   EXPECT_TRUE(v1->layer()->IsDrawn());
   EXPECT_FALSE(v4->layer()->IsDrawn());
 
   v2->SetVisible(true);
@@ skipping 15 matching lines @@
   EXPECT_TRUE(v1->layer()->IsDrawn());
   EXPECT_TRUE(v4->layer()->IsDrawn());
   EXPECT_TRUE(ViewAndLayerTreeAreConsistent(v1, v1->layer()));
 }
 
 // This test creates a random View tree, and then randomly reorders child views,
 // reparents views etc. Unrelated changes can appear to break this test. So
 // marking this as FLAKY.
 TEST_F(ViewLayerTest, DISABLED_ViewLayerTreesInSync) {
   View* content = new View;
-  content->SetPaintToLayer(true);
+  content->SetPaintToLayer(ui::LAYER_TEXTURED);
   widget()->SetContentsView(content);
   widget()->Show();
 
   ConstructTree(content, 5);
   EXPECT_TRUE(ViewAndLayerTreeAreConsistent(content, content->layer()));
 
   ScrambleTree(content);
   EXPECT_TRUE(ViewAndLayerTreeAreConsistent(content, content->layer()));
 
   ScrambleTree(content);
   EXPECT_TRUE(ViewAndLayerTreeAreConsistent(content, content->layer()));
 
   ScrambleTree(content);
   EXPECT_TRUE(ViewAndLayerTreeAreConsistent(content, content->layer()));
 }
 
 // Verifies when views are reordered the layer is also reordered. The widget is
 // providing the parent layer.
 TEST_F(ViewLayerTest, ReorderUnderWidget) {
   View* content = new View;
   widget()->SetContentsView(content);
   View* c1 = new View;
-  c1->SetPaintToLayer(true);
+  c1->SetPaintToLayer(ui::LAYER_TEXTURED);
   content->AddChildView(c1);
   View* c2 = new View;
-  c2->SetPaintToLayer(true);
+  c2->SetPaintToLayer(ui::LAYER_TEXTURED);
   content->AddChildView(c2);
 
   ui::Layer* parent_layer = c1->layer()->parent();
   ASSERT_TRUE(parent_layer);
   ASSERT_EQ(2u, parent_layer->children().size());
   EXPECT_EQ(c1->layer(), parent_layer->children()[0]);
   EXPECT_EQ(c2->layer(), parent_layer->children()[1]);
 
   // Move c1 to the front. The layers should have moved too.
   content->ReorderChildView(c1, -1);
   EXPECT_EQ(c1->layer(), parent_layer->children()[1]);
   EXPECT_EQ(c2->layer(), parent_layer->children()[0]);
 }
 
 // Verifies that the layer of a view can be acquired properly.
 TEST_F(ViewLayerTest, AcquireLayer) {
   View* content = new View;
   widget()->SetContentsView(content);
   std::unique_ptr<View> c1(new View);
-  c1->SetPaintToLayer(true);
+  c1->SetPaintToLayer(ui::LAYER_TEXTURED);
   EXPECT_TRUE(c1->layer());
   content->AddChildView(c1.get());
 
   std::unique_ptr<ui::Layer> layer(c1->AcquireLayer());
   EXPECT_EQ(layer.get(), c1->layer());
 
   std::unique_ptr<ui::Layer> layer2(c1->RecreateLayer());
   EXPECT_NE(c1->layer(), layer2.get());
 
   // Destroy view before destroying layer.
   c1.reset();
 }
 
 // Verify the z-order of the layers as a result of calling RecreateLayer().
 TEST_F(ViewLayerTest, RecreateLayerZOrder) {
   std::unique_ptr<View> v(new View());
-  v->SetPaintToLayer(true);
+  v->SetPaintToLayer(ui::LAYER_TEXTURED);
 
   View* v1 = new View();
-  v1->SetPaintToLayer(true);
+  v1->SetPaintToLayer(ui::LAYER_TEXTURED);
   v->AddChildView(v1);
   View* v2 = new View();
-  v2->SetPaintToLayer(true);
+  v2->SetPaintToLayer(ui::LAYER_TEXTURED);
   v->AddChildView(v2);
 
   // Test the initial z-order.
   const std::vector<ui::Layer*>& child_layers_pre = v->layer()->children();
   ASSERT_EQ(2u, child_layers_pre.size());
   EXPECT_EQ(v1->layer(), child_layers_pre[0]);
   EXPECT_EQ(v2->layer(), child_layers_pre[1]);
 
   std::unique_ptr<ui::Layer> v1_old_layer(v1->RecreateLayer());
 
   // Test the new layer order. We expect: |v1| |v1_old_layer| |v2|.
   // for |v1| and |v2|.
   const std::vector<ui::Layer*>& child_layers_post = v->layer()->children();
   ASSERT_EQ(3u, child_layers_post.size());
   EXPECT_EQ(v1->layer(), child_layers_post[0]);
   EXPECT_EQ(v1_old_layer.get(), child_layers_post[1]);
   EXPECT_EQ(v2->layer(), child_layers_post[2]);
 }
 
 // Verify the z-order of the layers as a result of calling RecreateLayer when
 // the widget is the parent with the layer.
 TEST_F(ViewLayerTest, RecreateLayerZOrderWidgetParent) {
   View* v = new View();
   widget()->SetContentsView(v);
 
   View* v1 = new View();
-  v1->SetPaintToLayer(true);
+  v1->SetPaintToLayer(ui::LAYER_TEXTURED);
   v->AddChildView(v1);
   View* v2 = new View();
-  v2->SetPaintToLayer(true);
+  v2->SetPaintToLayer(ui::LAYER_TEXTURED);
   v->AddChildView(v2);
 
   ui::Layer* root_layer = GetRootLayer();
 
   // Test the initial z-order.
   const std::vector<ui::Layer*>& child_layers_pre = root_layer->children();
   ASSERT_EQ(2u, child_layers_pre.size());
   EXPECT_EQ(v1->layer(), child_layers_pre[0]);
   EXPECT_EQ(v2->layer(), child_layers_pre[1]);
 
   std::unique_ptr<ui::Layer> v1_old_layer(v1->RecreateLayer());
 
   // Test the new layer order. We expect: |v1| |v1_old_layer| |v2|.
   const std::vector<ui::Layer*>& child_layers_post = root_layer->children();
   ASSERT_EQ(3u, child_layers_post.size());
   EXPECT_EQ(v1->layer(), child_layers_post[0]);
   EXPECT_EQ(v1_old_layer.get(), child_layers_post[1]);
   EXPECT_EQ(v2->layer(), child_layers_post[2]);
 }
 
 // Verifies RecreateLayer() moves all Layers over, even those that don't have
 // a View.
 TEST_F(ViewLayerTest, RecreateLayerMovesNonViewChildren) {
   View v;
-  v.SetPaintToLayer(true);
+  v.SetPaintToLayer(ui::LAYER_TEXTURED);
   View child;
-  child.SetPaintToLayer(true);
+  child.SetPaintToLayer(ui::LAYER_TEXTURED);
   v.AddChildView(&child);
   ASSERT_TRUE(v.layer() != NULL);
   ASSERT_EQ(1u, v.layer()->children().size());
   EXPECT_EQ(v.layer()->children()[0], child.layer());
 
   ui::Layer layer(ui::LAYER_NOT_DRAWN);
   v.layer()->Add(&layer);
   v.layer()->StackAtBottom(&layer);
 
   std::unique_ptr<ui::Layer> old_layer(v.RecreateLayer());
@@ skipping 23 matching lines @@
   View* v11 = new View;
   v1->AddChildView(v11);
 
   widget()->SetContentsView(v1);
 
   const gfx::Size& size = GetRootLayer()->GetCompositor()->size();
   GetRootLayer()->GetCompositor()->SetScaleAndSize(1.25f, size);
 
   v11->SetBoundsRect(gfx::Rect(1, 1, 10, 10));
   v1->SetBoundsRect(gfx::Rect(1, 1, 10, 10));
-  v11->SetPaintToLayer(true);
+  v11->SetPaintToLayer(ui::LAYER_TEXTURED);
 
   EXPECT_EQ("0.40 0.40", ToString(v11->layer()->subpixel_position_offset()));
 
   // Creating a layer in parent should update the child view's layer offset.
-  v1->SetPaintToLayer(true);
+  v1->SetPaintToLayer(ui::LAYER_TEXTURED);
   EXPECT_EQ("-0.20 -0.20", ToString(v1->layer()->subpixel_position_offset()));
   EXPECT_EQ("-0.20 -0.20", ToString(v11->layer()->subpixel_position_offset()));
 
   // DSF change should get propagated and update offsets.
   GetRootLayer()->GetCompositor()->SetScaleAndSize(1.5f, size);
   EXPECT_EQ("0.33 0.33", ToString(v1->layer()->subpixel_position_offset()));
   EXPECT_EQ("0.33 0.33", ToString(v11->layer()->subpixel_position_offset()));
 
   // Deleting parent's layer should update the child view's layer's offset.
-  v1->SetPaintToLayer(false);
+  v1->SetPaintToLayer(ui::LAYER_NOT_DRAWN);
   EXPECT_EQ("0.00 0.00", ToString(v11->layer()->subpixel_position_offset()));
 
   // Setting parent view should update the child view's layer's offset.
   v1->SetBoundsRect(gfx::Rect(2, 2, 10, 10));
   EXPECT_EQ("0.33 0.33", ToString(v11->layer()->subpixel_position_offset()));
 
   // Setting integral DSF should reset the offset.
   GetRootLayer()->GetCompositor()->SetScaleAndSize(2.0f, size);
   EXPECT_EQ("0.00 0.00", ToString(v11->layer()->subpixel_position_offset()));
 }
@@ skipping 130 matching lines @@
 
  private:
   ui::NativeTheme* theme_;
 
   DISALLOW_COPY_AND_ASSIGN(WidgetWithCustomTheme);
 };
 
 // See comment above test for details.
 class ViewThatAddsViewInOnNativeThemeChanged : public View {
  public:
-  ViewThatAddsViewInOnNativeThemeChanged() { SetPaintToLayer(true); }
+  ViewThatAddsViewInOnNativeThemeChanged() {
+    SetPaintToLayer(ui::LAYER_TEXTURED);
+  }
   ~ViewThatAddsViewInOnNativeThemeChanged() override {}
 
   bool on_native_theme_changed_called() const {
     return on_native_theme_changed_called_;
   }
 
   // View:
   void OnNativeThemeChanged(const ui::NativeTheme* theme) override {
     on_native_theme_changed_called_ = true;
     GetWidget()->GetRootView()->AddChildView(new View);
@@ skipping 26 matching lines @@
              const gfx::Rect& rect,
              const ExtraParams& extra) const override {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestNativeTheme);
 };
 
 // Creates and adds a new child view to |parent| that has a layer.
 void AddViewWithChildLayer(View* parent) {
   View* child = new View;
-  child->SetPaintToLayer(true);
+  child->SetPaintToLayer(ui::LAYER_TEXTURED);
   parent->AddChildView(child);
 }
 
 // This test does the following:
 // . creates a couple of views with layers added to the root.
 // . Add a view that overrides OnNativeThemeChanged(). In
 //   OnNativeThemeChanged() another view is added.
 // This sequence triggered DCHECKs or crashes previously. This tests verifies
 // that doesn't happen. Reason for crash was OnNativeThemeChanged() was called
 // before the layer hierarchy was updated. OnNativeThemeChanged() should be
@@ skipping 10 matching lines @@
   ViewThatAddsViewInOnNativeThemeChanged* v =
       new ViewThatAddsViewInOnNativeThemeChanged;
   widget.GetRootView()->AddChildView(v);
   EXPECT_TRUE(v->on_native_theme_changed_called());
 }
 
 // A View that removes its Layer when hidden.
 class NoLayerWhenHiddenView : public View {
  public:
   NoLayerWhenHiddenView() {
-    SetPaintToLayer(true);
+    SetPaintToLayer(ui::LAYER_TEXTURED);
     set_owned_by_client();
     SetBounds(0, 0, 100, 100);
   }
 
   bool was_hidden() const { return was_hidden_; }
 
   // View:
   void VisibilityChanged(View* starting_from, bool is_visible) override {
     if (!is_visible) {
       was_hidden_ = true;
-      SetPaintToLayer(false);
+      SetPaintToLayer(ui::LAYER_NOT_DRAWN);
     }
   }
 
  private:
   bool was_hidden_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(NoLayerWhenHiddenView);
 };
 
 // Test that Views can safely manipulate Layers during Widget closure.
@@ skipping 46 matching lines @@
     return children;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(OrderableView);
 };
 
 TEST_F(ViewTest, ChildViewZOrderChanged) {
   const int kChildrenCount = 4;
   std::unique_ptr<View> view(new OrderableView());
-  view->SetPaintToLayer(true);
+  view->SetPaintToLayer(ui::LAYER_TEXTURED);
   for (int i = 0; i < kChildrenCount; ++i)
     AddViewWithChildLayer(view.get());
   View::Views children = view->GetChildrenInZOrder();
   const std::vector<ui::Layer*>& layers = view->layer()->children();
   EXPECT_EQ(kChildrenCount, static_cast<int>(layers.size()));
   EXPECT_EQ(kChildrenCount, static_cast<int>(children.size()));
   for (int i = 0; i < kChildrenCount; ++i) {
     EXPECT_EQ(view->child_at(i)->layer(), layers[i]);
     EXPECT_EQ(view->child_at(i), children[i]);
   }
@@ skipping 167 matching lines @@
   std::unique_ptr<View> view = NewView();
   std::unique_ptr<View> child_view = NewView();
   std::unique_ptr<View> child_view2 = NewView();
   view->AddChildView(child_view.get());
   view->AddChildView(child_view2.get());
   view->ReorderChildView(child_view2.get(), 0);
   EXPECT_EQ(child_view2.get(), view_reordered());
 }
 
 }  // namespace views