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

content/browser/device_orientation/device_motion_service.h

Index: content/browser/device_orientation/device_motion_service.h
diff --git a/content/browser/device_orientation/device_motion_service.h b/content/browser/device_orientation/device_motion_service.h
new file mode 100644
index 0000000000000000000000000000000000000000..ea2ea9a9f78b4c1bd47695d3b7b01156bc783761
--- /dev/null
+++ b/content/browser/device_orientation/device_motion_service.h
@@ -0,0 +1,64 @@
+// 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.
+
+#ifndef CONTENT_BROWSER_DEVICE_ORIENTATION_DEVICE_MOTION_SERVICE_H_
+#define CONTENT_BROWSER_DEVICE_ORIENTATION_DEVICE_MOTION_SERVICE_H_
+
+#include "base/basictypes.h"
+#include "base/callback_forward.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/memory/singleton.h"
+#include "base/shared_memory.h"
+#include "base/threading/thread_checker.h"
+#include "content/common/content_export.h"
+
+namespace content {
+
+class DataFetcherSharedMemory;
+class DeviceMotionProvider;
+class RenderProcessHost;
+
+// Owns the DeviceMotionProvider (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 DeviceMotionService {
+ public:
+  // Returns the DeviceMotionService singleton.
+  static DeviceMotionService* GetInstance();
+
+  // Increments the number of users of the provider. The Provider is running
+  // when there's > 0 users, and is paused when the count drops to 0.
+  //
+  // Must be called on the I/O thread.
+  void AddConsumer();
+
+  // Removes a consumer. Should be matched with an AddConsumer call.
+  //
+  // Must be called on the I/O thread.
+  void RemoveConsumer();
+
+  // Returns the shared memory handle of the device motion data duplicated
+  // into the given process.
+  base::SharedMemoryHandle GetSharedMemoryHandleForProcess(
+      base::ProcessHandle handle);
+
+  // Stop/join with the background thread in DeviceMotionProvider |provider_|.
+  void Terminate();

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

I'm trying to understand this method.  It looks like the idea is that you could
have cases where you have existing consumers but you want to interrupt or stop
the background thread.  Is that right?  Can you help me understand when this
gets used?

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

This method comes from a similar class for gamepad. It is called from
BrowserMainLoop::ShutdownThreadsAndCleanUp. I've added a Terminate() call to the
DeviceMotionService there. It is my understanding that the idea here is to
cleanly terminate all running threads and sensors when the Browser process shuts
down and there are still some existing consumers. In the current implementation
for Android there is no polling thread because Android is push-based and the
fetcher writes to the buffer directly without any need for browser-side polling.
However it is still beneficial to terminate the fetcher (and the sensors) in a
predictable fashion just after the I/O browser thread shuts down. Otherwise it
is not exactly clear when the destructor for fetcher will be called since
DeviceMotionService is a singleton.

+
+ private:
+  friend struct DefaultSingletonTraits<DeviceMotionService>;
+
+  DeviceMotionService();
+  virtual ~DeviceMotionService();
+
+  int num_readers_;
+  scoped_ptr<DeviceMotionProvider> provider_;
+  base::ThreadChecker thread_checker_;
+
+  DISALLOW_COPY_AND_ASSIGN(DeviceMotionService);
+};
+
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_DEVICE_ORIENTATION_DEVICE_MOTION_SERVICE_H_