Runs most aura tests with both backends

ui/aura/window_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/aura/window.h"
 
 #include <limits.h>
 
 #include <string>
 #include <utility>
@@ skipping 109 matching lines @@
 
 }  // namespace
 
 DECLARE_WINDOW_PROPERTY_TYPE(TestProperty*);
 
 DECLARE_WINDOW_PROPERTY_TYPE(DeletionTestProperty*);
 
 namespace aura {
 namespace test {
 
-class WindowTest : public AuraTestBase {
+class WindowTest : public AuraTestBaseWithType {
  public:
   WindowTest() : max_separation_(0) {
   }
 
   void SetUp() override {
-    AuraTestBase::SetUp();
+    AuraTestBaseWithType::SetUp();
     // TODO: there needs to be an easier way to do this.
     max_separation_ = ui::GestureConfiguration::GetInstance()
                           ->max_separation_for_gesture_touches_in_pixels();
     ui::GestureConfiguration::GetInstance()
         ->set_max_separation_for_gesture_touches_in_pixels(0);
   }
 
   void TearDown() override {
     AuraTestBase::TearDown();
     ui::GestureConfiguration::GetInstance()
@@ skipping 177 matching lines @@
 };
 
 void OffsetBounds(Window* window, int horizontal, int vertical) {
   gfx::Rect bounds = window->bounds();
   bounds.Offset(horizontal, vertical);
   window->SetBounds(bounds);
 }
 
 }  // namespace
 
-TEST_F(WindowTest, GetChildById) {
+TEST_P(WindowTest, GetChildById) {
   std::unique_ptr<Window> w1(CreateTestWindowWithId(1, root_window()));
   std::unique_ptr<Window> w11(CreateTestWindowWithId(11, w1.get()));
   std::unique_ptr<Window> w111(CreateTestWindowWithId(111, w11.get()));
   std::unique_ptr<Window> w12(CreateTestWindowWithId(12, w1.get()));
 
   EXPECT_EQ(NULL, w1->GetChildById(57));
   EXPECT_EQ(w12.get(), w1->GetChildById(12));
   EXPECT_EQ(w111.get(), w1->GetChildById(111));
 }
 
 // Make sure that Window::Contains correctly handles children, grandchildren,
 // and not containing NULL or parents.
-TEST_F(WindowTest, Contains) {
+TEST_P(WindowTest, Contains) {
   Window parent(NULL);
   parent.Init(ui::LAYER_NOT_DRAWN);
   Window child1(NULL);
   child1.Init(ui::LAYER_NOT_DRAWN);
   Window child2(NULL);
   child2.Init(ui::LAYER_NOT_DRAWN);
 
   parent.AddChild(&child1);
   child1.AddChild(&child2);
 
   EXPECT_TRUE(parent.Contains(&parent));
   EXPECT_TRUE(parent.Contains(&child1));
   EXPECT_TRUE(parent.Contains(&child2));
 
   EXPECT_FALSE(parent.Contains(NULL));
   EXPECT_FALSE(child1.Contains(&parent));
   EXPECT_FALSE(child2.Contains(&child1));
 }
 
-TEST_F(WindowTest, ContainsPointInRoot) {
+TEST_P(WindowTest, ContainsPointInRoot) {
   std::unique_ptr<Window> w(CreateTestWindow(
       SK_ColorWHITE, 1, gfx::Rect(10, 10, 5, 5), root_window()));
   EXPECT_FALSE(w->ContainsPointInRoot(gfx::Point(9, 9)));
   EXPECT_TRUE(w->ContainsPointInRoot(gfx::Point(10, 10)));
   EXPECT_TRUE(w->ContainsPointInRoot(gfx::Point(14, 14)));
   EXPECT_FALSE(w->ContainsPointInRoot(gfx::Point(15, 15)));
   EXPECT_FALSE(w->ContainsPointInRoot(gfx::Point(20, 20)));
 }
 
-TEST_F(WindowTest, ContainsPoint) {
+TEST_P(WindowTest, ContainsPoint) {
   std::unique_ptr<Window> w(CreateTestWindow(
       SK_ColorWHITE, 1, gfx::Rect(10, 10, 5, 5), root_window()));
   EXPECT_TRUE(w->ContainsPoint(gfx::Point(0, 0)));
   EXPECT_TRUE(w->ContainsPoint(gfx::Point(4, 4)));
   EXPECT_FALSE(w->ContainsPoint(gfx::Point(5, 5)));
   EXPECT_FALSE(w->ContainsPoint(gfx::Point(10, 10)));
 }
 
-TEST_F(WindowTest, ConvertPointToWindow) {
+TEST_P(WindowTest, ConvertPointToWindow) {
   // Window::ConvertPointToWindow is mostly identical to
   // Layer::ConvertPointToLayer, except NULL values for |source| are permitted,
   // in which case the function just returns.
   std::unique_ptr<Window> w1(CreateTestWindowWithId(1, root_window()));
   gfx::Point reference_point(100, 100);
   gfx::Point test_point = reference_point;
   Window::ConvertPointToTarget(NULL, w1.get(), &test_point);
   EXPECT_EQ(reference_point, test_point);
 }
 
-TEST_F(WindowTest, MoveCursorTo) {
+TEST_P(WindowTest, MoveCursorTo) {
   std::unique_ptr<Window> w1(CreateTestWindow(
       SK_ColorWHITE, 1, gfx::Rect(10, 10, 500, 500), root_window()));
   std::unique_ptr<Window> w11(
       CreateTestWindow(SK_ColorGREEN, 11, gfx::Rect(5, 5, 100, 100), w1.get()));
   std::unique_ptr<Window> w111(
       CreateTestWindow(SK_ColorCYAN, 111, gfx::Rect(5, 5, 75, 75), w11.get()));
   std::unique_ptr<Window> w1111(
       CreateTestWindow(SK_ColorRED, 1111, gfx::Rect(5, 5, 50, 50), w111.get()));
 
   Window* root = root_window();
   root->MoveCursorTo(gfx::Point(10, 10));
   EXPECT_EQ("10,10",
             display::Screen::GetScreen()->GetCursorScreenPoint().ToString());
   w1->MoveCursorTo(gfx::Point(10, 10));
   EXPECT_EQ("20,20",
             display::Screen::GetScreen()->GetCursorScreenPoint().ToString());
   w11->MoveCursorTo(gfx::Point(10, 10));
   EXPECT_EQ("25,25",
             display::Screen::GetScreen()->GetCursorScreenPoint().ToString());
   w111->MoveCursorTo(gfx::Point(10, 10));
   EXPECT_EQ("30,30",
             display::Screen::GetScreen()->GetCursorScreenPoint().ToString());
   w1111->MoveCursorTo(gfx::Point(10, 10));
   EXPECT_EQ("35,35",
             display::Screen::GetScreen()->GetCursorScreenPoint().ToString());
 }
 
-TEST_F(WindowTest, ContainsMouse) {
+TEST_P(WindowTest, ContainsMouse) {
   std::unique_ptr<Window> w(CreateTestWindow(
       SK_ColorWHITE, 1, gfx::Rect(10, 10, 500, 500), root_window()));
   w->Show();
   WindowTestApi w_test_api(w.get());
   Window* root = root_window();
   root->MoveCursorTo(gfx::Point(10, 10));
   EXPECT_TRUE(w_test_api.ContainsMouse());
   root->MoveCursorTo(gfx::Point(9, 10));
   EXPECT_FALSE(w_test_api.ContainsMouse());
 }
 
 // Test Window::ConvertPointToWindow() with transform to root_window.
-TEST_F(WindowTest, MoveCursorToWithTransformRootWindow) {
+TEST_P(WindowTest, MoveCursorToWithTransformRootWindow) {
   gfx::Transform transform;
   transform.Translate(100.0, 100.0);
   transform.Rotate(90.0);
   transform.Scale(2.0, 5.0);
   host()->SetRootTransform(transform);
   host()->MoveCursorTo(gfx::Point(10, 10));
 #if !defined(OS_WIN)
   // TODO(yoshiki): fix this to build on Windows. See crbug.com/133413.OD
   EXPECT_EQ("50,120", QueryLatestMousePositionRequestInHost(host()).ToString());
 #endif
   EXPECT_EQ("10,10",
             display::Screen::GetScreen()->GetCursorScreenPoint().ToString());
 }
 
 // Tests Window::ConvertPointToWindow() with transform to non-root windows.
-TEST_F(WindowTest, MoveCursorToWithTransformWindow) {
+TEST_P(WindowTest, MoveCursorToWithTransformWindow) {
   std::unique_ptr<Window> w1(CreateTestWindow(
       SK_ColorWHITE, 1, gfx::Rect(10, 10, 500, 500), root_window()));
 
   gfx::Transform transform1;
   transform1.Scale(2, 2);
   w1->SetTransform(transform1);
   w1->MoveCursorTo(gfx::Point(10, 10));
   EXPECT_EQ("30,30",
             display::Screen::GetScreen()->GetCursorScreenPoint().ToString());
 
@@ skipping 17 matching lines @@
   transform4.Scale(2.0, 5.0);
   w1->SetTransform(transform4);
   w1->MoveCursorTo(gfx::Point(10, 10));
   EXPECT_EQ("60,130",
             display::Screen::GetScreen()->GetCursorScreenPoint().ToString());
 }
 
 // Test Window::ConvertPointToWindow() with complex transforms to both root and
 // non-root windows.
 // Test Window::ConvertPointToWindow() with transform to root_window.
-TEST_F(WindowTest, MoveCursorToWithComplexTransform) {
+TEST_P(WindowTest, MoveCursorToWithComplexTransform) {
   std::unique_ptr<Window> w1(CreateTestWindow(
       SK_ColorWHITE, 1, gfx::Rect(10, 10, 500, 500), root_window()));
   std::unique_ptr<Window> w11(
       CreateTestWindow(SK_ColorGREEN, 11, gfx::Rect(5, 5, 100, 100), w1.get()));
   std::unique_ptr<Window> w111(
       CreateTestWindow(SK_ColorCYAN, 111, gfx::Rect(5, 5, 75, 75), w11.get()));
   std::unique_ptr<Window> w1111(
       CreateTestWindow(SK_ColorRED, 1111, gfx::Rect(5, 5, 50, 50), w111.get()));
 
   // The root window expects transforms that produce integer rects.
@@ skipping 18 matching lines @@
 #if !defined(OS_WIN)
   // TODO(yoshiki): fix this to build on Windows. See crbug.com/133413.
   EXPECT_EQ("169,80", QueryLatestMousePositionRequestInHost(host()).ToString());
 #endif
   EXPECT_EQ("20,53",
             display::Screen::GetScreen()->GetCursorScreenPoint().ToString());
 }
 
 // Tests that we do not crash when a Window is destroyed by going out of
 // scope (as opposed to being explicitly deleted by its WindowDelegate).
-TEST_F(WindowTest, NoCrashOnWindowDelete) {
+TEST_P(WindowTest, NoCrashOnWindowDelete) {
   CaptureWindowDelegateImpl delegate;
   std::unique_ptr<Window> window(CreateTestWindowWithDelegate(
       &delegate, 0, gfx::Rect(0, 0, 20, 20), root_window()));
 }
 
-TEST_F(WindowTest, GetEventHandlerForPoint) {
+TEST_P(WindowTest, GetEventHandlerForPoint) {
   std::unique_ptr<Window> w1(CreateTestWindow(
       SK_ColorWHITE, 1, gfx::Rect(10, 10, 500, 500), root_window()));
   std::unique_ptr<Window> w11(
       CreateTestWindow(SK_ColorGREEN, 11, gfx::Rect(5, 5, 100, 100), w1.get()));
   std::unique_ptr<Window> w111(
       CreateTestWindow(SK_ColorCYAN, 111, gfx::Rect(5, 5, 75, 75), w11.get()));
   std::unique_ptr<Window> w1111(
       CreateTestWindow(SK_ColorRED, 1111, gfx::Rect(5, 5, 50, 50), w111.get()));
   std::unique_ptr<Window> w12(CreateTestWindow(
       SK_ColorMAGENTA, 12, gfx::Rect(10, 420, 25, 25), w1.get()));
   std::unique_ptr<Window> w121(
       CreateTestWindow(SK_ColorYELLOW, 121, gfx::Rect(5, 5, 5, 5), w12.get()));
   std::unique_ptr<Window> w13(
       CreateTestWindow(SK_ColorGRAY, 13, gfx::Rect(5, 470, 50, 50), w1.get()));
 
   Window* root = root_window();
   w1->parent()->SetBounds(gfx::Rect(500, 500));
   EXPECT_EQ(NULL, root->GetEventHandlerForPoint(gfx::Point(5, 5)));
   EXPECT_EQ(w1.get(), root->GetEventHandlerForPoint(gfx::Point(11, 11)));
   EXPECT_EQ(w11.get(), root->GetEventHandlerForPoint(gfx::Point(16, 16)));
   EXPECT_EQ(w111.get(), root->GetEventHandlerForPoint(gfx::Point(21, 21)));
   EXPECT_EQ(w1111.get(), root->GetEventHandlerForPoint(gfx::Point(26, 26)));
   EXPECT_EQ(w12.get(), root->GetEventHandlerForPoint(gfx::Point(21, 431)));
   EXPECT_EQ(w121.get(), root->GetEventHandlerForPoint(gfx::Point(26, 436)));
   EXPECT_EQ(w13.get(), root->GetEventHandlerForPoint(gfx::Point(26, 481)));
 }
 
-TEST_F(WindowTest, GetEventHandlerForPointWithOverride) {
+TEST_P(WindowTest, GetEventHandlerForPointWithOverride) {
   // If our child is flush to our top-left corner it gets events just inside the
   // window edges.
   std::unique_ptr<Window> parent(CreateTestWindow(
       SK_ColorWHITE, 1, gfx::Rect(10, 20, 400, 500), root_window()));
   std::unique_ptr<Window> child(
       CreateTestWindow(SK_ColorRED, 2, gfx::Rect(0, 0, 60, 70), parent.get()));
   EXPECT_EQ(child.get(), parent->GetEventHandlerForPoint(gfx::Point(0, 0)));
   EXPECT_EQ(child.get(), parent->GetEventHandlerForPoint(gfx::Point(1, 1)));
 
   // We can override the hit test bounds of the parent to make the parent grab
   // events along that edge.
   parent->set_hit_test_bounds_override_inner(gfx::Insets(1, 1, 1, 1));
   EXPECT_EQ(parent.get(), parent->GetEventHandlerForPoint(gfx::Point(0, 0)));
   EXPECT_EQ(child.get(),  parent->GetEventHandlerForPoint(gfx::Point(1, 1)));
 }
 
-TEST_F(WindowTest, GetEventHandlerForPointWithOverrideDescendingOrder) {
+TEST_P(WindowTest, GetEventHandlerForPointWithOverrideDescendingOrder) {
   std::unique_ptr<SelfEventHandlingWindowDelegate> parent_delegate(
       new SelfEventHandlingWindowDelegate);
   std::unique_ptr<Window> parent(CreateTestWindowWithDelegate(
       parent_delegate.get(), 1, gfx::Rect(10, 20, 400, 500), root_window()));
   std::unique_ptr<Window> child(CreateTestWindow(
       SK_ColorRED, 2, gfx::Rect(0, 0, 390, 480), parent.get()));
 
   // We can override ShouldDescendIntoChildForEventHandling to make the parent
   // grab all events.
   EXPECT_EQ(parent.get(), parent->GetEventHandlerForPoint(gfx::Point(0, 0)));
   EXPECT_EQ(parent.get(), parent->GetEventHandlerForPoint(gfx::Point(50, 50)));
 }
 
-TEST_F(WindowTest, GetTopWindowContainingPoint) {
+TEST_P(WindowTest, GetTopWindowContainingPoint) {
   Window* root = root_window();
   root->SetBounds(gfx::Rect(0, 0, 300, 300));
 
   std::unique_ptr<Window> w1(CreateTestWindow(
       SK_ColorWHITE, 1, gfx::Rect(10, 10, 100, 100), root_window()));
   std::unique_ptr<Window> w11(
       CreateTestWindow(SK_ColorGREEN, 11, gfx::Rect(0, 0, 120, 120), w1.get()));
 
   std::unique_ptr<Window> w2(
       CreateTestWindow(SK_ColorRED, 2, gfx::Rect(5, 5, 55, 55), root_window()));
@@ skipping 10 matching lines @@
   EXPECT_EQ(w2.get(), root->GetTopWindowContainingPoint(gfx::Point(10, 10)));
   EXPECT_EQ(w2.get(), root->GetTopWindowContainingPoint(gfx::Point(59, 59)));
   EXPECT_EQ(w1.get(), root->GetTopWindowContainingPoint(gfx::Point(60, 60)));
   EXPECT_EQ(w1.get(), root->GetTopWindowContainingPoint(gfx::Point(109, 109)));
   EXPECT_EQ(NULL, root->GetTopWindowContainingPoint(gfx::Point(110, 110)));
   EXPECT_EQ(w31.get(), root->GetTopWindowContainingPoint(gfx::Point(200, 200)));
   EXPECT_EQ(w31.get(), root->GetTopWindowContainingPoint(gfx::Point(220, 220)));
   EXPECT_EQ(NULL, root->GetTopWindowContainingPoint(gfx::Point(260, 260)));
 }
 
-TEST_F(WindowTest, GetToplevelWindow) {
+TEST_P(WindowTest, GetToplevelWindow) {
   const gfx::Rect kBounds(0, 0, 10, 10);
   TestWindowDelegate delegate;
 
   std::unique_ptr<Window> w1(CreateTestWindowWithId(1, root_window()));
   std::unique_ptr<Window> w11(
       CreateTestWindowWithDelegate(&delegate, 11, kBounds, w1.get()));
   std::unique_ptr<Window> w111(CreateTestWindowWithId(111, w11.get()));
   std::unique_ptr<Window> w1111(
       CreateTestWindowWithDelegate(&delegate, 1111, kBounds, w111.get()));
 
@@ skipping 11 matching lines @@
   void OnWindowAddedToRootWindow(Window* window) override { called_ = true; }
 
   bool called() const { return called_; }
 
  private:
   bool called_;
 
   DISALLOW_COPY_AND_ASSIGN(AddedToRootWindowObserver);
 };
 
-TEST_F(WindowTest, WindowAddedToRootWindowShouldNotifyChildAndNotParent) {
+TEST_P(WindowTest, WindowAddedToRootWindowShouldNotifyChildAndNotParent) {
   AddedToRootWindowObserver parent_observer;
   AddedToRootWindowObserver child_observer;
   std::unique_ptr<Window> parent_window(
       CreateTestWindowWithId(1, root_window()));
   std::unique_ptr<Window> child_window(new Window(NULL));
   child_window->Init(ui::LAYER_TEXTURED);
   child_window->Show();
 
   parent_window->AddObserver(&parent_observer);
   child_window->AddObserver(&child_observer);
 
   parent_window->AddChild(child_window.get());
 
   EXPECT_FALSE(parent_observer.called());
   EXPECT_TRUE(child_observer.called());
 
   parent_window->RemoveObserver(&parent_observer);
   child_window->RemoveObserver(&child_observer);
 }
 
 // Various destruction assertions.
-TEST_F(WindowTest, DestroyTest) {
+TEST_P(WindowTest, DestroyTest) {
   DestroyTrackingDelegateImpl parent_delegate;
   ChildWindowDelegateImpl child_delegate(&parent_delegate);
   {
     std::unique_ptr<Window> parent(CreateTestWindowWithDelegate(
         &parent_delegate, 0, gfx::Rect(), root_window()));
     CreateTestWindowWithDelegate(&child_delegate, 0, gfx::Rect(), parent.get());
   }
   // Both the parent and child should have been destroyed.
   EXPECT_EQ(1, parent_delegate.destroying_count());
   EXPECT_EQ(1, parent_delegate.destroyed_count());
   EXPECT_EQ(1, child_delegate.destroying_count());
   EXPECT_EQ(1, child_delegate.destroyed_count());
 }
 
 // Tests that a window is orphaned before OnWindowDestroyed is called.
-TEST_F(WindowTest, OrphanedBeforeOnDestroyed) {
+TEST_P(WindowTest, OrphanedBeforeOnDestroyed) {
   TestWindowDelegate parent_delegate;
   DestroyOrphanDelegate child_delegate;
   {
     std::unique_ptr<Window> parent(CreateTestWindowWithDelegate(
         &parent_delegate, 0, gfx::Rect(), root_window()));
     std::unique_ptr<Window> child(CreateTestWindowWithDelegate(
         &child_delegate, 0, gfx::Rect(), parent.get()));
     child_delegate.set_window(child.get());
   }
 }
 
 // Make sure StackChildAtTop moves both the window and layer to the front.
-TEST_F(WindowTest, StackChildAtTop) {
+TEST_P(WindowTest, StackChildAtTop) {
   Window parent(NULL);
   parent.Init(ui::LAYER_NOT_DRAWN);
   Window child1(NULL);
   child1.Init(ui::LAYER_NOT_DRAWN);
   Window child2(NULL);
   child2.Init(ui::LAYER_NOT_DRAWN);
 
   parent.AddChild(&child1);
   parent.AddChild(&child2);
   ASSERT_EQ(2u, parent.children().size());
   EXPECT_EQ(&child1, parent.children()[0]);
   EXPECT_EQ(&child2, parent.children()[1]);
   ASSERT_EQ(2u, parent.layer()->children().size());
   EXPECT_EQ(child1.layer(), parent.layer()->children()[0]);
   EXPECT_EQ(child2.layer(), parent.layer()->children()[1]);
 
   parent.StackChildAtTop(&child1);
   ASSERT_EQ(2u, parent.children().size());
   EXPECT_EQ(&child1, parent.children()[1]);
   EXPECT_EQ(&child2, parent.children()[0]);
   ASSERT_EQ(2u, parent.layer()->children().size());
   EXPECT_EQ(child1.layer(), parent.layer()->children()[1]);
   EXPECT_EQ(child2.layer(), parent.layer()->children()[0]);
 }
 
 // Make sure StackChildBelow works.
-TEST_F(WindowTest, StackChildBelow) {
+TEST_P(WindowTest, StackChildBelow) {
   Window parent(NULL);
   parent.Init(ui::LAYER_NOT_DRAWN);
   Window child1(NULL);
   child1.Init(ui::LAYER_NOT_DRAWN);
   child1.set_id(1);
   Window child2(NULL);
   child2.Init(ui::LAYER_NOT_DRAWN);
   child2.set_id(2);
   Window child3(NULL);
   child3.Init(ui::LAYER_NOT_DRAWN);
@@ skipping 11 matching lines @@
   EXPECT_EQ("2 1 3", ChildWindowIDsAsString(&parent));
 
   parent.StackChildBelow(&child3, &child2);
   EXPECT_EQ("3 2 1", ChildWindowIDsAsString(&parent));
 
   parent.StackChildBelow(&child3, &child1);
   EXPECT_EQ("2 3 1", ChildWindowIDsAsString(&parent));
 }
 
 // Various assertions for StackChildAbove.
-TEST_F(WindowTest, StackChildAbove) {
+TEST_P(WindowTest, StackChildAbove) {
   Window parent(NULL);
   parent.Init(ui::LAYER_NOT_DRAWN);
   Window child1(NULL);
   child1.Init(ui::LAYER_NOT_DRAWN);
   Window child2(NULL);
   child2.Init(ui::LAYER_NOT_DRAWN);
   Window child3(NULL);
   child3.Init(ui::LAYER_NOT_DRAWN);
 
   parent.AddChild(&child1);
@@ skipping 38 matching lines @@
   EXPECT_EQ(&child2, parent.children()[0]);
   EXPECT_EQ(&child1, parent.children()[1]);
   EXPECT_EQ(&child3, parent.children()[2]);
   ASSERT_EQ(3u, parent.layer()->children().size());
   EXPECT_EQ(child2.layer(), parent.layer()->children()[0]);
   EXPECT_EQ(child1.layer(), parent.layer()->children()[1]);
   EXPECT_EQ(child3.layer(), parent.layer()->children()[2]);
 }
 
 // Various capture assertions.
-TEST_F(WindowTest, CaptureTests) {
+TEST_P(WindowTest, CaptureTests) {
   CaptureWindowDelegateImpl delegate;
   std::unique_ptr<Window> window(CreateTestWindowWithDelegate(
       &delegate, 0, gfx::Rect(0, 0, 20, 20), root_window()));
   EXPECT_FALSE(window->HasCapture());
 
   delegate.ResetCounts();
 
   // Do a capture.
   window->SetCapture();
   EXPECT_TRUE(window->HasCapture());
@@ skipping 30 matching lines @@
 
   // Removing the capture window from parent should reset the capture window
   // in the root window.
   window->SetCapture();
   EXPECT_EQ(window.get(), aura::client::GetCaptureWindow(root_window()));
   window->parent()->RemoveChild(window.get());
   EXPECT_FALSE(window->HasCapture());
   EXPECT_EQ(NULL, aura::client::GetCaptureWindow(root_window()));
 }
 
-TEST_F(WindowTest, TouchCaptureCancelsOtherTouches) {
+TEST_P(WindowTest, TouchCaptureCancelsOtherTouches) {
   CaptureWindowDelegateImpl delegate1;
   std::unique_ptr<Window> w1(CreateTestWindowWithDelegate(
       &delegate1, 0, gfx::Rect(0, 0, 50, 50), root_window()));
   CaptureWindowDelegateImpl delegate2;
   std::unique_ptr<Window> w2(CreateTestWindowWithDelegate(
       &delegate2, 0, gfx::Rect(50, 50, 50, 50), root_window()));
 
   // Press on w1.
   ui::TouchEvent press1(
       ui::ET_TOUCH_PRESSED, gfx::Point(10, 10), 0, getTime());
@@ skipping 34 matching lines @@
   delegate2.ResetCounts();
 
   // And releasing capture changes nothing.
   w2->ReleaseCapture();
   EXPECT_EQ(0, delegate1.gesture_event_count());
   EXPECT_EQ(0, delegate1.touch_event_count());
   EXPECT_EQ(0, delegate2.gesture_event_count());
   EXPECT_EQ(0, delegate2.touch_event_count());
 }
 
-TEST_F(WindowTest, TouchCaptureDoesntCancelCapturedTouches) {
+TEST_P(WindowTest, TouchCaptureDoesntCancelCapturedTouches) {
   CaptureWindowDelegateImpl delegate;
   std::unique_ptr<Window> window(CreateTestWindowWithDelegate(
       &delegate, 0, gfx::Rect(0, 0, 50, 50), root_window()));
   base::TimeTicks time = getTime();
   const int kTimeDelta = 100;
 
   ui::TouchEvent press(
       ui::ET_TOUCH_PRESSED, gfx::Point(10, 10), 0, time);
   DispatchEventUsingWindowDispatcher(&press);
 
@@ skipping 34 matching lines @@
   time += base::TimeDelta::FromMilliseconds(kTimeDelta);
   ui::TouchEvent release(
       ui::ET_TOUCH_RELEASED, gfx::Point(10, 20), 0, time);
   DispatchEventUsingWindowDispatcher(&release);
   EXPECT_EQ(1, delegate.touch_event_count());
   EXPECT_EQ(2, delegate.gesture_event_count());
 }
 
 
 // Assertions around SetCapture() and touch/gestures.
-TEST_F(WindowTest, TransferCaptureTouchEvents) {
+TEST_P(WindowTest, TransferCaptureTouchEvents) {
   // Touch on |w1|.
   CaptureWindowDelegateImpl d1;
   std::unique_ptr<Window> w1(CreateTestWindowWithDelegate(
       &d1, 0, gfx::Rect(0, 0, 20, 20), root_window()));
   ui::TouchEvent p1(ui::ET_TOUCH_PRESSED, gfx::Point(10, 10), 0, getTime());
   DispatchEventUsingWindowDispatcher(&p1);
   // We will get both GESTURE_BEGIN and GESTURE_TAP_DOWN.
   EXPECT_EQ(1, d1.touch_event_count());
   EXPECT_EQ(2, d1.gesture_event_count());
   d1.ResetCounts();
@@ skipping 60 matching lines @@
   DispatchEventUsingWindowDispatcher(&m4);
   EXPECT_EQ(0, d1.touch_event_count());
   EXPECT_EQ(0, d1.gesture_event_count());
   EXPECT_EQ(0, d2.touch_event_count());
   EXPECT_EQ(0, d2.gesture_event_count());
   EXPECT_EQ(0, d3.touch_event_count());
   EXPECT_EQ(0, d3.gesture_event_count());
 }
 
 // Changes capture while capture is already ongoing.
-TEST_F(WindowTest, ChangeCaptureWhileMouseDown) {
+TEST_P(WindowTest, ChangeCaptureWhileMouseDown) {
   CaptureWindowDelegateImpl delegate;
   std::unique_ptr<Window> window(CreateTestWindowWithDelegate(
       &delegate, 0, gfx::Rect(0, 0, 20, 20), root_window()));
   CaptureWindowDelegateImpl delegate2;
   std::unique_ptr<Window> w2(CreateTestWindowWithDelegate(
       &delegate2, 0, gfx::Rect(20, 20, 20, 20), root_window()));
 
   // Execute the scheduled draws so that mouse events are not
   // aggregated.
   RunAllPendingInMessageLoop();
@@ skipping 18 matching lines @@
   w2->SetCapture();
 
   generator.MoveMouseTo(gfx::Point(40, 40), 2);
   EXPECT_EQ(1, delegate.capture_lost_count());
   EXPECT_EQ(1, delegate.capture_changed_event_count());
   EXPECT_EQ(1, delegate.mouse_event_count());
   EXPECT_EQ(2, delegate2.mouse_event_count());
 }
 
 // Verifies capture is reset when a window is destroyed.
-TEST_F(WindowTest, ReleaseCaptureOnDestroy) {
+TEST_P(WindowTest, ReleaseCaptureOnDestroy) {
   CaptureWindowDelegateImpl delegate;
   std::unique_ptr<Window> window(CreateTestWindowWithDelegate(
       &delegate, 0, gfx::Rect(0, 0, 20, 20), root_window()));
   EXPECT_FALSE(window->HasCapture());
 
   // Do a capture.
   window->SetCapture();
   EXPECT_TRUE(window->HasCapture());
 
   // Destroy the window.
   window.reset();
 
   // Make sure the root window doesn't reference the window anymore.
   EXPECT_EQ(NULL, host()->dispatcher()->mouse_pressed_handler());
   EXPECT_EQ(NULL, aura::client::GetCaptureWindow(root_window()));
 }
 
-TEST_F(WindowTest, GetBoundsInRootWindow) {
+TEST_P(WindowTest, GetBoundsInRootWindow) {
   std::unique_ptr<Window> viewport(
       CreateTestWindowWithBounds(gfx::Rect(0, 0, 300, 300), root_window()));
   std::unique_ptr<Window> child(
       CreateTestWindowWithBounds(gfx::Rect(0, 0, 100, 100), viewport.get()));
   // Sanity check.
   EXPECT_EQ("0,0 100x100", child->GetBoundsInRootWindow().ToString());
 
   // The |child| window's screen bounds should move along with the |viewport|.
   viewport->SetBounds(gfx::Rect(-100, -100, 300, 300));
   EXPECT_EQ("-100,-100 100x100", child->GetBoundsInRootWindow().ToString());
 
   // The |child| window is moved to the 0,0 in screen coordinates.
   // |GetBoundsInRootWindow()| should return 0,0.
   child->SetBounds(gfx::Rect(100, 100, 100, 100));
   EXPECT_EQ("0,0 100x100", child->GetBoundsInRootWindow().ToString());
 }
 
-TEST_F(WindowTest, GetBoundsInRootWindowWithLayers) {
+TEST_P(WindowTest, GetBoundsInRootWindowWithLayers) {
   std::unique_ptr<Window> viewport(
       CreateTestWindowWithBounds(gfx::Rect(0, 0, 300, 300), root_window()));
 
   std::unique_ptr<Window> widget(
       CreateTestWindowWithBounds(gfx::Rect(0, 0, 200, 200), viewport.get()));
 
   std::unique_ptr<Window> child(
       CreateTestWindowWithBounds(gfx::Rect(0, 0, 100, 100), widget.get()));
 
   // Sanity check.
   EXPECT_EQ("0,0 100x100", child->GetBoundsInRootWindow().ToString());
 
   // The |child| window's screen bounds should move along with the |viewport|.
   OffsetBounds(viewport.get(), -100, -100);
   EXPECT_EQ("-100,-100 100x100", child->GetBoundsInRootWindow().ToString());
 
   OffsetBounds(widget.get(), 50, 50);
   EXPECT_EQ("-50,-50 100x100", child->GetBoundsInRootWindow().ToString());
 
   // The |child| window is moved to the 0,0 in screen coordinates.
   // |GetBoundsInRootWindow()| should return 0,0.
   OffsetBounds(child.get(), 50, 50);
   EXPECT_EQ("0,0 100x100", child->GetBoundsInRootWindow().ToString());
 }
 
-TEST_F(WindowTest, GetBoundsInRootWindowWithLayersAndTranslations) {
+TEST_P(WindowTest, GetBoundsInRootWindowWithLayersAndTranslations) {
   std::unique_ptr<Window> viewport(
       CreateTestWindowWithBounds(gfx::Rect(0, 0, 300, 300), root_window()));
 
   std::unique_ptr<Window> widget(
       CreateTestWindowWithBounds(gfx::Rect(0, 0, 200, 200), viewport.get()));
 
   std::unique_ptr<Window> child(
       CreateTestWindowWithBounds(gfx::Rect(0, 0, 100, 100), widget.get()));
 
   // Sanity check.
@@ skipping 60 matching lines @@
 
  private:
   bool entered_;
   bool exited_;
 
   DISALLOW_COPY_AND_ASSIGN(MouseEnterExitWindowDelegate);
 };
 
 // Verifies that the WindowDelegate receives MouseExit and MouseEnter events for
 // mouse transitions from window to window.
-TEST_F(WindowTest, MouseEnterExit) {
+TEST_P(WindowTest, MouseEnterExit) {
   MouseEnterExitWindowDelegate d1;
   std::unique_ptr<Window> w1(CreateTestWindowWithDelegate(
       &d1, 1, gfx::Rect(10, 10, 50, 50), root_window()));
   MouseEnterExitWindowDelegate d2;
   std::unique_ptr<Window> w2(CreateTestWindowWithDelegate(
       &d2, 2, gfx::Rect(70, 70, 50, 50), root_window()));
 
   ui::test::EventGenerator generator(root_window());
   generator.MoveMouseToCenterOf(w1.get());
   EXPECT_TRUE(d1.entered());
   EXPECT_FALSE(d1.exited());
   EXPECT_FALSE(d2.entered());
   EXPECT_FALSE(d2.exited());
 
   generator.MoveMouseToCenterOf(w2.get());
   EXPECT_TRUE(d1.entered());
   EXPECT_TRUE(d1.exited());
   EXPECT_TRUE(d2.entered());
   EXPECT_FALSE(d2.exited());
 }
 
 // Verifies that the WindowDelegate receives MouseExit from ET_MOUSE_EXITED.
-TEST_F(WindowTest, WindowTreeHostExit) {
+TEST_P(WindowTest, WindowTreeHostExit) {
   MouseEnterExitWindowDelegate d1;
   std::unique_ptr<Window> w1(CreateTestWindowWithDelegate(
       &d1, 1, gfx::Rect(10, 10, 50, 50), root_window()));
 
   ui::test::EventGenerator generator(root_window());
   generator.MoveMouseToCenterOf(w1.get());
   EXPECT_TRUE(d1.entered());
   EXPECT_FALSE(d1.exited());
   d1.ResetExpectations();
 
   ui::MouseEvent exit_event(ui::ET_MOUSE_EXITED, gfx::Point(), gfx::Point(),
                             ui::EventTimeForNow(), 0, 0);
   DispatchEventUsingWindowDispatcher(&exit_event);
   EXPECT_FALSE(d1.entered());
   EXPECT_TRUE(d1.exited());
 }
 
 // Verifies that the WindowDelegate receives MouseExit and MouseEnter events for
 // mouse transitions from window to window, even if the entered window sets
 // and releases capture.
-TEST_F(WindowTest, MouseEnterExitWithClick) {
+TEST_P(WindowTest, MouseEnterExitWithClick) {
   MouseEnterExitWindowDelegate d1;
   std::unique_ptr<Window> w1(CreateTestWindowWithDelegate(
       &d1, 1, gfx::Rect(10, 10, 50, 50), root_window()));
   MouseEnterExitWindowDelegate d2;
   std::unique_ptr<Window> w2(CreateTestWindowWithDelegate(
       &d2, 2, gfx::Rect(70, 70, 50, 50), root_window()));
 
   ui::test::EventGenerator generator(root_window());
   generator.MoveMouseToCenterOf(w1.get());
   EXPECT_TRUE(d1.entered());
   EXPECT_FALSE(d1.exited());
   EXPECT_FALSE(d2.entered());
   EXPECT_FALSE(d2.exited());
 
   // Emmulate what Views does on a click by grabbing and releasing capture.
   generator.PressLeftButton();
   w1->SetCapture();
   w1->ReleaseCapture();
   generator.ReleaseLeftButton();
 
   generator.MoveMouseToCenterOf(w2.get());
   EXPECT_TRUE(d1.entered());
   EXPECT_TRUE(d1.exited());
   EXPECT_TRUE(d2.entered());
   EXPECT_FALSE(d2.exited());
 }
 
-TEST_F(WindowTest, MouseEnterExitWhenDeleteWithCapture) {
+TEST_P(WindowTest, MouseEnterExitWhenDeleteWithCapture) {
   MouseEnterExitWindowDelegate delegate;
   std::unique_ptr<Window> window(CreateTestWindowWithDelegate(
       &delegate, 1, gfx::Rect(10, 10, 50, 50), root_window()));
 
   ui::test::EventGenerator generator(root_window());
   generator.MoveMouseToCenterOf(window.get());
   EXPECT_TRUE(delegate.entered());
   EXPECT_FALSE(delegate.exited());
 
   // Emmulate what Views does on a click by grabbing and releasing capture.
   generator.PressLeftButton();
   window->SetCapture();
 
   delegate.ResetExpectations();
   generator.MoveMouseTo(0, 0);
   EXPECT_FALSE(delegate.entered());
   EXPECT_FALSE(delegate.exited());
 
   delegate.ResetExpectations();
   window.reset();
   EXPECT_FALSE(delegate.entered());
   EXPECT_FALSE(delegate.exited());
 }
 
 // Verifies that the correct enter / exits are sent if windows appear and are
 // deleted under the current mouse position.
-TEST_F(WindowTest, MouseEnterExitWithWindowAppearAndDelete) {
+TEST_P(WindowTest, MouseEnterExitWithWindowAppearAndDelete) {
   MouseEnterExitWindowDelegate d1;
   std::unique_ptr<Window> w1(CreateTestWindowWithDelegate(
       &d1, 1, gfx::Rect(10, 10, 50, 50), root_window()));
 
   // The cursor is moved into the bounds of |w1|. We expect the delegate
   // of |w1| to see an ET_MOUSE_ENTERED event.
   ui::test::EventGenerator generator(root_window());
   generator.MoveMouseToCenterOf(w1.get());
   EXPECT_TRUE(d1.entered());
   EXPECT_FALSE(d1.exited());
@@ skipping 22 matching lines @@
   // |w2| has been destroyed, so its delegate should see no further events.
   // The delegate of |w1| should see an ET_MOUSE_ENTERED event.
   EXPECT_TRUE(d1.entered());
   EXPECT_FALSE(d1.exited());
   EXPECT_FALSE(d2.entered());
   EXPECT_FALSE(d2.exited());
 }
 
 // Verifies that enter / exits are sent if windows appear and are hidden
 // under the current mouse position..
-TEST_F(WindowTest, MouseEnterExitWithHide) {
+TEST_P(WindowTest, MouseEnterExitWithHide) {
   MouseEnterExitWindowDelegate d1;
   std::unique_ptr<Window> w1(CreateTestWindowWithDelegate(
       &d1, 1, gfx::Rect(10, 10, 50, 50), root_window()));
 
   ui::test::EventGenerator generator(root_window());
   generator.MoveMouseToCenterOf(w1.get());
   EXPECT_TRUE(d1.entered());
   EXPECT_FALSE(d1.exited());
 
   MouseEnterExitWindowDelegate d2;
   std::unique_ptr<Window> w2(CreateTestWindowWithDelegate(
       &d2, 2, gfx::Rect(10, 10, 50, 50), root_window()));
   // Enters / exits can be send asynchronously.
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(d1.entered());
   EXPECT_TRUE(d1.exited());
   EXPECT_TRUE(d2.entered());
   EXPECT_FALSE(d2.exited());
 
   d1.ResetExpectations();
   w2->Hide();
   // Enters / exits can be send asynchronously.
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(d2.exited());
   EXPECT_TRUE(d1.entered());
 }
 
-TEST_F(WindowTest, MouseEnterExitWithParentHide) {
+TEST_P(WindowTest, MouseEnterExitWithParentHide) {
   MouseEnterExitWindowDelegate d1;
   std::unique_ptr<Window> w1(CreateTestWindowWithDelegate(
       &d1, 1, gfx::Rect(10, 10, 50, 50), root_window()));
   MouseEnterExitWindowDelegate d2;
   Window* w2 = CreateTestWindowWithDelegate(&d2, 2, gfx::Rect(10, 10, 50, 50),
                                             w1.get());
   ui::test::EventGenerator generator(root_window());
   generator.MoveMouseToCenterOf(w2);
   // Enters / exits can be send asynchronously.
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(d2.entered());
   EXPECT_FALSE(d2.exited());
 
   d2.ResetExpectations();
   w1->Hide();
   RunAllPendingInMessageLoop();
   EXPECT_FALSE(d2.entered());
   EXPECT_TRUE(d2.exited());
 
   w1.reset();
 }
 
-TEST_F(WindowTest, MouseEnterExitWithParentDelete) {
+TEST_P(WindowTest, MouseEnterExitWithParentDelete) {
   MouseEnterExitWindowDelegate d1;
   std::unique_ptr<Window> w1(CreateTestWindowWithDelegate(
       &d1, 1, gfx::Rect(10, 10, 50, 50), root_window()));
   MouseEnterExitWindowDelegate d2;
   Window* w2 = CreateTestWindowWithDelegate(&d2, 2, gfx::Rect(10, 10, 50, 50),
                                             w1.get());
   ui::test::EventGenerator generator(root_window());
   generator.MoveMouseToCenterOf(w2);
 
   // Enters / exits can be send asynchronously.
@@ skipping 12 matching lines @@
   EXPECT_FALSE(d2.entered());
   EXPECT_FALSE(d2.exited());
 }
 
 // Creates a window with a delegate (w111) that can handle events at a lower
 // z-index than a window without a delegate (w12). w12 is sized to fill the
 // entire bounds of the container. This test verifies that
 // GetEventHandlerForPoint() skips w12 even though its bounds contain the event,
 // because it has no children that can handle the event and it has no delegate
 // allowing it to handle the event itself.
-TEST_F(WindowTest, GetEventHandlerForPoint_NoDelegate) {
+TEST_P(WindowTest, GetEventHandlerForPoint_NoDelegate) {
   TestWindowDelegate d111;
   std::unique_ptr<Window> w1(CreateTestWindowWithDelegate(
       NULL, 1, gfx::Rect(0, 0, 500, 500), root_window()));
   std::unique_ptr<Window> w11(CreateTestWindowWithDelegate(
       NULL, 11, gfx::Rect(0, 0, 500, 500), w1.get()));
   std::unique_ptr<Window> w111(CreateTestWindowWithDelegate(
       &d111, 111, gfx::Rect(50, 50, 450, 450), w11.get()));
   std::unique_ptr<Window> w12(CreateTestWindowWithDelegate(
       NULL, 12, gfx::Rect(0, 0, 500, 500), w1.get()));
 
@@ skipping 23 matching lines @@
   }
 
  private:
   int shown_;
   int hidden_;
 
   DISALLOW_COPY_AND_ASSIGN(VisibilityWindowDelegate);
 };
 
 // Verifies show/hide propagate correctly to children and the layer.
-TEST_F(WindowTest, Visibility) {
+TEST_P(WindowTest, Visibility) {
   VisibilityWindowDelegate d;
   VisibilityWindowDelegate d2;
   std::unique_ptr<Window> w1(
       CreateTestWindowWithDelegate(&d, 1, gfx::Rect(), root_window()));
   std::unique_ptr<Window> w2(
       CreateTestWindowWithDelegate(&d2, 2, gfx::Rect(), w1.get()));
   std::unique_ptr<Window> w3(CreateTestWindowWithId(3, w2.get()));
 
   // Create shows all the windows.
   EXPECT_TRUE(w1->IsVisible());
@@ skipping 38 matching lines @@
   d2.Clear();
   w2->Hide();
   EXPECT_EQ(1, d2.hidden());
   EXPECT_EQ(0, d2.shown());
   d2.Clear();
   w2->Show();
   EXPECT_EQ(0, d2.hidden());
   EXPECT_EQ(1, d2.shown());
 }
 
-TEST_F(WindowTest, IgnoreEventsTest) {
+TEST_P(WindowTest, IgnoreEventsTest) {
   TestWindowDelegate d11;
   TestWindowDelegate d12;
   TestWindowDelegate d111;
   TestWindowDelegate d121;
   std::unique_ptr<Window> w1(CreateTestWindowWithDelegate(
       NULL, 1, gfx::Rect(0, 0, 500, 500), root_window()));
   std::unique_ptr<Window> w11(CreateTestWindowWithDelegate(
       &d11, 11, gfx::Rect(0, 0, 500, 500), w1.get()));
   std::unique_ptr<Window> w111(CreateTestWindowWithDelegate(
       &d111, 111, gfx::Rect(50, 50, 450, 450), w11.get()));
@@ skipping 10 matching lines @@
   EXPECT_EQ(w121.get(), w1->GetEventHandlerForPoint(gfx::Point(160, 160)));
   w121->set_ignore_events(true);
   EXPECT_EQ(w12.get(), w1->GetEventHandlerForPoint(gfx::Point(160, 160)));
   w12->set_ignore_events(true);
   EXPECT_EQ(w111.get(), w1->GetEventHandlerForPoint(gfx::Point(160, 160)));
   w111->set_ignore_events(true);
   EXPECT_EQ(w11.get(), w1->GetEventHandlerForPoint(gfx::Point(160, 160)));
 }
 
 // Tests transformation on the root window.
-TEST_F(WindowTest, Transform) {
+TEST_P(WindowTest, Transform) {
   gfx::Size size = host()->GetBounds().size();
   EXPECT_EQ(gfx::Rect(size), display::Screen::GetScreen()
                                  ->GetDisplayNearestPoint(gfx::Point())
                                  .bounds());
 
   // Rotate it clock-wise 90 degrees.
   gfx::Transform transform;
   transform.Translate(size.height(), 0);
   transform.Rotate(90.0);
   host()->SetRootTransform(transform);
 
   // The size should be the transformed size.
   gfx::Size transformed_size(size.height(), size.width());
   EXPECT_EQ(transformed_size.ToString(),
             root_window()->bounds().size().ToString());
   EXPECT_EQ(gfx::Rect(transformed_size).ToString(),
             display::Screen::GetScreen()
                 ->GetDisplayNearestPoint(gfx::Point())
                 .bounds()
                 .ToString());
 
   // Host size shouldn't change.
   EXPECT_EQ(size.ToString(), host()->GetBounds().size().ToString());
 }
 
-TEST_F(WindowTest, TransformGesture) {
+TEST_P(WindowTest, TransformGesture) {
   gfx::Size size = host()->GetBounds().size();
 
   std::unique_ptr<GestureTrackPositionDelegate> delegate(
       new GestureTrackPositionDelegate);
   std::unique_ptr<Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, gfx::Rect(0, 0, 20, 20), root_window()));
 
   // Rotate the root-window clock-wise 90 degrees.
   gfx::Transform transform;
   transform.Translate(size.height(), 0.0);
   transform.Rotate(90.0);
   host()->SetRootTransform(transform);
 
   ui::TouchEvent press(
       ui::ET_TOUCH_PRESSED, gfx::Point(size.height() - 10, 10), 0, getTime());
   DispatchEventUsingWindowDispatcher(&press);
   EXPECT_EQ(gfx::Point(10, 10).ToString(), delegate->position().ToString());
 }
 
 namespace {
 DEFINE_WINDOW_PROPERTY_KEY(int, kIntKey, -2);
 DEFINE_WINDOW_PROPERTY_KEY(const char*, kStringKey, "squeamish");
 }
 
-TEST_F(WindowTest, Property) {
+TEST_P(WindowTest, Property) {
   std::unique_ptr<Window> w(CreateTestWindowWithId(0, root_window()));
 
   static const char native_prop_key[] = "fnord";
 
   // Non-existent properties should return the default values.
   EXPECT_EQ(-2, w->GetProperty(kIntKey));
   EXPECT_EQ(std::string("squeamish"), w->GetProperty(kStringKey));
   EXPECT_EQ(NULL, w->GetNativeWindowProperty(native_prop_key));
 
   // A set property value should be returned again (even if it's the default
@@ skipping 17 matching lines @@
   w->SetNativeWindowProperty(native_prop_key, NULL);
   EXPECT_EQ(NULL, w->GetNativeWindowProperty(native_prop_key));
 
   // ClearProperty should restore the default value.
   w->ClearProperty(kIntKey);
   EXPECT_EQ(-2, w->GetProperty(kIntKey));
   w->ClearProperty(kStringKey);
   EXPECT_EQ(std::string("squeamish"), w->GetProperty(kStringKey));
 }
 
-TEST_F(WindowTest, OwnedProperty) {
+TEST_P(WindowTest, OwnedProperty) {
   std::unique_ptr<Window> w(CreateTestWindowWithId(0, root_window()));
   EXPECT_EQ(NULL, w->GetProperty(kOwnedKey));
   TestProperty* last_deleted = TestProperty::last_deleted();
   TestProperty* p1 = new TestProperty();
   w->SetProperty(kOwnedKey, p1);
   EXPECT_EQ(p1, w->GetProperty(kOwnedKey));
   EXPECT_EQ(last_deleted, TestProperty::last_deleted());
 
   TestProperty* p2 = new TestProperty();
   w->SetProperty(kOwnedKey, p2);
@@ skipping 30 matching lines @@
   void SetChildBounds(Window* child,
                       const gfx::Rect& requested_bounds) override {}
 
   DeletionTracker* tracker_;
 
   DISALLOW_COPY_AND_ASSIGN(DeletionTestLayoutManager);
 };
 
 }  // namespace
 
-TEST_F(WindowTest, DeleteLayoutManagerBeforeOwnedProps) {
+TEST_P(WindowTest, DeleteLayoutManagerBeforeOwnedProps) {
   DeletionTracker tracker;
   {
     Window w(nullptr);
     w.Init(ui::LAYER_NOT_DRAWN);
     w.SetLayoutManager(new DeletionTestLayoutManager(&tracker));
     w.SetProperty(kDeletionTestPropertyKey, new DeletionTestProperty(&tracker));
   }
   EXPECT_TRUE(tracker.property_deleted());
   EXPECT_TRUE(tracker.layout_manager_deleted());
   EXPECT_EQ(DeletionOrder::LAYOUT_MANAGER_FIRST, tracker.order());
 }
 
-TEST_F(WindowTest, SetBoundsInternalShouldCheckTargetBounds) {
+TEST_P(WindowTest, SetBoundsInternalShouldCheckTargetBounds) {
   // We cannot short-circuit animations in this test.
   ui::ScopedAnimationDurationScaleMode test_duration_mode(
       ui::ScopedAnimationDurationScaleMode::NON_ZERO_DURATION);
 
   std::unique_ptr<Window> w1(
       CreateTestWindowWithBounds(gfx::Rect(0, 0, 100, 100), root_window()));
 
   EXPECT_TRUE(w1->layer());
   w1->layer()->GetAnimator()->set_disable_timer_for_test(true);
   ui::LayerAnimator* animator = w1->layer()->GetAnimator();
@@ skipping 132 matching lines @@
   int destroyed_count_;
   std::unique_ptr<VisibilityInfo> visibility_info_;
   const void* property_key_;
   intptr_t old_property_value_;
   std::vector<std::pair<int, int> > transform_notifications_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowObserverTest);
 };
 
 // Various assertions for WindowObserver.
-TEST_F(WindowObserverTest, WindowObserver) {
+TEST_P(WindowObserverTest, WindowObserver) {
   std::unique_ptr<Window> w1(CreateTestWindowWithId(1, root_window()));
   w1->AddObserver(this);
 
   // Create a new window as a child of w1, our observer should be notified.
   std::unique_ptr<Window> w2(CreateTestWindowWithId(2, w1.get()));
   EXPECT_EQ("added=1 removed=0", WindowObserverCountStateAndClear());
 
   // Delete w2, which should result in the remove notification.
   w2.reset();
   EXPECT_EQ("added=0 removed=1", WindowObserverCountStateAndClear());
 
   // Create a window that isn't parented to w1, we shouldn't get any
   // notification.
   std::unique_ptr<Window> w3(CreateTestWindowWithId(3, root_window()));
   EXPECT_EQ("added=0 removed=0", WindowObserverCountStateAndClear());
 
   // Similarly destroying w3 shouldn't notify us either.
   w3.reset();
   EXPECT_EQ("added=0 removed=0", WindowObserverCountStateAndClear());
   w1->RemoveObserver(this);
 }
 
 // Test if OnWindowVisibilityChanged is invoked with expected
 // parameters.
-TEST_F(WindowObserverTest, WindowVisibility) {
+TEST_P(WindowObserverTest, WindowVisibility) {
   std::unique_ptr<Window> w1(CreateTestWindowWithId(1, root_window()));
   std::unique_ptr<Window> w2(CreateTestWindowWithId(1, w1.get()));
   w2->AddObserver(this);
 
   // Hide should make the window invisible and the passed visible
   // parameter is false.
   w2->Hide();
   EXPECT_TRUE(GetVisibilityInfo());
   EXPECT_TRUE(GetVisibilityInfo());
   if (!GetVisibilityInfo())
@@ skipping 31 matching lines @@
   // Verify that the OnWindowVisibilityChanged only once
   // per visibility change.
   w2->Hide();
   EXPECT_EQ(2, GetVisibilityInfo()->changed_count);
 
   w2->Hide();
   EXPECT_EQ(2, GetVisibilityInfo()->changed_count);
 }
 
 // Test if OnWindowDestroyed is invoked as expected.
-TEST_F(WindowObserverTest, WindowDestroyed) {
+TEST_P(WindowObserverTest, WindowDestroyed) {
   // Delete a window should fire a destroyed notification.
   std::unique_ptr<Window> w1(CreateTestWindowWithId(1, root_window()));
   w1->AddObserver(this);
   w1.reset();
   EXPECT_EQ(1, DestroyedCountAndClear());
 
   // Observe on child and delete parent window should fire a notification.
   std::unique_ptr<Window> parent(CreateTestWindowWithId(1, root_window()));
   Window* child = CreateTestWindowWithId(1, parent.get());  // owned by parent
   child->AddObserver(this);
   parent.reset();
   EXPECT_EQ(1, DestroyedCountAndClear());
 }
 
-TEST_F(WindowObserverTest, PropertyChanged) {
+TEST_P(WindowObserverTest, PropertyChanged) {
   // Setting property should fire a property change notification.
   std::unique_ptr<Window> w1(CreateTestWindowWithId(1, root_window()));
   w1->AddObserver(this);
 
   static const WindowProperty<int> prop = {-2};
   static const char native_prop_key[] = "fnord";
 
   w1->SetProperty(&prop, 1);
   EXPECT_EQ(PropertyChangeInfo(&prop, -2), PropertyChangeInfoAndClear());
   w1->SetProperty(&prop, -2);
   EXPECT_EQ(PropertyChangeInfo(&prop, 1), PropertyChangeInfoAndClear());
   w1->SetProperty(&prop, 3);
   EXPECT_EQ(PropertyChangeInfo(&prop, -2), PropertyChangeInfoAndClear());
   w1->ClearProperty(&prop);
   EXPECT_EQ(PropertyChangeInfo(&prop, 3), PropertyChangeInfoAndClear());
 
   w1->SetNativeWindowProperty(native_prop_key, &*w1);
   EXPECT_EQ(PropertyChangeInfo(native_prop_key, 0),
             PropertyChangeInfoAndClear());
   w1->SetNativeWindowProperty(native_prop_key, NULL);
   EXPECT_EQ(PropertyChangeInfo(native_prop_key,
                                reinterpret_cast<intptr_t>(&*w1)),
             PropertyChangeInfoAndClear());
 
   // Sanity check to see if |PropertyChangeInfoAndClear| really clears.
   EXPECT_EQ(PropertyChangeInfo(
       reinterpret_cast<const void*>(NULL), -3), PropertyChangeInfoAndClear());
 }
 
-TEST_F(WindowObserverTest, AncestorTransformed) {
+TEST_P(WindowObserverTest, AncestorTransformed) {
   // Create following window hierarchy:
   //   root_window
   //   +-- w1
   //       +-- w2
   //       +-- w3
   //           +-- w4
   // Then, apply a transform to |w1| and ensure all its descendants are
   // notified.
   std::unique_ptr<Window> w1(CreateTestWindowWithId(1, root_window()));
   w1->AddObserver(this);
   std::unique_ptr<Window> w2(CreateTestWindowWithId(2, w1.get()));
   w2->AddObserver(this);
   std::unique_ptr<Window> w3(CreateTestWindowWithId(3, w1.get()));
   w3->AddObserver(this);
   std::unique_ptr<Window> w4(CreateTestWindowWithId(4, w3.get()));
   w4->AddObserver(this);
 
   EXPECT_EQ(std::string(), TransformNotificationsAndClear());
 
   gfx::Transform transform;
   transform.Translate(10, 10);
   w1->SetTransform(transform);
 
   EXPECT_EQ("(1,1)(1,2)(1,3)(1,4)", TransformNotificationsAndClear());
 }
 
-TEST_F(WindowTest, AcquireLayer) {
+TEST_P(WindowTest, AcquireLayer) {
   std::unique_ptr<Window> window1(CreateTestWindowWithId(1, root_window()));
   std::unique_ptr<Window> window2(CreateTestWindowWithId(2, root_window()));
   ui::Layer* parent = window1->parent()->layer();
   EXPECT_EQ(2U, parent->children().size());
 
   WindowTestApi window1_test_api(window1.get());
   WindowTestApi window2_test_api(window2.get());
 
   EXPECT_TRUE(window1_test_api.OwnsLayer());
   EXPECT_TRUE(window2_test_api.OwnsLayer());
@@ skipping 15 matching lines @@
   window1.reset();
   window2.reset();
 
   // This should be set by the window's destructor.
   EXPECT_TRUE(window1_layer->delegate() == NULL);
   EXPECT_EQ(1U, parent->children().size());
 }
 
 // Make sure that properties which should persist from the old layer to the new
 // layer actually do.
-TEST_F(WindowTest, RecreateLayer) {
+TEST_P(WindowTest, RecreateLayer) {
   // Set properties to non default values.
   gfx::Rect window_bounds(100, 100);
   Window w(new ColorTestWindowDelegate(SK_ColorWHITE));
   w.set_id(1);
   w.Init(ui::LAYER_SOLID_COLOR);
   w.SetBounds(window_bounds);
 
   ui::Layer* layer = w.layer();
   layer->SetVisible(false);
   layer->SetMasksToBounds(true);
 
   ui::Layer child_layer;
   layer->Add(&child_layer);
 
   std::unique_ptr<ui::Layer> old_layer(w.RecreateLayer());
   layer = w.layer();
   EXPECT_EQ(ui::LAYER_SOLID_COLOR, layer->type());
   EXPECT_FALSE(layer->visible());
   EXPECT_EQ(1u, layer->children().size());
   EXPECT_TRUE(layer->GetMasksToBounds());
   EXPECT_EQ("0,0 100x100", w.bounds().ToString());
   EXPECT_EQ("0,0 100x100", layer->bounds().ToString());
 }
 
 // Verify that RecreateLayer() stacks the old layer above the newly creatd
 // layer.
-TEST_F(WindowTest, RecreateLayerZOrder) {
+TEST_P(WindowTest, RecreateLayerZOrder) {
   std::unique_ptr<Window> w(CreateTestWindow(
       SK_ColorWHITE, 1, gfx::Rect(0, 0, 100, 100), root_window()));
   std::unique_ptr<ui::Layer> old_layer(w->RecreateLayer());
 
   const std::vector<ui::Layer*>& child_layers =
       root_window()->layer()->children();
   ASSERT_EQ(2u, child_layers.size());
   EXPECT_EQ(w->layer(), child_layers[0]);
   EXPECT_EQ(old_layer.get(), child_layers[1]);
 }
 
 // Ensure that acquiring a layer then recreating a layer does not crash
 // and that RecreateLayer returns null.
-TEST_F(WindowTest, AcquireThenRecreateLayer) {
+TEST_P(WindowTest, AcquireThenRecreateLayer) {
   std::unique_ptr<Window> w(CreateTestWindow(
       SK_ColorWHITE, 1, gfx::Rect(0, 0, 100, 100), root_window()));
   std::unique_ptr<ui::Layer> acquired_layer(w->AcquireLayer());
   std::unique_ptr<ui::Layer> doubly_acquired_layer(w->RecreateLayer());
   EXPECT_EQ(NULL, doubly_acquired_layer.get());
 
   // Destroy window before layer gets destroyed.
   w.reset();
 }
 
@@ skipping 13 matching lines @@
   void UpdateLayerVisibility(aura::Window* window, bool visible) override {
     if (!ignore_visibility_changes_)
       window->layer()->SetVisible(visible);
   }
 
  private:
   bool ignore_visibility_changes_;
   DISALLOW_COPY_AND_ASSIGN(TestVisibilityClient);
 };
 
-TEST_F(WindowTest, VisibilityClientIsVisible) {
+TEST_P(WindowTest, VisibilityClientIsVisible) {
   TestVisibilityClient client(root_window());
 
   std::unique_ptr<Window> window(CreateTestWindowWithId(1, root_window()));
   EXPECT_TRUE(window->IsVisible());
   EXPECT_TRUE(window->layer()->visible());
 
   window->Hide();
   EXPECT_FALSE(window->IsVisible());
   EXPECT_FALSE(window->layer()->visible());
   window->Show();
 
   client.set_ignore_visibility_changes(true);
   window->Hide();
   EXPECT_FALSE(window->IsVisible());
   EXPECT_TRUE(window->layer()->visible());
 }
 
 // Tests the mouse events seen by WindowDelegates in a Window hierarchy when
 // changing the properties of a leaf Window.
-TEST_F(WindowTest, MouseEventsOnLeafWindowChange) {
+TEST_P(WindowTest, MouseEventsOnLeafWindowChange) {
   ui::test::EventGenerator generator(root_window());
   generator.MoveMouseTo(50, 50);
 
   EventCountDelegate d1;
   std::unique_ptr<Window> w1(CreateTestWindowWithDelegate(
       &d1, 1, gfx::Rect(0, 0, 100, 100), root_window()));
   RunAllPendingInMessageLoop();
   // The format of result is "Enter/Move/Leave".
   EXPECT_EQ("1 1 0", d1.GetMouseMotionCountsAndReset());
 
@@ skipping 78 matching lines @@
 
   // Close |w11|.
   w11.reset();
   RunAllPendingInMessageLoop();
   EXPECT_EQ("0 0 0", d1.GetMouseMotionCountsAndReset());
   EXPECT_EQ("0 0 0", d11.GetMouseMotionCountsAndReset());
 }
 
 // Tests the mouse events seen by WindowDelegates in a Window hierarchy when
 // deleting a non-leaf Window.
-TEST_F(WindowTest, MouseEventsOnNonLeafWindowDelete) {
+TEST_P(WindowTest, MouseEventsOnNonLeafWindowDelete) {
   ui::test::EventGenerator generator(root_window());
   generator.MoveMouseTo(50, 50);
 
   EventCountDelegate d1;
   std::unique_ptr<Window> w1(CreateTestWindowWithDelegate(
       &d1, 1, gfx::Rect(0, 0, 100, 100), root_window()));
   RunAllPendingInMessageLoop();
   // The format of result is "Enter/Move/Leave".
   EXPECT_EQ("1 1 0", d1.GetMouseMotionCountsAndReset());
 
@@ skipping 44 matching lines @@
     ++removed_count_;
   }
 
  private:
   int added_count_;
   int removed_count_;
 
   DISALLOW_COPY_AND_ASSIGN(RootWindowAttachmentObserver);
 };
 
-TEST_F(WindowTest, RootWindowAttachment) {
+TEST_P(WindowTest, RootWindowAttachment) {
   RootWindowAttachmentObserver observer;
 
   // Test a direct add/remove from the RootWindow.
   std::unique_ptr<Window> w1(new Window(NULL));
   w1->Init(ui::LAYER_NOT_DRAWN);
   w1->AddObserver(&observer);
 
   ParentWindow(w1.get());
   EXPECT_EQ(1, observer.added_count());
   EXPECT_EQ(0, observer.removed_count());
@@ skipping 62 matching lines @@
   }
 
   bool root_set() const { return root_set_; }
 
  private:
   bool root_set_;
 
   DISALLOW_COPY_AND_ASSIGN(BoundsChangedWindowObserver);
 };
 
-TEST_F(WindowTest, RootWindowSetWhenReparenting) {
+TEST_P(WindowTest, RootWindowSetWhenReparenting) {
   Window parent1(NULL);
   parent1.Init(ui::LAYER_NOT_DRAWN);
   Window parent2(NULL);
   parent2.Init(ui::LAYER_NOT_DRAWN);
   ParentWindow(&parent1);
   ParentWindow(&parent2);
   parent1.SetBounds(gfx::Rect(10, 10, 300, 300));
   parent2.SetBounds(gfx::Rect(20, 20, 300, 300));
 
   BoundsChangedWindowObserver observer;
@@ skipping 17 matching lines @@
   parent2.AddChild(&child);
   EXPECT_TRUE(observer.root_set());
 
   // Animations should stop and the bounds should be as set before the |child|
   // got reparented.
   EXPECT_EQ(new_bounds.ToString(), child.GetTargetBounds().ToString());
   EXPECT_EQ(new_bounds.ToString(), child.bounds().ToString());
   EXPECT_EQ("55,55 50x50", child.GetBoundsInRootWindow().ToString());
 }
 
-TEST_F(WindowTest, OwnedByParentFalse) {
+TEST_P(WindowTest, OwnedByParentFalse) {
   // By default, a window is owned by its parent. If this is set to false, the
   // window will not be destroyed when its parent is.
 
   std::unique_ptr<Window> w1(new Window(NULL));
   w1->Init(ui::LAYER_NOT_DRAWN);
   std::unique_ptr<Window> w2(new Window(NULL));
   w2->set_owned_by_parent(false);
   w2->Init(ui::LAYER_NOT_DRAWN);
   w1->AddChild(w2.get());
 
@@ skipping 23 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(OwningWindowDelegate);
 };
 
 }  // namespace
 
 // Creates a window with two child windows. When the first child window is
 // destroyed (WindowDelegate::OnWindowDestroyed) it deletes the second child.
 // This synthesizes BrowserView and the status bubble. Both are children of the
 // same parent and destroying BrowserView triggers it destroying the status
 // bubble.
-TEST_F(WindowTest, DeleteWindowFromOnWindowDestroyed) {
+TEST_P(WindowTest, DeleteWindowFromOnWindowDestroyed) {
   std::unique_ptr<Window> parent(new Window(NULL));
   parent->Init(ui::LAYER_NOT_DRAWN);
   OwningWindowDelegate delegate;
   Window* c1 = new Window(&delegate);
   c1->Init(ui::LAYER_NOT_DRAWN);
   parent->AddChild(c1);
   Window* c2 = new Window(NULL);
   c2->Init(ui::LAYER_NOT_DRAWN);
   parent->AddChild(c2);
   delegate.SetOwnedWindow(c2);
@@ skipping 23 matching lines @@
   // Was OnBoundsChanged() invoked?
   bool bounds_changed_;
 
   DISALLOW_COPY_AND_ASSIGN(BoundsChangeDelegate);
 };
 
 }  // namespace
 
 // Verifies the delegate is notified when the actual bounds of the layer
 // change.
-TEST_F(WindowTest, DelegateNotifiedAsBoundsChange) {
+TEST_P(WindowTest, DelegateNotifiedAsBoundsChange) {
   BoundsChangeDelegate delegate;
 
   // We cannot short-circuit animations in this test.
   ui::ScopedAnimationDurationScaleMode test_duration_mode(
       ui::ScopedAnimationDurationScaleMode::NON_ZERO_DURATION);
 
   std::unique_ptr<Window> window(CreateTestWindowWithDelegate(
       &delegate, 1, gfx::Rect(0, 0, 100, 100), root_window()));
   window->layer()->GetAnimator()->set_disable_timer_for_test(true);
 
@@ skipping 13 matching lines @@
   base::TimeTicks start_time =
       window->layer()->GetAnimator()->last_step_time();
   ui::LayerAnimator* animator = window->layer()->GetAnimator();
   animator->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
   EXPECT_TRUE(delegate.bounds_changed());
   EXPECT_NE("0,0 100x100", window->bounds().ToString());
 }
 
 // Verifies the delegate is notified when the actual bounds of the layer
 // change even when the window is not the layer's delegate
-TEST_F(WindowTest, DelegateNotifiedAsBoundsChangeInHiddenLayer) {
+TEST_P(WindowTest, DelegateNotifiedAsBoundsChangeInHiddenLayer) {
   BoundsChangeDelegate delegate;
 
   // We cannot short-circuit animations in this test.
   ui::ScopedAnimationDurationScaleMode test_duration_mode(
       ui::ScopedAnimationDurationScaleMode::NON_ZERO_DURATION);
 
   std::unique_ptr<Window> window(CreateTestWindowWithDelegate(
       &delegate, 1, gfx::Rect(0, 0, 100, 100), root_window()));
   window->layer()->GetAnimator()->set_disable_timer_for_test(true);
 
@@ skipping 52 matching lines @@
  private:
   int added_count_;
   int removed_count_;
 
   DISALLOW_COPY_AND_ASSIGN(AddChildNotificationsObserver);
 };
 
 }  // namespace
 
 // Assertions around when root window notifications are sent.
-TEST_F(WindowTest, AddChildNotifications) {
+TEST_P(WindowTest, AddChildNotifications) {
   AddChildNotificationsObserver observer;
   std::unique_ptr<Window> w1(CreateTestWindowWithId(1, root_window()));
   std::unique_ptr<Window> w2(CreateTestWindowWithId(1, root_window()));
   w2->AddObserver(&observer);
   w2->Focus();
   EXPECT_TRUE(w2->HasFocus());
 
   // Move |w2| to be a child of |w1|.
   w1->AddChild(w2.get());
   // Sine we moved in the same root, observer shouldn't be notified.
   EXPECT_EQ("0 0", observer.CountStringAndReset());
   // |w2| should still have focus after moving.
   EXPECT_TRUE(w2->HasFocus());
 }
 
 // Tests that a delegate that destroys itself when the window is destroyed does
 // not break.
-TEST_F(WindowTest, DelegateDestroysSelfOnWindowDestroy) {
+TEST_P(WindowTest, DelegateDestroysSelfOnWindowDestroy) {
   std::unique_ptr<Window> w1(
       CreateTestWindowWithDelegate(new DestroyWindowDelegate(), 0,
                                    gfx::Rect(10, 20, 30, 40), root_window()));
 }
 
 class HierarchyObserver : public WindowObserver {
  public:
   explicit HierarchyObserver(Window* target) : target_(target) {
     target_->AddObserver(this);
   }
@@ skipping 27 matching lines @@
     EXPECT_EQ(p1.receiver, p2.receiver);
   }
 
   Window* target_;
   std::vector<WindowObserver::HierarchyChangeParams> params_;
 
   DISALLOW_COPY_AND_ASSIGN(HierarchyObserver);
 };
 
 // Tests hierarchy change notifications.
-TEST_F(WindowTest, OnWindowHierarchyChange) {
+TEST_P(WindowTest, OnWindowHierarchyChange) {
   {
     // Simple add & remove.
     HierarchyObserver oroot(root_window());
 
     std::unique_ptr<Window> w1(CreateTestWindowWithId(1, NULL));
     HierarchyObserver o1(w1.get());
 
     // Add.
     root_window()->AddChild(w1.get());
 
@@ skipping 171 matching lines @@
       ui::LayerAnimationSequence* sequence) override {}
 
   bool animation_completed_;
   bool animation_aborted_;
 
   DISALLOW_COPY_AND_ASSIGN(TestLayerAnimationObserver);
 };
 
 }  // namespace
 
-TEST_F(WindowTest, WindowDestroyCompletesAnimations) {
+TEST_P(WindowTest, WindowDestroyCompletesAnimations) {
   ui::ScopedAnimationDurationScaleMode test_duration_mode(
       ui::ScopedAnimationDurationScaleMode::NON_ZERO_DURATION);
   scoped_refptr<ui::LayerAnimator> animator =
       ui::LayerAnimator::CreateImplicitAnimator();
   TestLayerAnimationObserver observer;
   animator->AddObserver(&observer);
   // Make sure destroying a Window completes the animation.
   {
     std::unique_ptr<Window> window(CreateTestWindowWithId(1, root_window()));
     window->layer()->SetAnimator(animator.get());
@@ skipping 28 matching lines @@
     EXPECT_FALSE(observer.animation_completed());
   }
 
   EXPECT_TRUE(animator.get());
   EXPECT_FALSE(animator->is_animating());
   EXPECT_TRUE(observer.animation_completed());
   EXPECT_FALSE(observer.animation_aborted());
   animator->RemoveObserver(&observer);
 }
 
+INSTANTIATE_TEST_CASE_P(/* no prefix */,
+                        WindowTest,
+                        ::testing::Values(BackendType::CLASSIC,
+                                          BackendType::MUS));
+
+INSTANTIATE_TEST_CASE_P(/* no prefix */,
+                        WindowObserverTest,
+                        ::testing::Values(BackendType::CLASSIC,
+                                          BackendType::MUS));
+
 }  // namespace test
 }  // namespace aura