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..705881909d02429bb13e9eacd0269872084de776
--- /dev/null
+++ b/components/exo/gamepad_unittest.cc
@@ -0,0 +1,161 @@
+// 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 "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() {}
+
+  void SetUp() override {
+    test::ExoTestBase::SetUp();
+    surface_.reset(new Surface);
+    shell_surface_.reset(new ShellSurface(surface_.get()));
+    gfx::Size buffer_size(10, 10);
+    buffer_.reset(
+        new Buffer(exo_test_helper()->CreateGpuMemoryBuffer(buffer_size)));
+    surface_->Attach(buffer_.get());
+    surface_->Commit();
+  }
+
+  void TearDown() override {
+    buffer_.reset();
+    shell_surface_.reset();
+    surface_.reset();
+    test::ExoTestBase::TearDown();
+  }
+
+  void InitializeGamepad(MockGamepadDelegate* delegate) {
+    blink::WebGamepads initial_data;
+    mock_data_fetcher_.reset(new device::MockGamepadDataFetcher(initial_data));
+
+    gamepad_.reset(new Gamepad(delegate, mock_data_fetcher_.get()));
+  }
+
+  void DestroyGamepad(MockGamepadDelegate* delegate) {
+    EXPECT_CALL(*delegate, OnGamepadDestroying(testing::_)).Times(1);
+    gamepad_.reset();
+  }
+
+  void SetDataAndWaitForDelegate(const blink::WebGamepads& new_data) {
+    mock_data_fetcher_->SetTestData(new_data);
+    // Wait for 2 polling cycles for data to be read and callbacks
+    // to be processed.
+    for (int i = 0; i < 1; ++i) {

[reveman, 2016/07/07 22:14:03]

this loop doesn't seem to be doing anything as i < 1 will just be true once. the
comment above also seem to indicate something else. what is this supposed to do?

+      mock_data_fetcher_->WaitForDataRead();
+      base::MessageLoop::current()->RunUntilIdle();
+    }
+  }
+
+ protected:
+  std::unique_ptr<Gamepad> gamepad_;
+
+  // Pointer owned by the gamepad instance.

[reveman, 2016/07/07 22:14:03]

this doesn't seem correct anymore

+  std::unique_ptr<device::MockGamepadDataFetcher> mock_data_fetcher_;
+
+  std::unique_ptr<Surface> surface_;
+  std::unique_ptr<ShellSurface> shell_surface_;
+  std::unique_ptr<Buffer> buffer_;
+
+  DISALLOW_COPY_AND_ASSIGN(GamepadTest);
+};
+
+TEST_F(GamepadTest, OnStateChange) {
+  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;
+  SetDataAndWaitForDelegate(gamepad_connected);
+
+  // Gamepad disconnected.
+  blink::WebGamepads all_disconnected;
+  EXPECT_CALL(delegate, OnStateChange(false)).Times(1);
+  SetDataAndWaitForDelegate(all_disconnected);
+
+  DestroyGamepad(&delegate);
+}
+
+TEST_F(GamepadTest, OnAxis) {
+  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);
+  SetDataAndWaitForDelegate(axis_moved);
+
+  DestroyGamepad(&delegate);
+}
+
+TEST_F(GamepadTest, OnButton) {
+  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);
+  SetDataAndWaitForDelegate(axis_moved);
+
+  DestroyGamepad(&delegate);
+}
+
+}  // namespace
+}  // namespace exo