Move gamepad_service out of content/ and into device/

device/gamepad/gamepad_provider_unittest.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 "device/gamepad/gamepad_provider.h"
 
 #include <memory>
 
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
@@ skipping 27 matching lines @@
   bool has_user_gesture_;
   base::WeakPtrFactory<UserGestureListener> weak_factory_;
 };
 
 // Main test fixture
 class GamepadProviderTest : public testing::Test, public GamepadTestHelper {
  public:
   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();
   }
 
  protected:
   GamepadProviderTest() {}
 
   std::unique_ptr<GamepadProvider> provider_;
 
   // Pointer owned by the provider.
   MockGamepadDataFetcher* mock_data_fetcher_;
 
   DISALLOW_COPY_AND_ASSIGN(GamepadProviderTest);
 };
 
 // Crashes. http://crbug.com/106163
 // crbug.com/147549
 #if defined(OS_ANDROID)
 #define MAYBE_PollingAccess DISABLED_PollingAccess
 #else
 #define MAYBE_PollingAccess PollingAccess
 #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;
   test_data.items[0].buttonsLength = 1;
   test_data.items[0].axesLength = 2;
   test_data.items[0].buttons[0].value = 1.f;
   test_data.items[0].buttons[0].pressed = true;
   test_data.items[0].axes[0] = -1.f;
   test_data.items[0].axes[1] = .5f;
 
   GamepadProvider* provider = CreateProvider(test_data);
   provider->SetSanitizationEnabled(false);
   provider->Resume();
 
   base::RunLoop().RunUntilIdle();
 
   mock_data_fetcher_->WaitForDataRead();
 
   // Renderer-side, pull data out of poll buffer.
   base::SharedMemoryHandle handle = provider->GetSharedMemoryHandleForProcess(
       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);
+  WebGamepads output;
+  memset(&output, 0, sizeof(WebGamepads));
+  GamepadHardwareBuffer* buffer =
+      static_cast<GamepadHardwareBuffer*>(shared_memory->memory());
+  base::subtle::Atomic32 version;
+  do {

[ke.he, 2016/12/09 07:44:55]

Before this patch, it is the "MockGamepadSharedBuffer" that the provider holds,
so here we can get shared memory contents directly.
In this patch, the provider creates a "real" GamepadSharedBuffer by default in
its constructor, so we have to deal with the seqlock read operations.

[blundell, 2016/12/09 13:35:22]

Seems like it would be worthwhile to make a helper function for this given that
it's repeated several times.

[ke.he, 2016/12/09 15:15:22]

Done.

+    version = buffer->seqlock.ReadBegin();
+    memcpy(&output, &buffer->data, sizeof(WebGamepads));
+  } while (buffer->seqlock.ReadRetry(version));
 
-  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_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.
 TEST_F(GamepadProviderTest, UserGesture) {
   WebGamepads no_button_data;
   no_button_data.length = 1;
   no_button_data.items[0].connected = true;
   no_button_data.items[0].timestamp = 0;
   no_button_data.items[0].buttonsLength = 1;
   no_button_data.items[0].axesLength = 2;
@@ skipping 66 matching lines @@
 
   base::RunLoop().RunUntilIdle();
 
   mock_data_fetcher_->WaitForDataRead();
 
   // Renderer-side, pull data out of poll buffer.
   base::SharedMemoryHandle handle = provider->GetSharedMemoryHandleForProcess(
       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);
+  WebGamepads output;
+  memset(&output, 0, sizeof(WebGamepads));
+  GamepadHardwareBuffer* buffer =
+      static_cast<GamepadHardwareBuffer*>(shared_memory->memory());
+  base::subtle::Atomic32 version;
+  do {
+    version = buffer->seqlock.ReadBegin();
+    memcpy(&output, &buffer->data, sizeof(WebGamepads));
+  } while (buffer->seqlock.ReadRetry(version));
 
   // 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
+  memset(&output, 0, sizeof(WebGamepads));
+  do {
+    version = buffer->seqlock.ReadBegin();
+    memcpy(&output, &buffer->data, sizeof(WebGamepads));
+  } while (buffer->seqlock.ReadRetry(version));
+
   // 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
+  memset(&output, 0, sizeof(WebGamepads));
+  do {
+    version = buffer->seqlock.ReadBegin();
+    memcpy(&output, &buffer->data, sizeof(WebGamepads));
+  } while (buffer->seqlock.ReadRetry(version));
+
   // 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
 
 }  // namespace device