Move gamepad_service out of content/ and into device/

This patch is a subtask of "Decoupling Gamepad from //content".

In this patch the GamepadService, GamepadServiceUnittest, GamepadMonitor and
GamepadSharedBuffer are moved out of content/browser/gamepad or render_host,
and into device/gamepad/.

The file //content/common/gamepad_hardware_buffer.h is removed, we move the
definition of GamepadHardwareBuffer into gamepad_shared_memory.h, and change
its definition by using generic SharedMemorySeqLockBuffer<blink::WebGamepads>.

In the unittest of GamepadProvider, we don't pass a MockSharedMemoryBuffer
(which has no seqlock controls) anymore. GamepadProvider will create a
SharedMemoryBuffer by default in its constructor, so we add the seqlock-read
accordingly in its unittest.

Based on a patch by bajones@chromium.org.

BUG = 612330

Review-Url: https://codereview.chromium.org/2563483006
Cr-Commit-Position: refs/heads/master@{#437716}

content/browser/BUILD.gn

@@ -70,7 +70,6 @@ source_set("browser") {
     "//device/battery:mojo_bindings",
     "//device/bluetooth",
     "//device/gamepad",
-    "//device/gamepad/public/interfaces",
     "//device/generic_sensor",
     "//device/geolocation",
     "//device/geolocation/public/interfaces",
@@ -641,10 +640,6 @@ source_set("browser") {
     "frame_host/render_widget_host_view_child_frame.h",
     "frame_host/render_widget_host_view_guest.cc",
     "frame_host/render_widget_host_view_guest.h",
-    "gamepad/gamepad_service.cc",
-    "gamepad/gamepad_service.h",
-    "gamepad/gamepad_shared_buffer_impl.cc",
-    "gamepad/gamepad_shared_buffer_impl.h",
     "gpu/browser_gpu_channel_host_factory.cc",
     "gpu/browser_gpu_channel_host_factory.h",
     "gpu/browser_gpu_memory_buffer_manager.cc",
@@ -1003,8 +998,6 @@ source_set("browser") {
     "renderer_host/font_utils_linux.h",
     "renderer_host/frame_metadata_util.cc",
     "renderer_host/frame_metadata_util.h",
-    "renderer_host/gamepad_monitor.cc",
-    "renderer_host/gamepad_monitor.h",
     "renderer_host/input/gesture_event_queue.cc",
     "renderer_host/input/gesture_event_queue.h",
     "renderer_host/input/input_ack_handler.h",

content/browser/browser_main_loop.cc

@@ -54,7 +54,6 @@
 #include "content/browser/dom_storage/dom_storage_area.h"
 #include "content/browser/download/download_resource_handler.h"
 #include "content/browser/download/save_file_manager.h"
-#include "content/browser/gamepad/gamepad_service.h"
 #include "content/browser/gpu/browser_gpu_channel_host_factory.h"
 #include "content/browser/gpu/browser_gpu_memory_buffer_manager.h"
 #include "content/browser/gpu/compositor_util.h"
@@ -90,6 +89,7 @@
 #include "content/public/common/main_function_params.h"
 #include "content/public/common/result_codes.h"
 #include "device/battery/battery_status_service.h"
+#include "device/gamepad/gamepad_service.h"
 #include "device/time_zone_monitor/time_zone_monitor.h"
 #include "media/base/media.h"
 #include "media/base/user_input_monitor.h"
@@ -1272,7 +1272,7 @@ void BrowserMainLoop::ShutdownThreadsAndCleanUp() {
   // I/O thread and isn't threadsafe.
   {
     TRACE_EVENT0("shutdown", "BrowserMainLoop::Subsystem:GamepadService");
-    GamepadService::GetInstance()->Terminate();
+    device::GamepadService::GetInstance()->Terminate();
   }
   {
     TRACE_EVENT0("shutdown", "BrowserMainLoop::Subsystem:SensorService");

content/browser/gamepad/OWNERS

-scottmg@chromium.org
-bajones@chromium.org

content/browser/gamepad/gamepad_service_test_helpers.cc

-// Copyright (c) 2012 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 "content/browser/gamepad/gamepad_service_test_helpers.h"
-
-#include "content/browser/gamepad/gamepad_service.h"
-
-namespace content {
-
-GamepadServiceTestConstructor::GamepadServiceTestConstructor(
-    const blink::WebGamepads& test_data) {
-  data_fetcher_ = new device::MockGamepadDataFetcher(test_data);
-  gamepad_service_ = new GamepadService(
-      std::unique_ptr<device::GamepadDataFetcher>(data_fetcher_));
-}
-
-GamepadServiceTestConstructor::~GamepadServiceTestConstructor() {
-  delete gamepad_service_;
-}
-
-}  // namespace content

content/browser/gamepad/gamepad_service_test_helpers.h

-// Copyright (c) 2012 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.
-
-#ifndef CONTENT_BROWSER_GAMEPAD_GAMEPAD_SERVICE_TEST_HELPERS_H_
-#define CONTENT_BROWSER_GAMEPAD_GAMEPAD_SERVICE_TEST_HELPERS_H_
-
-#include "base/macros.h"
-#include "device/gamepad/gamepad_test_helpers.h"
-#include "third_party/WebKit/public/platform/WebGamepads.h"
-
-namespace content {
-
-class GamepadService;
-
-// Constructs a GamepadService with a mock data source. This bypasses the
-// global singleton for the gamepad service.
-class GamepadServiceTestConstructor : public device::GamepadTestHelper {
- public:
-  explicit GamepadServiceTestConstructor(const blink::WebGamepads& test_data);
-  ~GamepadServiceTestConstructor() override;
-
-  GamepadService* gamepad_service() { return gamepad_service_; }
-  device::MockGamepadDataFetcher* data_fetcher() { return data_fetcher_; }
-
- private:
-  // Owning pointer (can't be a scoped_ptr due to private destructor).
-  GamepadService* gamepad_service_;
-
-  // Pointer owned by the provider (which is owned by the gamepad service).
-  device::MockGamepadDataFetcher* data_fetcher_;
-
-  DISALLOW_COPY_AND_ASSIGN(GamepadServiceTestConstructor);
-};
-
-}  // namespace content
-
-#endif  // CONTENT_BROWSER_GAMEPAD_GAMEPAD_SERVICE_TEST_HELPERS_H_

content/browser/gamepad/gamepad_shared_buffer_impl.h

-// Copyright (c) 2016 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.
-
-#ifndef CONTENT_BROWSER_GAMEPAD_GAMEPAD_SHARED_BUFFER_IMPL_H_
-#define CONTENT_BROWSER_GAMEPAD_GAMEPAD_SHARED_BUFFER_IMPL_H_
-
-#include "device/gamepad/gamepad_shared_buffer.h"
-#include "third_party/WebKit/public/platform/WebGamepads.h"
-
-namespace content {
-
-struct GamepadHardwareBuffer;
-
-class GamepadSharedBufferImpl : public device::GamepadSharedBuffer {
- public:
-  GamepadSharedBufferImpl();
-  ~GamepadSharedBufferImpl() override;
-
-  base::SharedMemory* shared_memory() override;
-  blink::WebGamepads* buffer() override;
-  GamepadHardwareBuffer* hardware_buffer();
-
-  void WriteBegin() override;
-  void WriteEnd() override;
-
- private:
-  base::SharedMemory shared_memory_;
-
-  DISALLOW_COPY_AND_ASSIGN(GamepadSharedBufferImpl);
-};
-
-}  // namespace content
-
-#endif  // CONTENT_BROWSER_GAMEPAD_GAMEPAD_SHARED_BUFFER_IMPL_H_

content/browser/renderer_host/pepper/pepper_gamepad_host.cc

@@ -5,8 +5,8 @@
 #include "content/browser/renderer_host/pepper/pepper_gamepad_host.h"
 
 #include "base/bind.h"
-#include "content/browser/gamepad/gamepad_service.h"
 #include "content/public/browser/browser_ppapi_host.h"
+#include "device/gamepad/gamepad_service.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/host/dispatch_host_message.h"
 #include "ppapi/host/host_message_context.h"
@@ -21,11 +21,11 @@ PepperGamepadHost::PepperGamepadHost(BrowserPpapiHost* host,
                                      PP_Resource resource)
     : ResourceHost(host->GetPpapiHost(), instance, resource),
       browser_ppapi_host_(host),
-      gamepad_service_(GamepadService::GetInstance()),
+      gamepad_service_(device::GamepadService::GetInstance()),
       is_started_(false),
       weak_factory_(this) {}
 
-PepperGamepadHost::PepperGamepadHost(GamepadService* gamepad_service,
+PepperGamepadHost::PepperGamepadHost(device::GamepadService* gamepad_service,
                                      BrowserPpapiHost* host,
                                      PP_Instance instance,
                                      PP_Resource resource)

content/browser/renderer_host/pepper/pepper_gamepad_host.h

@@ -14,6 +14,10 @@
 #include "device/gamepad/gamepad_consumer.h"
 #include "ppapi/host/resource_host.h"
 
+namespace device {
+class GamepadService;
+}
+
 namespace ppapi {
 namespace host {
 struct ReplyMessageContext;
@@ -23,7 +27,6 @@ struct ReplyMessageContext;
 namespace content {
 
 class BrowserPpapiHost;
-class GamepadService;
 
 class CONTENT_EXPORT PepperGamepadHost :
     public ppapi::host::ResourceHost,
@@ -35,7 +38,7 @@ class CONTENT_EXPORT PepperGamepadHost :
 
   // Allows tests to specify a gamepad service to use rather than the global
   // singleton. The caller owns the gamepad_service pointer.
-  PepperGamepadHost(GamepadService* gamepad_service,
+  PepperGamepadHost(device::GamepadService* gamepad_service,
                     BrowserPpapiHost* host,
                     PP_Instance instance,
                     PP_Resource resource);
@@ -59,7 +62,7 @@ class CONTENT_EXPORT PepperGamepadHost :
 
   BrowserPpapiHost* browser_ppapi_host_;
 
-  GamepadService* gamepad_service_;
+  device::GamepadService* gamepad_service_;
 
   bool is_started_;
 

content/browser/renderer_host/pepper/pepper_gamepad_host_unittest.cc

@@ -13,9 +13,8 @@
 #include "base/memory/weak_ptr.h"
 #include "base/run_loop.h"
 #include "build/build_config.h"
-#include "content/browser/gamepad/gamepad_service_test_helpers.h"
 #include "content/browser/renderer_host/pepper/browser_ppapi_host_test.h"
-#include "content/common/gamepad_hardware_buffer.h"
+#include "device/gamepad/gamepad_shared_buffer.h"
 #include "device/gamepad/gamepad_test_helpers.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/host/host_message_context.h"
@@ -36,13 +35,15 @@ class PepperGamepadHostTest : public testing::Test,
   ~PepperGamepadHostTest() override {}
 
   void ConstructService(const blink::WebGamepads& test_data) {
-    service_.reset(new GamepadServiceTestConstructor(test_data));
+    service_.reset(new device::GamepadServiceTestConstructor(test_data));
   }
 
-  GamepadService* gamepad_service() { return service_->gamepad_service(); }
+  device::GamepadService* gamepad_service() {
+    return service_->gamepad_service();
+  }
 
  protected:
-  std::unique_ptr<GamepadServiceTestConstructor> service_;
+  std::unique_ptr<device::GamepadServiceTestConstructor> service_;
 
   DISALLOW_COPY_AND_ASSIGN(PepperGamepadHostTest);
 };
@@ -59,13 +60,13 @@ inline ptrdiff_t AddressDiff(const void* a, const void* b) {
 TEST_F(PepperGamepadHostTest, ValidateHardwareBuffersMatch) {
   // Hardware buffer.
   static_assert(sizeof(ppapi::ContentGamepadHardwareBuffer) ==
-                    sizeof(GamepadHardwareBuffer),
+                    sizeof(device::GamepadHardwareBuffer),
                 "gamepad hardware buffers must match");
   ppapi::ContentGamepadHardwareBuffer ppapi_buf;
-  GamepadHardwareBuffer content_buf;
-  EXPECT_EQ(AddressDiff(&content_buf.sequence, &content_buf),
+  device::GamepadHardwareBuffer content_buf;
+  EXPECT_EQ(AddressDiff(&content_buf.seqlock, &content_buf),
             AddressDiff(&ppapi_buf.sequence, &ppapi_buf));
-  EXPECT_EQ(AddressDiff(&content_buf.buffer, &content_buf),
+  EXPECT_EQ(AddressDiff(&content_buf.data, &content_buf),
             AddressDiff(&ppapi_buf.buffer, &ppapi_buf));
 }
 

content/browser/renderer_host/render_process_host_impl.cc

@@ -99,7 +99,6 @@
 #include "content/browser/renderer_host/clipboard_message_filter.h"
 #include "content/browser/renderer_host/database_message_filter.h"
 #include "content/browser/renderer_host/file_utilities_message_filter.h"
-#include "content/browser/renderer_host/gamepad_monitor.h"
 #include "content/browser/renderer_host/media/audio_input_renderer_host.h"
 #include "content/browser/renderer_host/media/audio_renderer_host.h"
 #include "content/browser/renderer_host/media/media_stream_dispatcher_host.h"
@@ -164,6 +163,7 @@
 #include "content/public/common/service_names.mojom.h"
 #include "content/public/common/url_constants.h"
 #include "device/battery/battery_monitor_impl.h"
+#include "device/gamepad/gamepad_monitor.h"
 #include "device/power_monitor/power_monitor_message_broadcaster.h"
 #include "device/time_zone_monitor/time_zone_monitor.h"
 #include "gpu/GLES2/gl2extchromium.h"
@@ -1284,7 +1284,7 @@ void RenderProcessHostImpl::RegisterMojoInterfaces() {
   registry->AddInterface(base::Bind(&DeviceOrientationAbsoluteHost::Create));
 #endif  // defined(OS_ANDROID)
 
-  registry->AddInterface(base::Bind(&GamepadMonitor::Create));
+  registry->AddInterface(base::Bind(&device::GamepadMonitor::Create));
 
   registry->AddInterface(
       base::Bind(&VideoCaptureHost::Create,

content/common/BUILD.gn

@@ -125,7 +125,6 @@ source_set("common") {
     "frame_owner_properties.h",
     "frame_replication_state.cc",
     "frame_replication_state.h",
-    "gamepad_hardware_buffer.h",
     "generic_shared_memory_id_generator.cc",
     "generic_shared_memory_id_generator.h",
     "gin_java_bridge_messages.h",

content/common/gamepad_hardware_buffer.h

-// 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.
-
-#ifndef CONTENT_COMMON_GAMEPAD_HARDWARE_BUFFER_H_
-#define CONTENT_COMMON_GAMEPAD_HARDWARE_BUFFER_H_
-
-#include "device/base/synchronization/one_writer_seqlock.h"
-#include "third_party/WebKit/public/platform/WebGamepads.h"
-
-namespace content {
-
-/*
-
-This structure is stored in shared memory that's shared between the browser
-which does the hardware polling, and the various consumers of the gamepad
-state (renderers and NaCl plugins). The performance characteristics are that
-we want low latency (so would like to avoid explicit communication via IPC
-between producer and consumer) and relatively large data size.
-
-Writer and reader operate on the same buffer assuming contention is low, and
-contention is detected by using the associated SeqLock.
-
-*/
-
-struct GamepadHardwareBuffer {
-  // FIXME: Use the generic SharedMemorySeqLockBuffer<blink::WebGamepads>.
-  device::OneWriterSeqLock sequence;
-  blink::WebGamepads buffer;
-};
-
-}  // namespace content
-
-#endif  // CONTENT_COMMON_GAMEPAD_HARDWARE_BUFFER_H_

content/renderer/gamepad_shared_memory_reader.cc

@@ -6,7 +6,6 @@
 
 #include "base/metrics/histogram_macros.h"
 #include "base/trace_event/trace_event.h"
-#include "content/common/gamepad_hardware_buffer.h"
 #include "content/public/renderer/render_thread.h"
 #include "content/renderer/renderer_blink_platform_impl.h"
 #include "ipc/ipc_sync_message_filter.h"
@@ -92,12 +91,12 @@ void GamepadSharedMemoryReader::SampleGamepads(blink::WebGamepads& gamepads) {
   int contention_count = -1;
   base::subtle::Atomic32 version;
   do {
-    version = gamepad_hardware_buffer_->sequence.ReadBegin();
-    memcpy(&read_into, &gamepad_hardware_buffer_->buffer, sizeof(read_into));
+    version = gamepad_hardware_buffer_->seqlock.ReadBegin();
+    memcpy(&read_into, &gamepad_hardware_buffer_->data, sizeof(read_into));
     ++contention_count;
     if (contention_count == kMaximumContentionCount)
       break;
-  } while (gamepad_hardware_buffer_->sequence.ReadRetry(version));
+  } while (gamepad_hardware_buffer_->seqlock.ReadRetry(version));
   UMA_HISTOGRAM_COUNTS("Gamepad.ReadContentionCount", contention_count);
 
   if (contention_count >= kMaximumContentionCount) {

content/renderer/gamepad_shared_memory_reader.h

@@ -10,6 +10,7 @@
 #include "base/macros.h"
 #include "base/memory/shared_memory.h"
 #include "content/public/renderer/renderer_gamepad_provider.h"
+#include "device/base/synchronization/shared_memory_seqlock_buffer.h"
 #include "device/gamepad/public/interfaces/gamepad.mojom.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "mojo/public/cpp/system/platform_handle.h"
@@ -17,7 +18,8 @@
 
 namespace content {
 
-struct GamepadHardwareBuffer;
+typedef device::SharedMemorySeqLockBuffer<blink::WebGamepads>
+    GamepadHardwareBuffer;
 
 class GamepadSharedMemoryReader : public RendererGamepadProvider,
                                   public device::mojom::GamepadObserver {

content/test/BUILD.gn

@@ -1072,9 +1072,6 @@ test("content_unittests") {
     "../browser/frame_host/render_frame_host_manager_unittest.cc",
     "../browser/frame_host/render_widget_host_view_child_frame_unittest.cc",
     "../browser/frame_host/render_widget_host_view_guest_unittest.cc",
-    "../browser/gamepad/gamepad_service_test_helpers.cc",
-    "../browser/gamepad/gamepad_service_test_helpers.h",
-    "../browser/gamepad/gamepad_service_unittest.cc",
     "../browser/gpu/gpu_data_manager_impl_private_unittest.cc",
     "../browser/gpu/shader_disk_cache_unittest.cc",
     "../browser/host_zoom_map_impl_unittest.cc",

device/BUILD.gn

@@ -62,6 +62,7 @@ test("device_unittests") {
     "bluetooth/test/test_bluetooth_local_gatt_service_delegate.cc",
     "bluetooth/test/test_bluetooth_local_gatt_service_delegate.h",
     "gamepad/gamepad_provider_unittest.cc",
+    "gamepad/gamepad_service_unittest.cc",
     "gamepad/public/interfaces/gamepad_struct_traits_unittest.cc",
     "generic_sensor/platform_sensor_and_provider_unittest_win.cc",
     "generic_sensor/platform_sensor_provider_unittest.cc",

device/gamepad/BUILD.gn

@@ -23,6 +23,8 @@ component("gamepad") {
     "gamepad_data_fetcher.h",
     "gamepad_data_fetcher_manager.cc",
     "gamepad_data_fetcher_manager.h",
+    "gamepad_monitor.cc",
+    "gamepad_monitor.h",
     "gamepad_pad_state_provider.cc",
     "gamepad_pad_state_provider.h",
     "gamepad_platform_data_fetcher.h",
@@ -36,6 +38,10 @@ component("gamepad") {
     "gamepad_platform_data_fetcher_win.h",
     "gamepad_provider.cc",
     "gamepad_provider.h",
+    "gamepad_service.cc",
+    "gamepad_service.h",
+    "gamepad_shared_buffer.cc",
+    "gamepad_shared_buffer.h",
     "gamepad_standard_mappings.cc",
     "gamepad_standard_mappings.h",
     "gamepad_standard_mappings_linux.cc",
@@ -52,6 +58,9 @@ component("gamepad") {
   deps = [
     "//base",
     "//base/third_party/dynamic_annotations",
+    "//device/base/synchronization",
+    "//device/gamepad/public/interfaces",
+    "//mojo/public/cpp/system",
     "//third_party/WebKit/public:blink_headers",
   ]
 

content/browser/renderer_host/gamepad_monitor.cc → device/gamepad/gamepad_monitor.cc

@@ -2,26 +2,24 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "content/browser/renderer_host/gamepad_monitor.h"
+#include "device/gamepad/gamepad_monitor.h"
 
 #include "base/memory/shared_memory.h"
-#include "content/browser/gamepad/gamepad_service.h"
-#include "content/common/gamepad_hardware_buffer.h"
-#include "content/public/browser/browser_thread.h"
+#include "device/gamepad/gamepad_service.h"
+#include "device/gamepad/gamepad_shared_buffer.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 
-namespace content {
+namespace device {
 
 GamepadMonitor::GamepadMonitor() : is_started_(false) {}
 
 GamepadMonitor::~GamepadMonitor() {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (is_started_)
     GamepadService::GetInstance()->RemoveConsumer(this);
 }
 
 // static
-void GamepadMonitor::Create(device::mojom::GamepadMonitorRequest request) {
+void GamepadMonitor::Create(mojom::GamepadMonitorRequest request) {
   mojo::MakeStrongBinding(base::MakeUnique<GamepadMonitor>(),
                           std::move(request));
 }
@@ -57,9 +55,8 @@ void GamepadMonitor::GamepadStopPolling(
   callback.Run();
 }
 
-void GamepadMonitor::SetObserver(
-    device::mojom::GamepadObserverPtr gamepad_observer) {
+void GamepadMonitor::SetObserver(mojom::GamepadObserverPtr gamepad_observer) {
   gamepad_observer_ = std::move(gamepad_observer);
 }
 
-}  // namespace content
+}  // namespace device

content/browser/renderer_host/gamepad_monitor.h → device/gamepad/gamepad_monitor.h

@@ -2,23 +2,25 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CONTENT_BROWSER_RENDERER_HOST_GAMEPAD_MONITOR_H_
-#define CONTENT_BROWSER_RENDERER_HOST_GAMEPAD_MONITOR_H_
+#ifndef DEVICE_GAMEPAD_GAMEPAD_MONITOR_H_
+#define DEVICE_GAMEPAD_GAMEPAD_MONITOR_H_
 
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "device/gamepad/gamepad_consumer.h"
+#include "device/gamepad/gamepad_export.h"
 #include "device/gamepad/public/interfaces/gamepad.mojom.h"
 
-namespace content {
+namespace device {
 
-class GamepadMonitor : public device::GamepadConsumer,
-                       public device::mojom::GamepadMonitor {
+class DEVICE_GAMEPAD_EXPORT GamepadMonitor
+    : public GamepadConsumer,
+      NON_EXPORTED_BASE(public mojom::GamepadMonitor) {
  public:
   GamepadMonitor();
   ~GamepadMonitor() override;
 
-  static void Create(device::mojom::GamepadMonitorRequest request);
+  static void Create(mojom::GamepadMonitorRequest request);
 
   // GamepadConsumer implementation.
   void OnGamepadConnected(unsigned index,
@@ -26,19 +28,19 @@ class GamepadMonitor : public device::GamepadConsumer,
   void OnGamepadDisconnected(unsigned index,
                              const blink::WebGamepad& gamepad) override;
 
-  // device::mojom::GamepadMonitor implementation.
+  // mojom::GamepadMonitor implementation.
   void GamepadStartPolling(
       const GamepadStartPollingCallback& callback) override;
   void GamepadStopPolling(const GamepadStopPollingCallback& callback) override;
-  void SetObserver(device::mojom::GamepadObserverPtr gamepad_observer) override;
+  void SetObserver(mojom::GamepadObserverPtr gamepad_observer) override;
 
  private:
-  device::mojom::GamepadObserverPtr gamepad_observer_;
+  mojom::GamepadObserverPtr gamepad_observer_;
   bool is_started_;
 
   DISALLOW_COPY_AND_ASSIGN(GamepadMonitor);
 };
 
-}  // namespace content
+}  // namespace device
 
-#endif  // CONTENT_BROWSER_RENDERER_HOST_GAMEPAD_MONITOR_H_
+#endif  // DEVICE_GAMEPAD_GAMEPAD_MONITOR_H_

device/gamepad/gamepad_provider.cc

@@ -39,20 +39,18 @@ GamepadProvider::ClosureAndThread::ClosureAndThread(
 GamepadProvider::ClosureAndThread::~ClosureAndThread() {}
 
 GamepadProvider::GamepadProvider(
-    std::unique_ptr<GamepadSharedBuffer> buffer,
     GamepadConnectionChangeClient* connection_change_client)
     : is_paused_(true),
       have_scheduled_do_poll_(false),
       devices_changed_(true),
       ever_had_user_gesture_(false),
       sanitize_(true),
-      gamepad_shared_buffer_(std::move(buffer)),
+      gamepad_shared_buffer_(new GamepadSharedBuffer()),
       connection_change_client_(connection_change_client) {
   Initialize(std::unique_ptr<GamepadDataFetcher>());
 }
 
 GamepadProvider::GamepadProvider(
-    std::unique_ptr<GamepadSharedBuffer> buffer,
     GamepadConnectionChangeClient* connection_change_client,
     std::unique_ptr<GamepadDataFetcher> fetcher)
     : is_paused_(true),
@@ -60,7 +58,7 @@ GamepadProvider::GamepadProvider(
       devices_changed_(true),
       ever_had_user_gesture_(false),
       sanitize_(true),
-      gamepad_shared_buffer_(std::move(buffer)),
+      gamepad_shared_buffer_(new GamepadSharedBuffer()),
       connection_change_client_(connection_change_client) {
   Initialize(std::move(fetcher));
 }
@@ -260,7 +258,7 @@ void GamepadProvider::DoPoll() {
     base::AutoLock lock(shared_memory_lock_);
 
     // Acquire the SeqLock. There is only ever one writer to this data.
-    // See gamepad_hardware_buffer.h.
+    // See gamepad_shared_buffer.h.
     gamepad_shared_buffer_->WriteBegin();
     buffer->length = 0;
     for (unsigned i = 0; i < WebGamepads::itemsLengthCap; ++i) {

device/gamepad/gamepad_provider.h

@@ -42,12 +42,10 @@ class DEVICE_GAMEPAD_EXPORT GamepadProvider
       public base::SystemMonitor::DevicesChangedObserver {
  public:
   explicit GamepadProvider(
-      std::unique_ptr<GamepadSharedBuffer> buffer,
       GamepadConnectionChangeClient* connection_change_client);
 
   // Manually specifies the data fetcher. Used for testing.
   explicit GamepadProvider(
-      std::unique_ptr<GamepadSharedBuffer> buffer,
       GamepadConnectionChangeClient* connection_change_client,
       std::unique_ptr<GamepadDataFetcher> fetcher);
 

device/gamepad/gamepad_provider_unittest.cc

@@ -45,11 +45,20 @@ class GamepadProviderTest : public testing::Test, public GamepadTestHelper {
   GamepadProvider* CreateProvider(const WebGamepads& test_data) {
     mock_data_fetcher_ = new MockGamepadDataFetcher(test_data);
     provider_.reset(new GamepadProvider(
-        std::unique_ptr<GamepadSharedBuffer>(new MockGamepadSharedBuffer()),
         nullptr, std::unique_ptr<GamepadDataFetcher>(mock_data_fetcher_)));
     return provider_.get();
   }
 
+  void ReadGamepadHardwareBuffer(GamepadHardwareBuffer* buffer,
+                                 WebGamepads* output) {
+    memset(output, 0, sizeof(WebGamepads));
+    base::subtle::Atomic32 version;
+    do {
+      version = buffer->seqlock.ReadBegin();
+      memcpy(output, &buffer->data, sizeof(WebGamepads));
+    } while (buffer->seqlock.ReadRetry(version));
+  }
+
  protected:
   GamepadProviderTest() {}
 
@@ -70,6 +79,7 @@ class GamepadProviderTest : public testing::Test, public GamepadTestHelper {
 #endif
 TEST_F(GamepadProviderTest, MAYBE_PollingAccess) {
   WebGamepads test_data;
+  memset(&test_data, 0, sizeof(WebGamepads));
   test_data.length = 1;
   test_data.items[0].connected = true;
   test_data.items[0].timestamp = 0;
@@ -93,18 +103,20 @@ TEST_F(GamepadProviderTest, MAYBE_PollingAccess) {
       base::GetCurrentProcessHandle());
   std::unique_ptr<base::SharedMemory> shared_memory(
       new base::SharedMemory(handle, true));
-  EXPECT_TRUE(shared_memory->Map(sizeof(WebGamepads)));
-  void* mem = shared_memory->memory();
-
-  WebGamepads* output = static_cast<WebGamepads*>(mem);
-
-  EXPECT_EQ(1u, output->length);
-  EXPECT_EQ(1u, output->items[0].buttonsLength);
-  EXPECT_EQ(1.f, output->items[0].buttons[0].value);
-  EXPECT_EQ(true, output->items[0].buttons[0].pressed);
-  EXPECT_EQ(2u, output->items[0].axesLength);
-  EXPECT_EQ(-1.f, output->items[0].axes[0]);
-  EXPECT_EQ(0.5f, output->items[0].axes[1]);
+  EXPECT_TRUE(shared_memory->Map(sizeof(GamepadHardwareBuffer)));
+
+  GamepadHardwareBuffer* buffer =
+      static_cast<GamepadHardwareBuffer*>(shared_memory->memory());
+  WebGamepads output;
+  ReadGamepadHardwareBuffer(buffer, &output);
+
+  EXPECT_EQ(1u, output.length);
+  EXPECT_EQ(1u, output.items[0].buttonsLength);
+  EXPECT_EQ(1.f, output.items[0].buttons[0].value);
+  EXPECT_EQ(true, output.items[0].buttons[0].pressed);
+  EXPECT_EQ(2u, output.items[0].axesLength);
+  EXPECT_EQ(-1.f, output.items[0].axes[0]);
+  EXPECT_EQ(0.5f, output.items[0].axes[1]);
 }
 
 // Tests that waiting for a user gesture works properly.
@@ -191,43 +203,51 @@ TEST_F(GamepadProviderTest, MAYBE_Sanitization) {
       base::GetCurrentProcessHandle());
   std::unique_ptr<base::SharedMemory> shared_memory(
       new base::SharedMemory(handle, true));
-  EXPECT_TRUE(shared_memory->Map(sizeof(WebGamepads)));
-  void* mem = shared_memory->memory();
+  EXPECT_TRUE(shared_memory->Map(sizeof(GamepadHardwareBuffer)));
 
-  WebGamepads* output = static_cast<WebGamepads*>(mem);
+  GamepadHardwareBuffer* buffer =
+      static_cast<GamepadHardwareBuffer*>(shared_memory->memory());
+  WebGamepads output;
+  ReadGamepadHardwareBuffer(buffer, &output);
 
   // Initial data should all be zeroed out due to sanitization, even though the
   // gamepad reported input
-  EXPECT_EQ(1u, output->length);
-  EXPECT_EQ(1u, output->items[0].buttonsLength);
-  EXPECT_EQ(0.f, output->items[0].buttons[0].value);
-  EXPECT_FALSE(output->items[0].buttons[0].pressed);
-  EXPECT_EQ(1u, output->items[0].axesLength);
-  EXPECT_EQ(0.f, output->items[0].axes[0]);
+  EXPECT_EQ(1u, output.length);
+  EXPECT_EQ(1u, output.items[0].buttonsLength);
+  EXPECT_EQ(0.f, output.items[0].buttons[0].value);
+  EXPECT_FALSE(output.items[0].buttons[0].pressed);
+  EXPECT_EQ(1u, output.items[0].axesLength);
+  EXPECT_EQ(0.f, output.items[0].axes[0]);
 
   // Zero out the inputs
   mock_data_fetcher_->SetTestData(zero_data);
   mock_data_fetcher_->WaitForDataReadAndCallbacksIssued();
 
+  // Read updated data from shared memory
+  ReadGamepadHardwareBuffer(buffer, &output);
+
   // Should still read zero, which is now an accurate reflection of the data
-  EXPECT_EQ(1u, output->length);
-  EXPECT_EQ(1u, output->items[0].buttonsLength);
-  EXPECT_EQ(0.f, output->items[0].buttons[0].value);
-  EXPECT_FALSE(output->items[0].buttons[0].pressed);
-  EXPECT_EQ(1u, output->items[0].axesLength);
-  EXPECT_EQ(0.f, output->items[0].axes[0]);
+  EXPECT_EQ(1u, output.length);
+  EXPECT_EQ(1u, output.items[0].buttonsLength);
+  EXPECT_EQ(0.f, output.items[0].buttons[0].value);
+  EXPECT_FALSE(output.items[0].buttons[0].pressed);
+  EXPECT_EQ(1u, output.items[0].axesLength);
+  EXPECT_EQ(0.f, output.items[0].axes[0]);
 
   // Re-set the active inputs
   mock_data_fetcher_->SetTestData(active_data);
   mock_data_fetcher_->WaitForDataReadAndCallbacksIssued();
 
+  // Read updated data from shared memory
+  ReadGamepadHardwareBuffer(buffer, &output);
+
   // Should now accurately reflect the reported data.
-  EXPECT_EQ(1u, output->length);
-  EXPECT_EQ(1u, output->items[0].buttonsLength);
-  EXPECT_EQ(1.f, output->items[0].buttons[0].value);
-  EXPECT_TRUE(output->items[0].buttons[0].pressed);
-  EXPECT_EQ(1u, output->items[0].axesLength);
-  EXPECT_EQ(-1.f, output->items[0].axes[0]);
+  EXPECT_EQ(1u, output.length);
+  EXPECT_EQ(1u, output.items[0].buttonsLength);
+  EXPECT_EQ(1.f, output.items[0].buttons[0].value);
+  EXPECT_TRUE(output.items[0].buttons[0].pressed);
+  EXPECT_EQ(1u, output.items[0].axesLength);
+  EXPECT_EQ(-1.f, output.items[0].axes[0]);
 }
 
 }  // namespace

content/browser/gamepad/gamepad_service.cc → device/gamepad/gamepad_service.cc

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "content/browser/gamepad/gamepad_service.h"
+#include "device/gamepad/gamepad_service.h"
 
 #include <utility>
 
@@ -10,35 +10,33 @@
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/singleton.h"
-#include "content/browser/gamepad/gamepad_shared_buffer_impl.h"
-#include "content/common/gamepad_hardware_buffer.h"
-#include "content/public/browser/browser_thread.h"
-#include "content/public/browser/render_process_host.h"
+#include "base/single_thread_task_runner.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "device/gamepad/gamepad_consumer.h"
 #include "device/gamepad/gamepad_data_fetcher.h"
 #include "device/gamepad/gamepad_provider.h"
 #include "mojo/public/cpp/system/platform_handle.h"
 
-namespace content {
+namespace device {
 
 namespace {
 GamepadService* g_gamepad_service = 0;
 }
 
 GamepadService::GamepadService()
-    : num_active_consumers_(0),
+    : main_thread_task_runner_(base::ThreadTaskRunnerHandle::Get()),
+      num_active_consumers_(0),
       gesture_callback_pending_(false) {
   SetInstance(this);
 }
 
 GamepadService::GamepadService(
     std::unique_ptr<device::GamepadDataFetcher> fetcher)
-    : provider_(new device::GamepadProvider(
-        base::MakeUnique<GamepadSharedBufferImpl>(), this, std::move(fetcher))),
+    : provider_(new device::GamepadProvider(this, std::move(fetcher))),
+      main_thread_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       num_active_consumers_(0),
       gesture_callback_pending_(false) {
   SetInstance(this);
-  thread_checker_.DetachFromThread();
 }
 
 GamepadService::~GamepadService() {
@@ -60,11 +58,10 @@ GamepadService* GamepadService::GetInstance() {
 }
 
 void GamepadService::ConsumerBecameActive(device::GamepadConsumer* consumer) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(main_thread_task_runner_->BelongsToCurrentThread());
 
   if (!provider_)
-    provider_.reset(new device::GamepadProvider(
-        base::MakeUnique<GamepadSharedBufferImpl>(), this));
+    provider_.reset(new device::GamepadProvider(this));
 
   std::pair<ConsumerSet::iterator, bool> insert_result =
       consumers_.insert(consumer);
@@ -73,8 +70,7 @@ void GamepadService::ConsumerBecameActive(device::GamepadConsumer* consumer) {
       !gesture_callback_pending_) {
     gesture_callback_pending_ = true;
     provider_->RegisterForUserGesture(
-          base::Bind(&GamepadService::OnUserGesture,
-                     base::Unretained(this)));
+        base::Bind(&GamepadService::OnUserGesture, base::Unretained(this)));
   }
 
   if (num_active_consumers_++ == 0)
@@ -93,7 +89,7 @@ void GamepadService::ConsumerBecameInactive(device::GamepadConsumer* consumer) {
 }
 
 void GamepadService::RemoveConsumer(device::GamepadConsumer* consumer) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(main_thread_task_runner_->BelongsToCurrentThread());
 
   ConsumerSet::iterator it = consumers_.find(consumer);
   if (it->is_active && --num_active_consumers_ == 0)
@@ -103,7 +99,7 @@ void GamepadService::RemoveConsumer(device::GamepadConsumer* consumer) {
 
 void GamepadService::RegisterForUserGesture(const base::Closure& closure) {
   DCHECK(consumers_.size() > 0);
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(main_thread_task_runner_->BelongsToCurrentThread());
   provider_->RegisterForUserGesture(closure);
 }
 
@@ -115,35 +111,33 @@ void GamepadService::OnGamepadConnectionChange(bool connected,
                                                int index,
                                                const blink::WebGamepad& pad) {
   if (connected) {
-    BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-                            base::Bind(&GamepadService::OnGamepadConnected,
-                                       base::Unretained(this), index, pad));
+    main_thread_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&GamepadService::OnGamepadConnected,
+                              base::Unretained(this), index, pad));
   } else {
-    BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-                            base::Bind(&GamepadService::OnGamepadDisconnected,
-                                       base::Unretained(this), index, pad));
+    main_thread_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&GamepadService::OnGamepadDisconnected,
+                              base::Unretained(this), index, pad));
   }
 }
 
-void GamepadService::OnGamepadConnected(
-    int index,
-    const blink::WebGamepad& pad) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+void GamepadService::OnGamepadConnected(int index,
+                                        const blink::WebGamepad& pad) {
+  DCHECK(main_thread_task_runner_->BelongsToCurrentThread());
 
-  for (ConsumerSet::iterator it = consumers_.begin();
-       it != consumers_.end(); ++it) {
+  for (ConsumerSet::iterator it = consumers_.begin(); it != consumers_.end();
+       ++it) {
     if (it->did_observe_user_gesture && it->is_active)
       it->consumer->OnGamepadConnected(index, pad);
   }
 }
 
-void GamepadService::OnGamepadDisconnected(
-    int index,
-    const blink::WebGamepad& pad) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+void GamepadService::OnGamepadDisconnected(int index,
+                                           const blink::WebGamepad& pad) {
+  DCHECK(main_thread_task_runner_->BelongsToCurrentThread());
 
-  for (ConsumerSet::iterator it = consumers_.begin();
-       it != consumers_.end(); ++it) {
+  for (ConsumerSet::iterator it = consumers_.begin(); it != consumers_.end();
+       ++it) {
     if (it->did_observe_user_gesture && it->is_active)
       it->consumer->OnGamepadDisconnected(index, pad);
   }
@@ -151,12 +145,12 @@ void GamepadService::OnGamepadDisconnected(
 
 base::SharedMemoryHandle GamepadService::GetSharedMemoryHandleForProcess(
     base::ProcessHandle handle) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(main_thread_task_runner_->BelongsToCurrentThread());
   return provider_->GetSharedMemoryHandleForProcess(handle);
 }
 
 mojo::ScopedSharedBufferHandle GamepadService::GetSharedBufferHandle() {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(main_thread_task_runner_->BelongsToCurrentThread());
 
   // TODO(heke): Use mojo::SharedBuffer rather than base::SharedMemory in
   // GamepadSharedBuffer. See crbug.com/670655 for details.
@@ -166,16 +160,15 @@ mojo::ScopedSharedBufferHandle GamepadService::GetSharedBufferHandle() {
 }
 
 void GamepadService::OnUserGesture() {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(main_thread_task_runner_->BelongsToCurrentThread());
 
   gesture_callback_pending_ = false;
 
-  if (!provider_ ||
-      num_active_consumers_ == 0)
+  if (!provider_ || num_active_consumers_ == 0)
     return;
 
-  for (ConsumerSet::iterator it = consumers_.begin();
-       it != consumers_.end(); ++it) {
+  for (ConsumerSet::iterator it = consumers_.begin(); it != consumers_.end();
+       ++it) {
     if (!it->did_observe_user_gesture && it->is_active) {
       const ConsumerInfo& info = *it;
       info.did_observe_user_gesture = true;
@@ -194,4 +187,4 @@ void GamepadService::SetSanitizationEnabled(bool sanitize) {
   provider_->SetSanitizationEnabled(sanitize);
 }
 
-}  // namespace content
+}  // namespace device

content/browser/gamepad/gamepad_service.h → device/gamepad/gamepad_service.h

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CONTENT_BROWSER_GAMEPAD_GAMEPAD_SERVICE_H_
-#define CONTENT_BROWSER_GAMEPAD_GAMEPAD_SERVICE_H_
+#ifndef DEVICE_GAMEPAD_GAMEPAD_SERVICE_H_
+#define DEVICE_GAMEPAD_GAMEPAD_SERVICE_H_
 
 #include <memory>
 #include <set>
@@ -12,29 +12,31 @@
 #include "base/macros.h"
 #include "base/memory/shared_memory.h"
 #include "base/memory/singleton.h"
-#include "base/threading/thread_checker.h"
-#include "content/common/content_export.h"
+#include "device/gamepad/gamepad_export.h"
 #include "device/gamepad/gamepad_provider.h"
 #include "mojo/public/cpp/system/buffer.h"
 
+namespace {
+class SingleThreadTaskRunner;
+}
+
 namespace blink {
 class WebGamepad;
 }
 
+namespace content {
+class GamepadServiceTestConstructor;
+}
+
 namespace device {
 class GamepadConsumer;
 class GamepadDataFetcher;
 class GamepadProvider;
-}
-
-namespace content {
-
-class GamepadServiceTestConstructor;
 
 // Owns the GamepadProvider (the background polling thread) and keeps track of
 // the number of consumers currently using the data (and pausing the provider
 // when not in use).
-class CONTENT_EXPORT GamepadService
+class DEVICE_GAMEPAD_EXPORT GamepadService
     : public device::GamepadConnectionChangeClient {
  public:
   // Returns the GamepadService singleton.
@@ -96,8 +98,7 @@ class CONTENT_EXPORT GamepadService
 
   // Constructor for testing. This specifies the data fetcher to use for a
   // provider, bypassing the default platform one.
-  GamepadService(
-      std::unique_ptr<device::GamepadDataFetcher> fetcher);
+  GamepadService(std::unique_ptr<device::GamepadDataFetcher> fetcher);
 
   virtual ~GamepadService();
 
@@ -126,7 +127,7 @@ class CONTENT_EXPORT GamepadService
 
   std::unique_ptr<device::GamepadProvider> provider_;
 
-  base::ThreadChecker thread_checker_;
+  scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner_;
 
   typedef std::set<ConsumerInfo> ConsumerSet;
   ConsumerSet consumers_;
@@ -140,4 +141,4 @@ class CONTENT_EXPORT GamepadService
 
 }  // namespace content
 
-#endif  // CONTENT_BROWSER_GAMEPAD_GAMEPAD_SERVICE_H_
+#endif  // DEVICE_GAMEPAD_GAMEPAD_SERVICE_H_

content/browser/gamepad/gamepad_service_unittest.cc → device/gamepad/gamepad_service_unittest.cc

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "content/browser/gamepad/gamepad_service.h"
+#include "device/gamepad/gamepad_service.h"
 
 #include <string.h>
 
@@ -10,12 +10,11 @@
 
 #include "base/macros.h"
 #include "base/run_loop.h"
-#include "content/public/test/test_browser_thread_bundle.h"
 #include "device/gamepad/gamepad_consumer.h"
 #include "device/gamepad/gamepad_test_helpers.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-namespace content {
+namespace device {
 
 namespace {
 static const int kNumberOfGamepads = blink::WebGamepads::itemsLengthCap;
@@ -25,9 +24,7 @@ using blink::WebGamepads;
 
 class ConnectionListener : public device::GamepadConsumer {
  public:
-  ConnectionListener() {
-    ClearCounters();
-  }
+  ConnectionListener() { ClearCounters(); }
 
   void OnGamepadConnected(unsigned index,
                           const blink::WebGamepad& gamepad) override {
@@ -69,17 +66,16 @@ class GamepadServiceTest : public testing::Test {
   void SetUp() override;
 
  private:
+  base::MessageLoop message_loop_;
   device::MockGamepadDataFetcher* fetcher_;
   GamepadService* service_;
   std::unique_ptr<ConnectionListener> connection_listener_;
-  TestBrowserThreadBundle browser_thread_;
   WebGamepads test_data_;
 
   DISALLOW_COPY_AND_ASSIGN(GamepadServiceTest);
 };
 
-GamepadServiceTest::GamepadServiceTest()
-    : browser_thread_(TestBrowserThreadBundle::IO_MAINLOOP) {
+GamepadServiceTest::GamepadServiceTest() {
   memset(&test_data_, 0, sizeof(test_data_));
 
   // Set it so that we have user gesture.
@@ -94,8 +90,8 @@ GamepadServiceTest::~GamepadServiceTest() {
 
 void GamepadServiceTest::SetUp() {
   fetcher_ = new device::MockGamepadDataFetcher(test_data_);
-  service_ = new GamepadService(
-      std::unique_ptr<device::GamepadDataFetcher>(fetcher_));
+  service_ =
+      new GamepadService(std::unique_ptr<device::GamepadDataFetcher>(fetcher_));
   connection_listener_.reset((new ConnectionListener));
   service_->SetSanitizationEnabled(false);
   service_->ConsumerBecameActive(connection_listener_.get());
@@ -134,4 +130,4 @@ TEST_F(GamepadServiceTest, ConnectionsTest) {
   EXPECT_EQ(0, GetDisconnectedCounter());
 }
 
-}  // namespace content
+}  // namespace device

content/browser/gamepad/gamepad_shared_buffer_impl.cc → device/gamepad/gamepad_shared_buffer.cc

@@ -2,45 +2,41 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "content/browser/gamepad/gamepad_shared_buffer_impl.h"
+#include "device/gamepad/gamepad_shared_buffer.h"
 
-#include "content/common/gamepad_hardware_buffer.h"
+namespace device {
 
-namespace content {
-
-GamepadSharedBufferImpl::GamepadSharedBufferImpl() {
+GamepadSharedBuffer::GamepadSharedBuffer() {
   size_t data_size = sizeof(GamepadHardwareBuffer);
   bool res = shared_memory_.CreateAndMapAnonymous(data_size);
   CHECK(res);
 
   void* mem = shared_memory_.memory();
   DCHECK(mem);
-  new (mem) GamepadHardwareBuffer();
+  hardware_buffer_ = new (mem) GamepadHardwareBuffer();
+  memset(&(hardware_buffer_->data), 0, sizeof(blink::WebGamepads));
 }
 
-GamepadSharedBufferImpl::~GamepadSharedBufferImpl() {
-}
+GamepadSharedBuffer::~GamepadSharedBuffer() {}
 
-base::SharedMemory* GamepadSharedBufferImpl::shared_memory() {
+base::SharedMemory* GamepadSharedBuffer::shared_memory() {
   return &shared_memory_;
 }
 
-blink::WebGamepads* GamepadSharedBufferImpl::buffer() {
-  return &(hardware_buffer()->buffer);
+blink::WebGamepads* GamepadSharedBuffer::buffer() {
+  return &(hardware_buffer()->data);
 }
 
-GamepadHardwareBuffer* GamepadSharedBufferImpl::hardware_buffer() {
-  void* mem = shared_memory_.memory();
-  DCHECK(mem);
-  return static_cast<GamepadHardwareBuffer*>(mem);
+GamepadHardwareBuffer* GamepadSharedBuffer::hardware_buffer() {
+  return hardware_buffer_;
 }
 
-void GamepadSharedBufferImpl::WriteBegin() {
-  hardware_buffer()->sequence.WriteBegin();
+void GamepadSharedBuffer::WriteBegin() {
+  hardware_buffer_->seqlock.WriteBegin();
 }
 
-void GamepadSharedBufferImpl::WriteEnd() {
-  hardware_buffer()->sequence.WriteEnd();
+void GamepadSharedBuffer::WriteEnd() {
+  hardware_buffer_->seqlock.WriteEnd();
 }
 
-}  // namespace content
+}  // namespace device

device/gamepad/gamepad_shared_buffer.h

@@ -6,20 +6,42 @@
 #define DEVICE_GAMEPAD_SHARED_BUFFER_H_
 
 #include "base/memory/shared_memory.h"
+#include "device/base/synchronization/shared_memory_seqlock_buffer.h"
 #include "device/gamepad/gamepad_export.h"
 #include "third_party/WebKit/public/platform/WebGamepads.h"
 
 namespace device {
 
+/*
+
+ GamepadHardwareBuffer is stored in shared memory that's shared between the
+ browser which does the hardware polling, and the various consumers of the
+ gamepad state (renderers and NaCl plugins). The performance characteristics are
+ that we want low latency (so would like to avoid explicit communication via IPC
+ between producer and consumer) and relatively large data size.
+
+ Writer and reader operate on the same buffer assuming contention is low, and
+ contention is detected by using the associated SeqLock.
+
+*/
+
+typedef SharedMemorySeqLockBuffer<blink::WebGamepads> GamepadHardwareBuffer;
+
 class DEVICE_GAMEPAD_EXPORT GamepadSharedBuffer {
  public:
-  virtual ~GamepadSharedBuffer() {}
+  GamepadSharedBuffer();
+  ~GamepadSharedBuffer();
+
+  base::SharedMemory* shared_memory();
+  blink::WebGamepads* buffer();
+  GamepadHardwareBuffer* hardware_buffer();
 
-  virtual base::SharedMemory* shared_memory() = 0;
-  virtual blink::WebGamepads* buffer() = 0;
+  void WriteBegin();
+  void WriteEnd();
 
-  virtual void WriteBegin() = 0;
-  virtual void WriteEnd() = 0;
+ private:
+  base::SharedMemory shared_memory_;
+  GamepadHardwareBuffer* hardware_buffer_;
 };
 
 }  // namespace device

device/gamepad/gamepad_test_helpers.cc

@@ -51,30 +51,19 @@ void MockGamepadDataFetcher::SetTestData(const blink::WebGamepads& new_data) {
   test_data_ = new_data;
 }
 
-MockGamepadSharedBuffer::MockGamepadSharedBuffer() {
-  size_t data_size = sizeof(blink::WebGamepads);
-  bool res = shared_memory_.CreateAndMapAnonymous(data_size);
-  CHECK(res);
-  blink::WebGamepads* buf = buffer();
-  memset(buf, 0, sizeof(blink::WebGamepads));
-}
+GamepadTestHelper::GamepadTestHelper() {}
 
-base::SharedMemory* MockGamepadSharedBuffer::shared_memory() {
-  return &shared_memory_;
-}
+GamepadTestHelper::~GamepadTestHelper() {}
 
-blink::WebGamepads* MockGamepadSharedBuffer::buffer() {
-  void* mem = shared_memory_.memory();
-  CHECK(mem);
-  return static_cast<blink::WebGamepads*>(mem);
+GamepadServiceTestConstructor::GamepadServiceTestConstructor(
+    const blink::WebGamepads& test_data) {
+  data_fetcher_ = new MockGamepadDataFetcher(test_data);
+  gamepad_service_ =
+      new GamepadService(std::unique_ptr<GamepadDataFetcher>(data_fetcher_));
 }
 
-void MockGamepadSharedBuffer::WriteBegin() {}
-
-void MockGamepadSharedBuffer::WriteEnd() {}
-
-GamepadTestHelper::GamepadTestHelper() {}
-
-GamepadTestHelper::~GamepadTestHelper() {}
+GamepadServiceTestConstructor::~GamepadServiceTestConstructor() {
+  delete gamepad_service_;
+}
 
 }  // namespace device

device/gamepad/gamepad_test_helpers.h

@@ -12,6 +12,7 @@
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "device/gamepad/gamepad_data_fetcher.h"
+#include "device/gamepad/gamepad_service.h"
 #include "device/gamepad/gamepad_shared_buffer.h"
 #include "third_party/WebKit/public/platform/WebGamepads.h"
 
@@ -51,22 +52,6 @@ class MockGamepadDataFetcher : public GamepadDataFetcher {
   DISALLOW_COPY_AND_ASSIGN(MockGamepadDataFetcher);
 };
 
-class MockGamepadSharedBuffer : public GamepadSharedBuffer {
- public:
-  MockGamepadSharedBuffer();
-
-  base::SharedMemory* shared_memory() override;
-  blink::WebGamepads* buffer() override;
-
-  void WriteBegin() override;
-  void WriteEnd() override;
-
- private:
-  base::SharedMemory shared_memory_;
-
-  DISALLOW_COPY_AND_ASSIGN(MockGamepadSharedBuffer);
-};
-
 // Base class for the other test helpers. This just sets up the system monitor.
 class GamepadTestHelper {
  public:
@@ -82,6 +67,26 @@ class GamepadTestHelper {
   DISALLOW_COPY_AND_ASSIGN(GamepadTestHelper);
 };
 
+// Constructs a GamepadService with a mock data source. This bypasses the
+// global singleton for the gamepad service.
+class GamepadServiceTestConstructor : public GamepadTestHelper {
+ public:
+  explicit GamepadServiceTestConstructor(const blink::WebGamepads& test_data);
+  ~GamepadServiceTestConstructor() override;
+
+  GamepadService* gamepad_service() { return gamepad_service_; }
+  MockGamepadDataFetcher* data_fetcher() { return data_fetcher_; }
+
+ private:
+  // Owning pointer (can't be a scoped_ptr due to private destructor).
+  GamepadService* gamepad_service_;
+
+  // Pointer owned by the provider (which is owned by the gamepad service).
+  MockGamepadDataFetcher* data_fetcher_;
+
+  DISALLOW_COPY_AND_ASSIGN(GamepadServiceTestConstructor);
+};
+
 }  // namespace device
 
 #endif  // DEVICE_GAMEPAD_GAMEPAD_TEST_HELPERS_H_

device/gamepad/public/interfaces/gamepad.mojom

@@ -57,7 +57,7 @@ interface GamepadObserver {
 
 // Asks the browser process to start polling, and return a shared memory
 // handle that will hold the data from the hardware. See
-// gamepad_hardware_buffer.h for a description of how synchronization is
+// gamepad_shared_buffer.h for a description of how synchronization is
 // handled. The number of Starts should match the number of Stops.
 interface GamepadMonitor {
   [Sync]

ppapi/shared_impl/ppb_gamepad_shared.h

@@ -109,7 +109,7 @@ struct WebKitGamepads {
 };
 
 // This is the structure store in shared memory. It must match
-// content/common/gamepad_hardware_buffer.h. The GamepadHost unit test has
+// device::GamepadHardwareBuffer. The GamepadHost unit test has
 // some compile asserts to validate this.
 struct ContentGamepadHardwareBuffer {
   base::subtle::Atomic32 sequence;