Add gesture target fuzzing to views

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/string_util.h"
 #include "base/utf_string_conversions.h"
@@ skipping 629 matching lines @@
   v1->last_gesture_event_type_ = ui::ET_UNKNOWN;
   v3->last_gesture_event_type_ = ui::ET_UNKNOWN;
   root->OnGestureEvent(g1);
   EXPECT_EQ(ui::ET_GESTURE_TAP, v1->last_gesture_event_type_);
   EXPECT_EQ(ui::ET_UNKNOWN, v3->last_gesture_event_type_);
   EXPECT_EQ("110,110", v1->location_.ToString());
 
   widget->CloseNow();
 }
 
+TEST_F(ViewTest, GestureEventWithFuzzing) {
+  scoped_ptr<Widget> widget(new Widget());
+  Widget::InitParams params(Widget::InitParams::TYPE_POPUP);
+  params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
+  params.bounds = gfx::Rect(0, 0, 500, 500);
+  widget->Init(params);
+  View* root_view = widget->GetRootView();
+
+  // Have this hierarchy of views (the coords here are all in root coord):
+  // v1 (0, 0, 100, 100)
+  // v2 (150, 0, 250, 100)
+  // v3 (0, 200, 150, 100)
+  //     v31 (10, 210, 80, 80)
+  //     v32 (110, 210, 30, 80)
+  // v4 (300, 200, 100, 100)
+  //     v41 (310, 210, 80, 80)
+  //         v411 (370, 275, 10, 5)
+
+  // The coordinates used for SetBounds are in parent coordinates
+
+  TestView* v1 = new TestViewConsumeGesture();
+  v1->SetBounds(0, 0, 100, 100);
+  root_view->AddChildView(v1);
+
+  TestView* v2 = new TestViewConsumeGesture();
+  v2->SetBounds(150, 0, 250, 100);
+  root_view->AddChildView(v2);
+
+  TestView* v3 = new TestViewConsumeGesture();
+  v3->SetBounds(0, 200, 150, 100);
+  root_view->AddChildView(v3);
+
+  TestView* v4 = new TestViewConsumeGesture();
+  v4->SetBounds(300, 200, 100, 100);
+  root_view->AddChildView(v4);
+
+  TestView* v31 = new TestViewIgnoreGesture();
+  v31->SetBounds(10, 10, 80, 80);
+  v3->AddChildView(v31);
+
+  TestView* v32 = new TestViewConsumeGesture();
+  v32->SetBounds(110, 10, 30, 80);
+  v3->AddChildView(v32);
+
+  TestView* v41 = new TestViewConsumeGesture();
+  v41->SetBounds(10, 10, 80, 80);
+  v4->AddChildView(v41);
+
+  TestView* v411 = new TestViewIgnoreGesture();
+  v411->SetBounds(60, 65, 10, 5);
+  v41->AddChildView(v411);
+
+  v1->Reset();
+  v2->Reset();
+  v3->Reset();
+  v4->Reset();
+  v31->Reset();
+  v32->Reset();
+  v41->Reset();
+  v411->Reset();
+
+  // Covers v1 by enough
+  ui::GestureEventDetails gesture_details(ui::ET_GESTURE_TAP, 0, 0);
+  gesture_details.set_bounding_box(gfx::Rect(15, 15, 100, 100));
+  GestureEventForTest g1(ui::ET_GESTURE_TAP, 65, 65, 0, gesture_details);
+  root_view->OnGestureEvent(g1);
+  EXPECT_EQ(ui::ET_GESTURE_TAP, v1->last_gesture_event_type_);
+  GestureEventForTest g1_up(ui::ET_GESTURE_END, 65, 65, 0);
+  root_view->OnGestureEvent(g1_up);
+  v1->Reset();
+
+  // Intersects v1 but does not cover by enough, center point is in v1
+  gesture_details.set_bounding_box(gfx::Rect(80, 80, 20, 20));
+  GestureEventForTest g2(ui::ET_GESTURE_TAP, 90, 90, 0, gesture_details);
+  root_view->OnGestureEvent(g2);
+  EXPECT_EQ(ui::ET_GESTURE_TAP, v1->last_gesture_event_type_);
+  GestureEventForTest g2_up(ui::ET_GESTURE_END, 90, 90, 0);
+  root_view->OnGestureEvent(g2_up);
+  v1->Reset();
+
+  // Intersects nothing
+  gesture_details.set_bounding_box(gfx::Rect(105, 105, 30, 45));
+  GestureEventForTest g3(ui::ET_GESTURE_TAP, 120, 127, 0, gesture_details);
+  root_view->OnGestureEvent(g3);
+  EXPECT_EQ(ui::ET_UNKNOWN, v1->last_gesture_event_type_);
+  EXPECT_EQ(ui::ET_UNKNOWN, v2->last_gesture_event_type_);
+  EXPECT_EQ(ui::ET_UNKNOWN, v3->last_gesture_event_type_);
+  EXPECT_EQ(ui::ET_UNKNOWN, v32->last_gesture_event_type_);
+  EXPECT_EQ(ui::ET_UNKNOWN, v4->last_gesture_event_type_);
+  EXPECT_EQ(ui::ET_UNKNOWN, v41->last_gesture_event_type_);
+  GestureEventForTest g3_up(ui::ET_GESTURE_END, 120, 127, 0);
+  root_view->OnGestureEvent(g3_up);
+
+  // Intersects v2 and covers by enough,
+  // Intersects v1 but does not cover by enough
+  gesture_details.set_bounding_box(gfx::Rect(95, 10, 300, 120));
+  GestureEventForTest g4(ui::ET_GESTURE_TAP, 245, 70, 0, gesture_details);
+  root_view->OnGestureEvent(g4);
+  EXPECT_EQ(ui::ET_UNKNOWN, v1->last_gesture_event_type_);
+  EXPECT_EQ(ui::ET_GESTURE_TAP, v2->last_gesture_event_type_);
+  GestureEventForTest g4_up(ui::ET_GESTURE_END, 245, 70, 0);
+  root_view->OnGestureEvent(g4_up);
+  v1->Reset();
+  v2->Reset();
+
+  // Intersects v1 and v2 and covers by enough, closer to v2
+  gesture_details.set_bounding_box(gfx::Rect(20, 20, 400, 100));
+  GestureEventForTest g5(ui::ET_GESTURE_TAP, 220, 70, 0, gesture_details);
+  root_view->OnGestureEvent(g5);
+  EXPECT_EQ(ui::ET_UNKNOWN, v1->last_gesture_event_type_);
+  EXPECT_EQ(ui::ET_GESTURE_TAP, v2->last_gesture_event_type_);
+  GestureEventForTest g5_up(ui::ET_GESTURE_END, 220, 70, 0);
+  root_view->OnGestureEvent(g5_up);
+  v1->Reset();
+  v2->Reset();
+
+  // Covers all of v3 up to left side of v32
+  gesture_details.set_bounding_box(gfx::Rect(0, 200, 110, 100));
+  GestureEventForTest g6(ui::ET_GESTURE_TAP, 55, 250, 0, gesture_details);
+  root_view->OnGestureEvent(g6);
+  EXPECT_EQ(ui::ET_UNKNOWN, v31->last_gesture_event_type_);
+  EXPECT_EQ(ui::ET_UNKNOWN, v32->last_gesture_event_type_);
+  EXPECT_EQ(ui::ET_GESTURE_TAP, v3->last_gesture_event_type_);
+  GestureEventForTest g6_up(ui::ET_GESTURE_END, 55, 250, 0);
+  root_view->OnGestureEvent(g6_up);
+  v31->Reset();
+  v32->Reset();
+  v3->Reset();
+
+  // Covers all of v3
+  gesture_details.set_bounding_box(gfx::Rect(0, 200, 150, 100));
+  GestureEventForTest g7(ui::ET_GESTURE_TAP, 75, 250, 0, gesture_details);
+  root_view->OnGestureEvent(g7);
+  EXPECT_EQ(ui::ET_UNKNOWN, v31->last_gesture_event_type_);
+  EXPECT_EQ(ui::ET_UNKNOWN, v32->last_gesture_event_type_);
+  EXPECT_EQ(ui::ET_GESTURE_TAP, v3->last_gesture_event_type_);
+  GestureEventForTest g7_up(ui::ET_GESTURE_END, 75, 250, 0);
+  root_view->OnGestureEvent(g7_up);
+  v31->Reset();
+  v32->Reset();
+  v3->Reset();
+
+  // Covers right half of v3
+  gesture_details.set_bounding_box(gfx::Rect(75, 200, 75, 100));
+  GestureEventForTest g8(ui::ET_GESTURE_TAP, 112, 250, 0, gesture_details);
+  root_view->OnGestureEvent(g8);
+  EXPECT_EQ(ui::ET_UNKNOWN, v31->last_gesture_event_type_);
+  EXPECT_EQ(ui::ET_GESTURE_TAP, v32->last_gesture_event_type_);
+  EXPECT_EQ(ui::ET_UNKNOWN, v3->last_gesture_event_type_);
+  GestureEventForTest g8_up(ui::ET_GESTURE_END, 112, 250, 0);
+  root_view->OnGestureEvent(g8_up);
+  v31->Reset();
+  v32->Reset();
+  v3->Reset();
+
+  // Covers v31 and v32 by enough, but closer to v32
+  gesture_details.set_bounding_box(gfx::Rect(30, 225, 180, 115));
+  GestureEventForTest g9(ui::ET_GESTURE_TAP, 120, 282, 0, gesture_details);
+  root_view->OnGestureEvent(g9);
+  EXPECT_EQ(ui::ET_UNKNOWN, v31->last_gesture_event_type_);
+  EXPECT_EQ(ui::ET_GESTURE_TAP, v32->last_gesture_event_type_);
+  EXPECT_EQ(ui::ET_UNKNOWN, v3->last_gesture_event_type_);
+  GestureEventForTest g9_up(ui::ET_GESTURE_END, 120, 282, 0);
+  root_view->OnGestureEvent(g9_up);
+  v31->Reset();
+  v32->Reset();
+  v3->Reset();
+
+  // Covers all of v41
+  gesture_details.set_bounding_box(gfx::Rect(310, 210, 80, 80));
+  GestureEventForTest g10(ui::ET_GESTURE_TAP, 350, 250, 0, gesture_details);
+  root_view->OnGestureEvent(g10);
+  EXPECT_EQ(ui::ET_UNKNOWN, v4->last_gesture_event_type_);
+  EXPECT_EQ(ui::ET_GESTURE_TAP, v41->last_gesture_event_type_);
+  EXPECT_EQ(ui::ET_UNKNOWN, v411->last_gesture_event_type_);
+  GestureEventForTest g10_up(ui::ET_GESTURE_END, 350, 250, 0);
+  root_view->OnGestureEvent(g10_up);
+  v4->Reset();
+  v41->Reset();
+  v411->Reset();
+
+  // Covers all of v411
+  gesture_details.set_bounding_box(gfx::Rect(370, 275, 10, 5));
+  GestureEventForTest g11(ui::ET_GESTURE_TAP, 375, 277, 0, gesture_details);
+  root_view->OnGestureEvent(g11);
+  EXPECT_EQ(ui::ET_UNKNOWN, v4->last_gesture_event_type_);
+  EXPECT_EQ(ui::ET_GESTURE_TAP, v41->last_gesture_event_type_);
+  EXPECT_EQ(ui::ET_UNKNOWN, v411->last_gesture_event_type_);
+  GestureEventForTest g11_up(ui::ET_GESTURE_END, 375, 277, 0);
+  root_view->OnGestureEvent(g11_up);
+  v4->Reset();
+  v41->Reset();
+  v411->Reset();
+
+  // Intersects v41 and v411 but covers neither by enough
+  gesture_details.set_bounding_box(gfx::Rect(368, 272, 5, 8));
+  GestureEventForTest g12(ui::ET_GESTURE_TAP, 370, 276, 0, gesture_details);
+  root_view->OnGestureEvent(g12);
+  EXPECT_EQ(ui::ET_UNKNOWN, v4->last_gesture_event_type_);
+  EXPECT_EQ(ui::ET_GESTURE_TAP, v41->last_gesture_event_type_);
+  EXPECT_EQ(ui::ET_UNKNOWN, v411->last_gesture_event_type_);
+  GestureEventForTest g12_up(ui::ET_GESTURE_END, 370, 276, 0);
+  root_view->OnGestureEvent(g12_up);
+  v4->Reset();
+  v41->Reset();
+  v411->Reset();
+
+  // Center point in v4, intersects v41 but not by enough
+  gesture_details.set_bounding_box(gfx::Rect(285, 185, 40, 40));
+  GestureEventForTest g13(ui::ET_GESTURE_TAP, 305, 205, 0, gesture_details);
+  root_view->OnGestureEvent(g13);
+  EXPECT_EQ(ui::ET_GESTURE_TAP, v4->last_gesture_event_type_);
+  EXPECT_EQ(ui::ET_UNKNOWN, v41->last_gesture_event_type_);
+  EXPECT_EQ(ui::ET_UNKNOWN, v411->last_gesture_event_type_);
+  GestureEventForTest g13_up(ui::ET_GESTURE_END, 305, 205, 0);
+  root_view->OnGestureEvent(g13_up);
+  v4->Reset();
+  v41->Reset();
+  v411->Reset();
+
+  // Intersects v31, v32 (covers by enough), v411 (does not cover
+  // by enough) and is closest to v32
+  gesture_details.set_bounding_box(gfx::Rect(20, 222, 352, 250));
+  GestureEventForTest g14(ui::ET_GESTURE_TAP, 196, 347, 0, gesture_details);
+  root_view->OnGestureEvent(g14);
+  EXPECT_EQ(ui::ET_UNKNOWN, v1->last_gesture_event_type_);
+  EXPECT_EQ(ui::ET_UNKNOWN, v2->last_gesture_event_type_);
+  EXPECT_EQ(ui::ET_UNKNOWN, v3->last_gesture_event_type_);
+  EXPECT_EQ(ui::ET_UNKNOWN, v4->last_gesture_event_type_);
+  EXPECT_EQ(ui::ET_UNKNOWN, v31->last_gesture_event_type_);
+  EXPECT_EQ(ui::ET_GESTURE_TAP, v32->last_gesture_event_type_);
+  EXPECT_EQ(ui::ET_UNKNOWN, v41->last_gesture_event_type_);
+  EXPECT_EQ(ui::ET_UNKNOWN, v411->last_gesture_event_type_);
+  GestureEventForTest g14_up(ui::ET_GESTURE_END, 196, 347, 0);
+  root_view->OnGestureEvent(g14_up);
+  v1->Reset();
+  v2->Reset();
+  v3->Reset();
+  v4->Reset();
+  v31->Reset();
+  v32->Reset();
+  v41->Reset();
+  v411->Reset();
+
+  // Covers all views completely
+  gesture_details.set_bounding_box(gfx::Rect(0, 0, 400, 300));
+  GestureEventForTest g15(ui::ET_GESTURE_TAP, 200, 150, 0, gesture_details);
+  root_view->OnGestureEvent(g15);
+  EXPECT_EQ(ui::ET_UNKNOWN, v1->last_gesture_event_type_);
+  EXPECT_EQ(ui::ET_GESTURE_TAP, v2->last_gesture_event_type_);
+  EXPECT_EQ(ui::ET_UNKNOWN, v3->last_gesture_event_type_);
+  EXPECT_EQ(ui::ET_UNKNOWN, v4->last_gesture_event_type_);
+  EXPECT_EQ(ui::ET_UNKNOWN, v31->last_gesture_event_type_);
+  EXPECT_EQ(ui::ET_UNKNOWN, v32->last_gesture_event_type_);
+  EXPECT_EQ(ui::ET_UNKNOWN, v41->last_gesture_event_type_);
+  EXPECT_EQ(ui::ET_UNKNOWN, v411->last_gesture_event_type_);
+  GestureEventForTest g15_up(ui::ET_GESTURE_END, 200, 150, 0);
+  root_view->OnGestureEvent(g15_up);
+  v1->Reset();
+  v2->Reset();
+  v3->Reset();
+  v4->Reset();
+  v31->Reset();
+  v32->Reset();
+  v41->Reset();
+  v411->Reset();
+
+  // Covers enough of v32, v2, v411 (closest to v411)
+  gesture_details.set_bounding_box(gfx::Rect(120, 15, 375, 450));
+  GestureEventForTest g16(ui::ET_GESTURE_TAP, 307, 240, 0, gesture_details);
+  root_view->OnGestureEvent(g16);
+  EXPECT_EQ(ui::ET_UNKNOWN, v1->last_gesture_event_type_);
+  EXPECT_EQ(ui::ET_UNKNOWN, v2->last_gesture_event_type_);
+  EXPECT_EQ(ui::ET_UNKNOWN, v3->last_gesture_event_type_);
+  EXPECT_EQ(ui::ET_UNKNOWN, v4->last_gesture_event_type_);
+  EXPECT_EQ(ui::ET_UNKNOWN, v31->last_gesture_event_type_);
+  EXPECT_EQ(ui::ET_UNKNOWN, v32->last_gesture_event_type_);
+  EXPECT_EQ(ui::ET_GESTURE_TAP, v41->last_gesture_event_type_);
+  EXPECT_EQ(ui::ET_UNKNOWN, v411->last_gesture_event_type_);
+  GestureEventForTest g16_up(ui::ET_GESTURE_END, 307, 240, 0);
+  root_view->OnGestureEvent(g16_up);
+  v1->Reset();
+  v2->Reset();
+  v3->Reset();
+  v4->Reset();
+  v31->Reset();
+  v32->Reset();
+  v41->Reset();
+  v411->Reset();
+
+  widget->CloseNow();
+}
+
 TEST_F(ViewTest, ScrollGestureEvent) {
   // Views hierarchy for non delivery of GestureEvent.
   TestView* v1 = new TestViewConsumeGesture();
   v1->SetBoundsRect(gfx::Rect(0, 0, 300, 300));
 
   TestView* v2 = new TestViewIgnoreScrollGestures();
   v2->SetBoundsRect(gfx::Rect(100, 100, 100, 100));
 
   TestView* v3 = new TestViewIgnoreGesture();
   v3->SetBoundsRect(gfx::Rect(0, 0, 100, 100));
@@ skipping 329 matching lines @@
 
   // Test GetEventHandlerForPoint
   EXPECT_EQ(v1, root_view->GetEventHandlerForPoint(v1_centerpoint));
   EXPECT_EQ(v2, root_view->GetEventHandlerForPoint(v2_centerpoint));
   EXPECT_EQ(v1, root_view->GetEventHandlerForPoint(v1_origin));
   EXPECT_EQ(root_view, root_view->GetEventHandlerForPoint(v2_origin));
 
   widget->CloseNow();
 }
 
+TEST_F(ViewTest, GetEventHandlerForRect) {
+  Widget* widget = new Widget;
+  widget->Init(Widget::InitParams(Widget::InitParams::TYPE_POPUP));
+  View* root_view = widget->GetRootView();
+  root_view->SetBoundsRect(gfx::Rect(0, 0, 500, 500));
+
+  // Have this hierarchy of views (the coords here are all in root coord):
+  // v1 (0, 0, 100, 100)
+  // v2 (150, 0, 250, 100)
+  // v3 (0, 200, 150, 100)
+  //     v31 (10, 210, 80, 80)
+  //     v32 (110, 210, 30, 80)
+  // v4 (300, 200, 100, 100)
+  //     v41 (310, 210, 80, 80)
+  //         v411 (370, 275, 10, 5)
+
+  // The coordinates used for SetBounds are in parent coordinates
+
+  TestView* v1 = new TestView;
+  v1->SetBounds(0, 0, 100, 100);
+  root_view->AddChildView(v1);
+
+  TestView* v2 = new TestView;
+  v2->SetBounds(150, 0, 250, 100);
+  root_view->AddChildView(v2);
+
+  TestView* v3 = new TestView;
+  v3->SetBounds(0, 200, 150, 100);
+  root_view->AddChildView(v3);
+
+  TestView* v4 = new TestView;
+  v4->SetBounds(300, 200, 100, 100);
+  root_view->AddChildView(v4);
+
+  TestView* v31 = new TestView;
+  v31->SetBounds(10, 10, 80, 80);
+  v3->AddChildView(v31);
+
+  TestView* v32 = new TestView;
+  v32->SetBounds(110, 10, 30, 80);
+  v3->AddChildView(v32);
+
+  TestView* v41 = new TestView;
+  v41->SetBounds(10, 10, 80, 80);
+  v4->AddChildView(v41);
+
+  TestView* v411 = new TestView;
+  v411->SetBounds(60, 65, 10, 5);
+  v41->AddChildView(v411);
+
+
+  // Covers v1 by enough
+  gfx::Rect touch_rect(15, 15, 100, 100);
+  View* result_view = root_view->GetEventHandlerForRect(touch_rect);
+  EXPECT_EQ(result_view, v1);
+
+  // Intersects v1 but does not cover by enough
+  touch_rect.SetRect(80, 90, 20, 20);
+  result_view = root_view->GetEventHandlerForRect(touch_rect);
+  EXPECT_FALSE(result_view);
+
+  // Intersects nothing
+  touch_rect.SetRect(105, 105, 30, 45);
+  result_view = root_view->GetEventHandlerForRect(touch_rect);
+  EXPECT_FALSE(result_view);
+
+  // Intersects v2 and covers by enough,
+  // Intersects v1 but does not cover by enough
+  touch_rect.SetRect(95, 10, 300, 120);
+  result_view = root_view->GetEventHandlerForRect(touch_rect);
+  EXPECT_EQ(result_view, v2);
+
+  // Intersects v1 and v2 and covers by enough, closer to v2
+  touch_rect.SetRect(20, 20, 400, 100);
+  result_view = root_view->GetEventHandlerForRect(touch_rect);
+  EXPECT_EQ(result_view, v2);
+
+  // Covers all of v3 up to left side of v32
+  touch_rect.SetRect(0, 200, 110, 100);
+  result_view = root_view->GetEventHandlerForRect(touch_rect);
+  EXPECT_EQ(result_view, v31);
+
+  // Covers all of v3
+  touch_rect.SetRect(0, 200, 150, 100);
+  result_view = root_view->GetEventHandlerForRect(touch_rect);
+  EXPECT_EQ(result_view, v31);
+
+  // Covers right half of v3
+  touch_rect.SetRect(75, 200, 75, 100);
+  result_view = root_view->GetEventHandlerForRect(touch_rect);
+  EXPECT_EQ(result_view, v32);
+
+  // Covers v31 and v32 by enough, but closer to v32
+  touch_rect.SetRect(30, 225, 180, 115);
+  result_view = root_view->GetEventHandlerForRect(touch_rect);
+  EXPECT_EQ(result_view, v32);
+
+  // Covers all of v41
+  touch_rect.SetRect(310, 210, 80, 80);
+  result_view = root_view->GetEventHandlerForRect(touch_rect);
+  EXPECT_EQ(result_view, v411);
+
+  // Covers all of v411
+  touch_rect.SetRect(370, 275, 10, 5);
+  result_view = root_view->GetEventHandlerForRect(touch_rect);
+  EXPECT_EQ(result_view, v411);
+
+  // Intersects v41 and v411 but covers neither by enough
+  touch_rect.SetRect(368, 272, 5, 8);
+  result_view = root_view->GetEventHandlerForRect(touch_rect);
+  EXPECT_FALSE(result_view);
+
+  // Covers enough of v41 but not enough of v411
+  touch_rect.SetRect(315, 212, 62, 64);
+  result_view = root_view->GetEventHandlerForRect(touch_rect);
+  EXPECT_FALSE(result_view);
+
+  // Intersects v31, v32 (covers by enough), v4111 (does not cover
+  // by enough) and is closest to v32
+  touch_rect.SetRect(20, 222, 352, 250);
+  result_view = root_view->GetEventHandlerForRect(touch_rect);
+  EXPECT_EQ(result_view, v32);
+
+  // Covers all views completely
+  touch_rect.SetRect(0, 0, 400, 300);
+  result_view = root_view->GetEventHandlerForRect(touch_rect);
+  EXPECT_EQ(result_view, v2);
+
+  // Covers enough of v32, v2, v411 (closest to v411)
+  touch_rect.SetRect(120, 15, 375, 450);
+  result_view = root_view->GetEventHandlerForRect(touch_rect);
+  EXPECT_EQ(result_view, v411);
+
+  widget->CloseNow();
+}
+
 TEST_F(ViewTest, NotifyEnterExitOnChild) {
   Widget* widget = new Widget;
   widget->Init(Widget::InitParams(Widget::InitParams::TYPE_POPUP));
   View* root_view = widget->GetRootView();
   root_view->SetBoundsRect(gfx::Rect(0, 0, 500, 500));
 
   // Have this hierarchy of views (the coords here are in root coord):
   // v1 (0, 0, 100, 100)
   //  - v11 (0, 0, 20, 30)
   //    - v111 (5, 5, 5, 15)
@@ skipping 2328 matching lines @@
   // Set to non default value.
   v->layer()->set_scale_content(false);
   scoped_ptr<ui::Layer> old_layer(v->RecreateLayer());
   ui::Layer* new_layer = v->layer();
   EXPECT_EQ(false, new_layer->scale_content());
 }
 
 #endif  // USE_AURA
 
 }  // namespace views