Add gamepad hardware data fetcher, and higher level thread container

content/browser/gamepad/gamepad_provider_unittest.cc

+// Copyright (c) 2011 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 "base/memory/scoped_ptr.h"
+#include "base/process_util.h"
+#include "base/system_monitor/system_monitor.h"
+#include "content/browser/gamepad/gamepad_provider.h"
+#include "content/common/gamepad_messages.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace {
+
+class MockDataFetcher : public gamepad::DataFetcher {
+ public:
+  MockDataFetcher() {
+    memset(&test_data, 0, sizeof(test_data));
+  }
+  virtual void GetGamepadData(WebKit::WebGamepads& pads,
+                              bool devices_changed_hint) OVERRIDE {
+    pads = test_data;
+  }
+
+  void SetData(WebKit::WebGamepads& data) {
+    test_data = data;
+  }
+
+  WebKit::WebGamepads test_data;
+};
+
+// Main test fixture
+class GamepadProviderTest : public testing::Test {
+ public:
+  gamepad::Provider* CreateProvider() {
+    system_monitor_.reset(new base::SystemMonitor);
+    mock_data_fetcher_ = new MockDataFetcher;
+    provider_ = new gamepad::Provider(mock_data_fetcher_);
+    return provider_.get();
+  }
+
+ protected:
+  GamepadProviderTest() {
+  }
+
+  MessageLoop main_message_loop_;
+  scoped_ptr<base::SystemMonitor> system_monitor_;
+  MockDataFetcher* mock_data_fetcher_;
+  scoped_refptr<gamepad::Provider> provider_;
+};
+
+TEST_F(GamepadProviderTest, BasicStartStop) {
+  gamepad::Provider* provider = CreateProvider();
+  provider->Start();
+  provider->Stop();
+  // Just ensure that there's no asserts on startup, shutdown, or destroy.
+}
+
+TEST_F(GamepadProviderTest, PollingAccess) {
+  using namespace gamepad;
+
+  Provider* provider = CreateProvider();
+  provider->Start();
+
+  WebKit::WebGamepads test_data;
+  test_data.length = 1;
+  test_data.items[0].connected = true;
+  test_data.items[0].timestamp = 0;
+  test_data.items[0].buttonsLength = 1;
+  test_data.items[0].axesLength = 2;
+  test_data.items[0].buttons[0] = 1.f;
+  test_data.items[0].axes[0] = -1.f;
+  test_data.items[0].axes[1] = .5f;
+  mock_data_fetcher_->SetData(test_data);
+
+  main_message_loop_.RunAllPending();
+  base::PlatformThread::Sleep(300);

[Paweł Hajdan Jr., 2011/11/16 08:36:35]

Why? Is it inherently timing-dependent, or should you wait on some event? What's
the purpose of this Sleep?

[scottmg, 2011/11/16 18:04:35]

The background thread polls hardware every 16ms. There's (intentionally) no
explicit synchronization between hardware polling and the consumer of the data
so there's no event available.

Thank you for pointing this out, I will need to keep an eye on this test to make
sure it doesn't cause flakyness.

[Paweł Hajdan Jr., 2011/11/17 09:40:59]

If it's background thread polling every 16ms, it's very scheduler-dependent
whether 300ms is the right amount of time to wait. Could you just wait for the
first poll to finish?

+

[jam, 2011/11/16 00:24:58]

extra blank line

[scottmg, 2011/11/16 18:04:35]

Done.

+
+  // Renderer-side, pull data out of poll buffer.
+  base::SharedMemoryHandle handle =
+    provider->GetRendererSharedMemoryHandle(base::GetCurrentProcessHandle());

[jam, 2011/11/16 00:24:58]

nit: 4 spaces

[scottmg, 2011/11/16 18:04:35]

Done.

+  base::SharedMemory* shared_memory = new base::SharedMemory(handle, true);
+  EXPECT_TRUE(shared_memory->Map(sizeof(GamepadHardwareBuffer)));
+  void* mem = shared_memory->memory();
+
+  GamepadHardwareBuffer* hwbuf = static_cast<GamepadHardwareBuffer*>(mem);
+  // See gamepad_hardware_buffer.h for details on the read discipline.
+  base::subtle::Atomic32 start, end;
+  int contention_count = 0;
+  WebKit::WebGamepads output;
+  for (;;)
+  {

[jam, 2011/11/16 00:24:58]

nit: brace bracket on previous line

[scottmg, 2011/11/16 18:04:35]

Done.

+    end = base::subtle::Acquire_Load(&hwbuf->end_marker);
+    memcpy(&output, &hwbuf->buffer, sizeof(output));
+    start = base::subtle::Acquire_Load(&hwbuf->start_marker);
+    if (start == end) break;
+    ++contention_count;
+    base::PlatformThread::YieldCurrentThread();

[Paweł Hajdan Jr., 2011/11/16 08:36:35]

What's the purpose of this? Tests generally run single-threaded, and this test
doesn't seem to create any background threads (or maybe the code under test
does?).

[scottmg, 2011/11/16 18:04:35]

That's right, the code under test creates a background thread.

[Paweł Hajdan Jr., 2011/11/17 09:40:59]

Still, what's the purpose of this? Threads should be fairly scheduled anyway, I
don't see a reason for an explicit yield. Furthermore, is it possible that the
loop will never finish? It's not obvious to me that there is no starvation here.

+  }
+
+  EXPECT_EQ(1, output.length);
+  EXPECT_EQ(1, output.items[0].buttonsLength);
+  EXPECT_EQ(1.f, output.items[0].buttons[0]);
+  EXPECT_EQ(2, output.items[0].axesLength);
+  EXPECT_EQ(-1.f, output.items[0].axes[0]);
+  EXPECT_EQ(0.5f, output.items[0].axes[1]);
+
+  provider->Stop();
+}
+
+}  // namespace