Runs most aura tests with both backends

ui/aura/window_targeter_unittest.cc

 // Copyright (c) 2013 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_targeter.h"
 
 #include <utility>
 
 #include "base/macros.h"
 #include "ui/aura/scoped_window_targeter.h"
@@ skipping 17 matching lines @@
   Window* FindTargetForLocatedEvent(Window* window,
                                     ui::LocatedEvent* event) override {
     return window_;
   }
 
   Window* window_;
 
   DISALLOW_COPY_AND_ASSIGN(StaticWindowTargeter);
 };
 
-class WindowTargeterTest : public test::AuraTestBase {
- public:
-  WindowTargeterTest() {}
-  ~WindowTargeterTest() override {}
-
-  Window* root_window() { return AuraTestBase::root_window(); }
-};
-
 gfx::RectF GetEffectiveVisibleBoundsInRootWindow(Window* window) {
   gfx::RectF bounds = gfx::RectF(gfx::SizeF(window->bounds().size()));
   Window* root = window->GetRootWindow();
   CHECK(window->layer());
   CHECK(root->layer());
   gfx::Transform transform;
   if (!window->layer()->GetTargetTransformRelativeTo(root->layer(), &transform))
     return gfx::RectF();
   transform.TransformRect(&bounds);
   return bounds;
 }
 
-TEST_F(WindowTargeterTest, Basic) {
+using WindowTargeterTest = test::AuraTestBaseWithType;
+
+TEST_P(WindowTargeterTest, Basic) {
   test::TestWindowDelegate delegate;
   std::unique_ptr<Window> window(
       CreateNormalWindow(1, root_window(), &delegate));
   Window* one = CreateNormalWindow(2, window.get(), &delegate);
   Window* two = CreateNormalWindow(3, window.get(), &delegate);
 
   window->SetBounds(gfx::Rect(0, 0, 100, 100));
   one->SetBounds(gfx::Rect(0, 0, 500, 100));
   two->SetBounds(gfx::Rect(501, 0, 500, 1000));
 
   root_window()->Show();
 
   ui::test::TestEventHandler handler;
   one->AddPreTargetHandler(&handler);
 
   ui::MouseEvent press(ui::ET_MOUSE_PRESSED, gfx::Point(20, 20),
                        gfx::Point(20, 20), ui::EventTimeForNow(), ui::EF_NONE,
                        ui::EF_NONE);
   DispatchEventUsingWindowDispatcher(&press);
   EXPECT_EQ(1, handler.num_mouse_events());
 
   handler.Reset();
   DispatchEventUsingWindowDispatcher(&press);
   EXPECT_EQ(1, handler.num_mouse_events());
 
   one->RemovePreTargetHandler(&handler);
 }
 
-TEST_F(WindowTargeterTest, ScopedWindowTargeter) {
+TEST_P(WindowTargeterTest, ScopedWindowTargeter) {
   test::TestWindowDelegate delegate;
   std::unique_ptr<Window> window(
       CreateNormalWindow(1, root_window(), &delegate));
   Window* child = CreateNormalWindow(2, window.get(), &delegate);
 
   window->SetBounds(gfx::Rect(30, 30, 100, 100));
   child->SetBounds(gfx::Rect(20, 20, 50, 50));
   root_window()->Show();
 
   ui::EventTarget* root = root_window();
@@ skipping 19 matching lines @@
   scoped_targeter.reset();
   {
     ui::MouseEvent mouse(ui::ET_MOUSE_MOVED, event_location, event_location,
                          ui::EventTimeForNow(), ui::EF_NONE, ui::EF_NONE);
     EXPECT_EQ(child, targeter->FindTargetForEvent(root, &mouse));
   }
 }
 
 // Test that ScopedWindowTargeter does not crash if the window for which it
 // replaces the targeter gets destroyed before it does.
-TEST_F(WindowTargeterTest, ScopedWindowTargeterWindowDestroyed) {
+TEST_P(WindowTargeterTest, ScopedWindowTargeterWindowDestroyed) {
   test::TestWindowDelegate delegate;
   std::unique_ptr<Window> window(
       CreateNormalWindow(1, root_window(), &delegate));
   std::unique_ptr<ScopedWindowTargeter> scoped_targeter(
       new ScopedWindowTargeter(window.get(),
                                std::unique_ptr<ui::EventTargeter>(
                                    new StaticWindowTargeter(window.get()))));
 
   window.reset();
   scoped_targeter.reset();
 
   // We did not crash!
 }
 
-TEST_F(WindowTargeterTest, TargetTransformedWindow) {
+TEST_P(WindowTargeterTest, TargetTransformedWindow) {
   root_window()->Show();
 
   test::TestWindowDelegate delegate;
   std::unique_ptr<Window> window(
       CreateNormalWindow(2, root_window(), &delegate));
 
   const gfx::Rect window_bounds(100, 20, 400, 80);
   window->SetBounds(window_bounds);
 
   ui::EventTarget* root_target = root_window();
@@ skipping 41 matching lines @@
   bool SubtreeShouldBeExploredForEvent(Window* window,
                                        const ui::LocatedEvent& event) override {
     return (window->id() == id_ &&
             WindowTargeter::SubtreeShouldBeExploredForEvent(window, event));
   }
 
  private:
   int id_;
 };
 
-TEST_F(WindowTargeterTest, Bounds) {
+TEST_P(WindowTargeterTest, Bounds) {
   test::TestWindowDelegate delegate;
   std::unique_ptr<Window> parent(
       CreateNormalWindow(1, root_window(), &delegate));
   std::unique_ptr<Window> child(CreateNormalWindow(1, parent.get(), &delegate));
   std::unique_ptr<Window> grandchild(
       CreateNormalWindow(1, child.get(), &delegate));
 
   parent->SetBounds(gfx::Rect(0, 0, 30, 30));
   child->SetBounds(gfx::Rect(5, 5, 20, 20));
   grandchild->SetBounds(gfx::Rect(5, 5, 5, 5));
@@ skipping 59 matching lines @@
  private:
   // WindowTargeter:
   bool SubtreeShouldBeExploredForEvent(Window* window,
                                        const ui::LocatedEvent& event) override {
     return false;
   }
 };
 
 // Verifies that an EventTargeter installed on an EventTarget can dictate
 // whether the target itself can process an event.
-TEST_F(WindowTargeterTest, TargeterChecksOwningEventTarget) {
+TEST_P(WindowTargeterTest, TargeterChecksOwningEventTarget) {
   test::TestWindowDelegate delegate;
   std::unique_ptr<Window> child(
       CreateNormalWindow(1, root_window(), &delegate));
 
   ui::EventTarget* root_target = root_window();
   ui::EventTargeter* targeter = root_target->GetEventTargeter();
 
   ui::MouseEvent mouse(ui::ET_MOUSE_MOVED, gfx::Point(10, 10),
                        gfx::Point(10, 10), ui::EventTimeForNow(), ui::EF_NONE,
                        ui::EF_NONE);
   EXPECT_EQ(child.get(), targeter->FindTargetForEvent(root_target, &mouse));
 
   // Install an event targeter on |child| which always prevents the target from
   // receiving event.
   child->SetEventTargeter(
       std::unique_ptr<ui::EventTargeter>(new IgnoreWindowTargeter()));
 
   ui::MouseEvent mouse2(ui::ET_MOUSE_MOVED, gfx::Point(10, 10),
                         gfx::Point(10, 10), ui::EventTimeForNow(), ui::EF_NONE,
                         ui::EF_NONE);
   EXPECT_EQ(root_window(), targeter->FindTargetForEvent(root_target, &mouse2));
 }
 
+INSTANTIATE_TEST_CASE_P(/* no prefix */,
+                        WindowTargeterTest,
+                        ::testing::Values(test::BackendType::CLASSIC,
+                                          test::BackendType::MUS));
+
 }  // namespace aura