Allow gaming_seat to use ozone gamepad as back-end

components/exo/gaming_seat_unittest.cc

 // Copyright 2015 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 "components/exo/gaming_seat.h"
 #include "ash/shell.h"
 #include "base/command_line.h"
 #include "base/run_loop.h"
 #include "base/test/test_simple_task_runner.h"
 #include "components/exo/buffer.h"
@@ skipping 24 matching lines @@
  public:
   MockGamepadDelegate() {}
 
   // Overridden from GamepadDelegate:
   MOCK_METHOD0(OnRemoved, void());
   MOCK_METHOD2(OnAxis, void(int, double));
   MOCK_METHOD3(OnButton, void(int, bool, double));
   MOCK_METHOD0(OnFrame, void());
 };
 
-class GamingSeatTest : public test::ExoTestBase {
+class GamingSeatJoydevTest : public test::ExoTestBase {
  public:
-  GamingSeatTest() {}
+  GamingSeatJoydevTest() {}
 
   std::unique_ptr<device::GamepadDataFetcher> MockDataFetcherFactory() {
     device::Gamepads initial_data;
     std::unique_ptr<device::MockGamepadDataFetcher> fetcher(
         new device::MockGamepadDataFetcher(initial_data));
     mock_data_fetcher_ = fetcher.get();
     return std::move(fetcher);
   }
 
   void InitializeGamingSeat(MockGamingSeatDelegate* delegate) {
     polling_task_runner_ = new base::TestSimpleTaskRunner();
     gaming_seat_.reset(
         new GamingSeat(delegate, polling_task_runner_.get(),
-                       base::Bind(&GamingSeatTest::MockDataFetcherFactory,
+                       base::Bind(&GamingSeatJoydevTest::MockDataFetcherFactory,
                                   base::Unretained(this))));
     // Run the polling task runner to have it create the data fetcher.
     polling_task_runner_->RunPendingTasks();
   }
 
   void DestroyGamingSeat(MockGamingSeatDelegate* delegate) {
     EXPECT_CALL(*delegate, Die()).Times(1);
     mock_data_fetcher_ = nullptr;
     gaming_seat_.reset();
     // Process tasks until polling is shut down.
@@ skipping 14 matching lines @@
   std::unique_ptr<GamingSeat> gaming_seat_;
 
   // Task runner to simulate the polling thread.
   scoped_refptr<base::TestSimpleTaskRunner> polling_task_runner_;
 
   // Weak reference to the mock data fetcher provided by MockDataFetcherFactory.
   // This instance is valid until both gamepad_ and polling_task_runner_ are
   // shut down.
   device::MockGamepadDataFetcher* mock_data_fetcher_;
 
-  DISALLOW_COPY_AND_ASSIGN(GamingSeatTest);
+  DISALLOW_COPY_AND_ASSIGN(GamingSeatJoydevTest);
 };
 
-TEST_F(GamingSeatTest, ConnectionChange) {
+TEST_F(GamingSeatJoydevTest, ConnectionChange) {
   std::unique_ptr<Surface> surface(new Surface);
   std::unique_ptr<ShellSurface> shell_surface(new ShellSurface(surface.get()));
   gfx::Size buffer_size(10, 10);
   std::unique_ptr<Buffer> buffer(
       new Buffer(exo_test_helper()->CreateGpuMemoryBuffer(buffer_size)));
   surface->Attach(buffer.get());
   surface->Commit();
 
   testing::StrictMock<MockGamingSeatDelegate>* gaming_seat_delegate =
       new testing::StrictMock<MockGamingSeatDelegate>();
@@ skipping 41 matching lines @@
 
   SetDataAndPostToDelegate(gamepad_connected);
 
   // Gamepad disconnected.
   device::Gamepads all_disconnected;
   SetDataAndPostToDelegate(all_disconnected);
 
   DestroyGamingSeat(gaming_seat_delegate);
 }
 
-TEST_F(GamingSeatTest, OnAxis) {
+TEST_F(GamingSeatJoydevTest, OnAxis) {
   std::unique_ptr<Surface> surface(new Surface);
   std::unique_ptr<ShellSurface> shell_surface(new ShellSurface(surface.get()));
   gfx::Size buffer_size(10, 10);
   std::unique_ptr<Buffer> buffer(
       new Buffer(exo_test_helper()->CreateGpuMemoryBuffer(buffer_size)));
   surface->Attach(buffer.get());
   surface->Commit();
 
   testing::StrictMock<MockGamingSeatDelegate>* gaming_seat_delegate =
       new testing::StrictMock<MockGamingSeatDelegate>();
@@ skipping 38 matching lines @@
 
   EXPECT_CALL(gamepad_delegate0, OnAxis(0, 2.0)).Times(1);
   EXPECT_CALL(gamepad_delegate0, OnFrame()).Times(1);
   SetDataAndPostToDelegate(axis_moved);
 
   EXPECT_CALL(gamepad_delegate0, OnRemoved()).Times(1);
   EXPECT_CALL(gamepad_delegate2, OnRemoved()).Times(1);
   DestroyGamingSeat(gaming_seat_delegate);
 }
 
-TEST_F(GamingSeatTest, OnButton) {
+TEST_F(GamingSeatJoydevTest, OnButton) {
   std::unique_ptr<Surface> surface(new Surface);
   std::unique_ptr<ShellSurface> shell_surface(new ShellSurface(surface.get()));
   gfx::Size buffer_size(10, 10);
   std::unique_ptr<Buffer> buffer(
       new Buffer(exo_test_helper()->CreateGpuMemoryBuffer(buffer_size)));
   surface->Attach(buffer.get());
   surface->Commit();
 
   testing::StrictMock<MockGamingSeatDelegate>* gaming_seat_delegate =
       new testing::StrictMock<MockGamingSeatDelegate>();
@@ skipping 42 matching lines @@
   EXPECT_CALL(gamepad_delegate0, OnButton(0, true, 2.0)).Times(1);
   EXPECT_CALL(gamepad_delegate0, OnFrame()).Times(1);
   SetDataAndPostToDelegate(axis_moved);
 
   EXPECT_CALL(gamepad_delegate0, OnRemoved()).Times(1);
   EXPECT_CALL(gamepad_delegate2, OnRemoved()).Times(1);
 
   DestroyGamingSeat(gaming_seat_delegate);
 }
 
-TEST_F(GamingSeatTest, OnWindowFocused) {
+TEST_F(GamingSeatJoydevTest, OnWindowFocused) {
   // Create surface and move focus to it.
   std::unique_ptr<Surface> surface(new Surface);
   std::unique_ptr<ShellSurface> shell_surface(new ShellSurface(surface.get()));
   gfx::Size buffer_size(10, 10);
   std::unique_ptr<Buffer> buffer(
       new Buffer(exo_test_helper()->CreateGpuMemoryBuffer(buffer_size)));
   surface->Attach(buffer.get());
   surface->Commit();
 
   testing::StrictMock<MockGamingSeatDelegate>* gaming_seat_delegate =
@@ skipping 22 matching lines @@
   // scheduled in the next round.
   polling_task_runner_->RunPendingTasks();
   polling_task_runner_->RunPendingTasks();
   ASSERT_FALSE(polling_task_runner_->HasPendingTask());
 
   DestroyGamingSeat(gaming_seat_delegate);
 }
 
 }  // namespace
 }  // namespace exo