exo: Implement wayland gamepad support

components/exo/gamepad_unittest.cc

Index: components/exo/gamepad_unittest.cc
diff --git a/components/exo/gamepad_unittest.cc b/components/exo/gamepad_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..9b6584882058304dc3b5089d76aeb66993987b08
--- /dev/null
+++ b/components/exo/gamepad_unittest.cc
@@ -0,0 +1,218 @@
+// 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 "ash/shell.h"
+#include "base/command_line.h"
+#include "base/test/test_simple_task_runner.h"
+#include "components/exo/buffer.h"
+#include "components/exo/gamepad.h"
+#include "components/exo/gamepad_delegate.h"
+#include "components/exo/shell_surface.h"
+#include "components/exo/surface.h"
+#include "components/exo/test/exo_test_base.h"
+#include "components/exo/test/exo_test_helper.h"
+#include "device/gamepad/gamepad_test_helpers.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/aura/client/focus_client.h"
+
+namespace exo {
+namespace {
+
+class MockGamepadDelegate : public GamepadDelegate {
+ public:
+  MockGamepadDelegate() {}
+
+  // Overridden from GamepadDelegate:
+  MOCK_METHOD1(OnGamepadDestroying, void(Gamepad*));
+  MOCK_CONST_METHOD1(CanAcceptGamepadEventsForSurface, bool(Surface*));
+  MOCK_METHOD1(OnStateChange, void(bool));
+  MOCK_METHOD2(OnAxis, void(int, double));
+  MOCK_METHOD3(OnButton, void(int, bool, double));
+  MOCK_METHOD0(OnFrame, void());
+};
+
+class GamepadTest : public test::ExoTestBase {
+ public:
+  GamepadTest() {}
+
+  std::unique_ptr<device::GamepadDataFetcher> MockDataFetcherFactory() {
+    blink::WebGamepads initial_data;
+    std::unique_ptr<device::MockGamepadDataFetcher> fetcher(
+        new device::MockGamepadDataFetcher(initial_data));
+    mock_data_fetcher_ = fetcher.get();
+    return std::move(fetcher);
+  }
+
+  void InitializeGamepad(MockGamepadDelegate* delegate) {

[reveman, 2016/07/11 10:50:44]

Would be nice to have one test that verifies that multiple gamepad instances
work correctly but this seems to limit testing to one instance. I'm OK with
having that not be tested for now but something to think about for the future.

[denniskempin, 2016/07/11 17:43:29]

I think that would be a good thing to do when we add support for multiple
gamepads. 

+    polling_task_runner_ = new base::TestSimpleTaskRunner();
+    gamepad_.reset(new Gamepad(delegate,
+                               make_scoped_refptr(polling_task_runner_.get()),
+                               base::Bind(&GamepadTest::MockDataFetcherFactory,
+                                          base::Unretained(this))));
+    // Run the polling task runner to have it create the data fetcher.
+    polling_task_runner_->RunPendingTasks();
+  }
+
+  void DestroyGamepad(MockGamepadDelegate* delegate) {
+    EXPECT_CALL(*delegate, OnGamepadDestroying(testing::_)).Times(1);
+    mock_data_fetcher_ = nullptr;
+    gamepad_.reset();
+    // Process tasks until polling is shut down.

[reveman, 2016/07/11 10:50:44]

are the following lines really needed?

[denniskempin, 2016/07/11 17:43:29]

Since polling is happening independently of the Gamepad instance and might
continue if not properly shut down by the Gamepad destructor, I'd like to make
sure this is happening so we are not messing up following tests.

+    polling_task_runner_->RunUntilIdle();
+    polling_task_runner_ = nullptr;
+  }
+
+  void SetDataAndPostToDelegate(const blink::WebGamepads& new_data) {
+    ASSERT_TRUE(mock_data_fetcher_ != nullptr);
+    mock_data_fetcher_->SetTestData(new_data);
+    // Run one polling cycle, which will post a task to the origin task runner.
+    polling_task_runner_->RunPendingTasks();
+    // Run origin task runner to invoke delegate
+    base::MessageLoop::current()->RunUntilIdle();
+  }
+
+ protected:
+  std::unique_ptr<Gamepad> gamepad_;
+
+  // 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(GamepadTest);
+};
+
+TEST_F(GamepadTest, OnStateChange) {
+  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<MockGamepadDelegate> delegate;
+  EXPECT_CALL(delegate, CanAcceptGamepadEventsForSurface(testing::_))
+      .WillOnce(testing::Return(true));
+
+  InitializeGamepad(&delegate);
+
+  // Gamepad connected.
+  EXPECT_CALL(delegate, OnStateChange(true)).Times(1);
+  blink::WebGamepads gamepad_connected;
+  gamepad_connected.length = 1;
+  gamepad_connected.items[0].connected = true;
+  gamepad_connected.items[0].timestamp = 1;
+  SetDataAndPostToDelegate(gamepad_connected);
+
+  // Gamepad disconnected.
+  blink::WebGamepads all_disconnected;
+  EXPECT_CALL(delegate, OnStateChange(false)).Times(1);
+  SetDataAndPostToDelegate(all_disconnected);
+
+  DestroyGamepad(&delegate);
+}
+
+TEST_F(GamepadTest, 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<MockGamepadDelegate> delegate;
+  EXPECT_CALL(delegate, CanAcceptGamepadEventsForSurface(testing::_))
+      .WillOnce(testing::Return(true));
+
+  InitializeGamepad(&delegate);
+
+  blink::WebGamepads axis_moved;
+  axis_moved.length = 1;
+  axis_moved.items[0].connected = true;
+  axis_moved.items[0].timestamp = 1;
+  axis_moved.items[0].axesLength = 1;
+  axis_moved.items[0].axes[0] = 1.0;
+
+  EXPECT_CALL(delegate, OnStateChange(true)).Times(1);
+  EXPECT_CALL(delegate, OnAxis(0, 1.0)).Times(1);
+  EXPECT_CALL(delegate, OnFrame()).Times(1);
+  SetDataAndPostToDelegate(axis_moved);
+
+  DestroyGamepad(&delegate);
+}
+
+TEST_F(GamepadTest, 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<MockGamepadDelegate> delegate;
+  EXPECT_CALL(delegate, CanAcceptGamepadEventsForSurface(testing::_))
+      .WillOnce(testing::Return(true));
+
+  InitializeGamepad(&delegate);
+
+  blink::WebGamepads axis_moved;
+  axis_moved.length = 1;
+  axis_moved.items[0].connected = true;
+  axis_moved.items[0].timestamp = 1;
+  axis_moved.items[0].buttonsLength = 1;
+  axis_moved.items[0].buttons[0].pressed = true;
+  axis_moved.items[0].buttons[0].value = 1.0;
+
+  EXPECT_CALL(delegate, OnStateChange(true)).Times(1);
+  EXPECT_CALL(delegate, OnButton(0, true, 1.0)).Times(1);
+  EXPECT_CALL(delegate, OnFrame()).Times(1);
+  SetDataAndPostToDelegate(axis_moved);
+
+  DestroyGamepad(&delegate);
+}
+
+TEST_F(GamepadTest, OnWindowFocused) {
+  // Create surface and focus on 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<MockGamepadDelegate> delegate;
+  EXPECT_CALL(delegate, CanAcceptGamepadEventsForSurface(testing::_))
+      .WillOnce(testing::Return(true));
+
+  InitializeGamepad(&delegate);
+
+  // In focus. Should be polling.
+  polling_task_runner_->RunPendingTasks();
+  ASSERT_TRUE(polling_task_runner_->HasPendingTask());
+  polling_task_runner_->RunPendingTasks();
+  ASSERT_TRUE(polling_task_runner_->HasPendingTask());
+
+  // Remove focus from exo window.
+  aura::client::FocusClient* focus_client =
+      aura::client::GetFocusClient(ash::Shell::GetPrimaryRootWindow());
+  focus_client->FocusWindow(nullptr);
+
+  // Run EnablePolling and OnPoll task, no more polls should be scheduled.
+  polling_task_runner_->RunPendingTasks();
+  polling_task_runner_->RunPendingTasks();
+  ASSERT_FALSE(polling_task_runner_->HasPendingTask());
+
+  DestroyGamepad(&delegate);
+}
+
+}  // namespace
+}  // namespace exo