Implement the content/renderer and content/browser part of the Device Motion API.

content/renderer/shared_memory_seqlock_reader.cc

+// Copyright (c) 2013 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 "shared_memory_seqlock_reader.h"
+
+namespace internal {
+
+content::SharedMemorySeqLockBufferBase*
+SharedMemorySeqLockReaderBase::InitializeSharedMemory(
+    base::SharedMemoryHandle shared_memory_handle, size_t buffer_size) {
+  renderer_shared_memory_handle_ = shared_memory_handle;
+  if (!base::SharedMemory::IsHandleValid(renderer_shared_memory_handle_))
+    return 0;
+  renderer_shared_memory_.reset(new base::SharedMemory(
+      renderer_shared_memory_handle_, true));
+  if (renderer_shared_memory_->Map(buffer_size)) {
+    base_buffer_ = static_cast<content::SharedMemorySeqLockBufferBase*>(
+        renderer_shared_memory_->memory());
+    return base_buffer_;
+  }
+  return 0;
+}
+
+bool SharedMemorySeqLockReaderBase::FetchFromBuffer(

[darin (slow to review), 2013/06/27 17:33:26]

Is there a path to changing GamepadSharedMemoryReader to use
SharedMemorySeqLockReader<T> too?  Are you saving that for a separate CL?

[timvolodine, 2013/06/27 21:08:43]

Yes, I think this is best done in a separate CL. If the refactoring happens to
break Gamepad it would also be easier to revert.

As to the refactoring of the gamepad, the idea is to call
SharedMemorySeqLockReader from GamepadSharedMemoryReader at appropriate places.
The GamepadSharedMemoryReader itself will probably still need to exist because
there is some gamepad-specific code like for handling gestures..

+    void* final, void* temp, void* from, size_t size) {
+
+  if (!base::SharedMemory::IsHandleValid(renderer_shared_memory_handle_))
+    return false;
+
+  // Only try to read this many times before failing to avoid waiting here
+  // very long in case of contention with the writer.
+  int contention_count = -1;
+  base::subtle::Atomic32 version;
+  do {
+    version = base_buffer_->seqlock.ReadBegin();
+    memcpy(temp, from, size);
+    ++contention_count;
+    if (contention_count == kMaximumContentionCount)
+      break;
+  } while (base_buffer_->seqlock.ReadRetry(version));
+
+  if (contention_count >= kMaximumContentionCount) {
+    // We failed to successfully read, presumably because the hardware
+    // thread was taking unusually long. Don't copy the data to the output
+    // buffer, and simply leave what was there before.
+    return false;
+  }
+
+  // New data was read successfully, copy it into the output buffer.
+  memcpy(final, temp, size);
+  return true;
+}
+
+}  // namespace internal