Implement Device Orientation using shared memory in content/renderer.

content/renderer/device_orientation/device_motion_event_pump.h

 // Copyright 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_RENDERER_DEVICE_MOTION_EVENT_PUMP_H_
 #define CONTENT_RENDERER_DEVICE_MOTION_EVENT_PUMP_H_
 
 #include "base/memory/scoped_ptr.h"
-#include "base/memory/shared_memory.h"
-#include "base/timer/timer.h"
-#include "content/public/renderer/render_process_observer.h"
+#include "content/renderer/device_orientation/device_sensor_event_pump.h"

[darin (slow to review), 2013/07/31 19:27:28]

Hmm, so "device sensor" is the term we are using as the generalization of device
motion and device orientation?  It seems like there are some other places in the
code where "device orientation" is used to contain things specific to "device
motion".  Should we standardize on using the term "device sensor" everywhere
applicable?  Is that your plan?  I realize it may take several CLs to implement
such a plan.

[timvolodine, 2013/08/01 15:31:36]

On the Blink side we have DeviceSensorEventController and
DeviceSensorEventDipatcher, so DeviceSensorEventPump seemed like a good option
here.

At some point Adam coined the term 'kinesthetics' e.g.
DeviceKinestheticsController, but I think it sounds a bit far fetched..

At the browser-side in content/browser/device_orientation/ I am planning to use
DeviceInertialSensorService as a generalized class to supply both
motion/orientation data.

In the chromium directory tree we have been using ../device_orientation/..,
probably because the spec is called 'DeviceOrientation Event Specification',
however it also covers motion and compass events.

So something like ../device_sensor/.. would probably be more sensible.
../device_inertial_sensor/.. sounds a bit too specific, although strictly
speaking covers our case (see
http://en.wikipedia.org/wiki/Inertial_measurement_unit).

So at this point I think I would prefer 'device sensor' as the main term (except
when it get close to the hardware where I would call it 'inertial sensor').

Does this make sense?

(maybe we can make this into a thread discussion.. anyway the renaming should
not delay this CL)

 #include "content/renderer/shared_memory_seqlock_reader.h"
 #include "third_party/WebKit/public/platform/WebDeviceMotionData.h"
 
 namespace WebKit {
 class WebDeviceMotionListener;
 }
 
 namespace content {
-class RenderThread;
 
 typedef SharedMemorySeqLockReader<WebKit::WebDeviceMotionData>
     DeviceMotionSharedMemoryReader;
 
-class CONTENT_EXPORT DeviceMotionEventPump : public RenderProcessObserver {
+class CONTENT_EXPORT DeviceMotionEventPump : public DeviceSensorEventPump {
  public:
   DeviceMotionEventPump();
+  explicit DeviceMotionEventPump(int pump_delay_millis);
   virtual ~DeviceMotionEventPump();
 
-  static double GetDelayMillis();
-
   // Sets the listener to receive updates for device motion data at
-  // regular intervals.
-  // Returns true if the registration was successful.
-  bool SetListener(WebKit::WebDeviceMotionListener*);
-
-  void SetDeviceMotionReader(scoped_ptr<DeviceMotionSharedMemoryReader>);
-
-  void Attach(RenderThread* thread);
+  // regular intervals. Returns true if the registration was successful.
+  bool SetListener(WebKit::WebDeviceMotionListener* listener);
 
   // RenderProcessObserver implementation.
   virtual bool OnControlMessageReceived(const IPC::Message& message) OVERRIDE;
 
  protected:
-  // Delay between subsequent firing of events.
-  static const double kPumpDelayMillis;
-
-  // The pump is a tri-state automaton with allowed transitions as follows:
-  // STOPPED -> PENDING_START
-  // PENDING_START -> RUNNING
-  // PENDING_START -> STOPPED
-  // RUNNING -> STOPPED
-  enum PumpState {
-      STOPPED,
-      RUNNING,
-      PENDING_START
-  };
-
-  bool StartFetchingDeviceMotion();
-  bool StopFetchingDeviceMotion();
-  void OnDidStartDeviceMotion(base::SharedMemoryHandle renderer_handle);
-  void FireEvent();
+  virtual void FireEvent() OVERRIDE;
+  virtual bool InitializeReader(base::SharedMemoryHandle handle) OVERRIDE;
+  virtual bool SendStartMessage() OVERRIDE;
+  virtual bool SendStopMessage() OVERRIDE;
 
   WebKit::WebDeviceMotionListener* listener_;
   scoped_ptr<DeviceMotionSharedMemoryReader> reader_;
-  base::RepeatingTimer<DeviceMotionEventPump> timer_;
-  PumpState state_;
 };
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_DEVICE_MOTION_EVENT_PUMP_H_