Implements part of DeviceMotion in the browser

This adds the motion message filter, motion ipc messages, and related motion
files. This was originally part of a larger patch
(http://codereview.chromium.org/10698046/).


BUG=59201


Review URL: https://chromiumcodereview.appspot.com/10823310

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@151908 0039d316-1c4b-4281-b951-d872f2087c98

content/browser/device_orientation/device_data.h

@@ -18,6 +18,7 @@ class CONTENT_EXPORT DeviceData :
     public base::RefCountedThreadSafe<DeviceData> {
  public:
   enum Type {
+    kTypeMotion,
     kTypeOrientation,
     kTypeTest
   };

content/browser/device_orientation/motion.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/device_orientation/motion.h"
+
+#include "content/common/device_motion_messages.h"
+
+namespace content {
+
+Motion::Motion()
+    : can_provide_acceleration_x_(false),
+      can_provide_acceleration_y_(false),
+      can_provide_acceleration_z_(false),
+      can_provide_acceleration_including_gravity_x_(false),
+      can_provide_acceleration_including_gravity_y_(false),
+      can_provide_acceleration_including_gravity_z_(false),
+      can_provide_rotation_rate_alpha_(false),
+      can_provide_rotation_rate_beta_(false),
+      can_provide_rotation_rate_gamma_(false),
+      can_provide_interval_(false) {
+}
+
+Motion::~Motion() {
+}
+
+IPC::Message* Motion::CreateIPCMessage(int render_view_id) const {
+  DeviceMotionMsg_Updated_Params params;
+
+  params.can_provide_acceleration_x = can_provide_acceleration_x_;
+  params.acceleration_x = acceleration_x_;
+  params.can_provide_acceleration_y = can_provide_acceleration_y_;
+  params.acceleration_y = acceleration_y_;
+  params.can_provide_acceleration_z = can_provide_acceleration_z_;
+  params.acceleration_z = acceleration_z_;
+
+  params.can_provide_acceleration_including_gravity_x =
+      can_provide_acceleration_including_gravity_x_;
+  params.acceleration_including_gravity_x = acceleration_including_gravity_x_;
+  params.can_provide_acceleration_including_gravity_y =
+      can_provide_acceleration_including_gravity_y_;
+  params.acceleration_including_gravity_y = acceleration_including_gravity_y_;
+  params.can_provide_acceleration_including_gravity_z =
+      can_provide_acceleration_including_gravity_z_;
+  params.acceleration_including_gravity_z = acceleration_including_gravity_z_;
+
+  params.can_provide_rotation_rate_alpha = can_provide_rotation_rate_alpha_;
+  params.rotation_rate_alpha = rotation_rate_alpha_;
+  params.can_provide_rotation_rate_beta = can_provide_rotation_rate_beta_;
+  params.rotation_rate_beta = rotation_rate_beta_;
+  params.can_provide_rotation_rate_gamma = can_provide_rotation_rate_gamma_;
+  params.rotation_rate_gamma = rotation_rate_gamma_;
+
+  params.can_provide_interval = can_provide_interval_;
+  params.interval = interval_;
+
+  return new DeviceMotionMsg_Updated(render_view_id, params);
+}
+
+// Should always fire new motion events so that they occur at regular intervals.
+// The firing frequency is determined by the polling frequency in ProviderImpl.
+bool Motion::ShouldFireEvent(const DeviceData* old_data) const {
+  return true;
+}
+
+};  // namespace content

content/browser/device_orientation/motion.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_DEVICE_ORIENTATION_MOTION_H_
+#define CONTENT_BROWSER_DEVICE_ORIENTATION_MOTION_H_
+
+#include "base/compiler_specific.h"
+#include "content/browser/device_orientation/device_data.h"
+#include "content/common/content_export.h"
+
+namespace content {
+
+class Motion : public DeviceData {
+ public:
+  // acceleration_x, acceleration_y, and acceleration_z are the accelerations
+  // excluding gravity along the axes specified in
+  // http://dev.w3.org/geo/api/spec-source-orientation.html
+
+  // acceleration_including_gravity_x, acceleration_including_gravity_y, and
+  // acceleration_including_gravity_z are the accelerations including gravity
+  // along the same axes as above
+
+  // rotation_rate_alpha, rotation_rate_beta, and rotataion_rate_gamma are the
+  // rotations around the same axes as above
+
+  // interval is the time interval at which data is obtained from the hardware,
+  // as specified in the document referenced above
+
+  // can_provide_{acceleration_x, acceleration_y, acceleration_z,
+  // acceleration_including_gravity_x, acceleration_including_gravity_y,
+  // acceleration_including_gravity_z, rotation_rate_alpha, rotation_rate_beta,
+  // rotation_rate_gamma, interval} is true if data can be provided for that
+  // variable
+  CONTENT_EXPORT Motion();
+
+  // From DeviceData.
+  virtual IPC::Message* CreateIPCMessage(int render_view_id) const OVERRIDE;
+  virtual bool ShouldFireEvent(const DeviceData* old_data) const OVERRIDE;
+
+  void set_acceleration_x(double acceleration_x) {
+    can_provide_acceleration_x_ = true;
+    acceleration_x_ = acceleration_x;
+  }
+  bool can_provide_acceleration_x() const {
+    return can_provide_acceleration_x_;
+  }
+  double acceleration_x() const { return acceleration_x_; }
+
+  void set_acceleration_y(double acceleration_y) {
+    can_provide_acceleration_y_ = true;
+    acceleration_y_ = acceleration_y;
+  }
+  bool can_provide_acceleration_y() const {
+    return can_provide_acceleration_y_;
+  }
+  double acceleration_y() const { return acceleration_y_; }
+
+  void set_acceleration_z(double acceleration_z) {
+    can_provide_acceleration_z_ = true;
+    acceleration_z_ = acceleration_z;
+  }
+  bool can_provide_acceleration_z() const {
+    return can_provide_acceleration_z_;
+  }
+  double acceleration_z() const { return acceleration_z_; }
+
+  void set_acceleration_including_gravity_x(
+      double acceleration_including_gravity_x) {
+    can_provide_acceleration_including_gravity_x_ = true;
+    acceleration_including_gravity_x_ = acceleration_including_gravity_x;
+  }
+  bool can_provide_acceleration_including_gravity_x() const {
+    return can_provide_acceleration_x_;
+  }
+  double acceleration_including_gravity_x() const {
+    return acceleration_including_gravity_x_;
+  }
+
+  void set_acceleration_including_gravity_y(
+      double acceleration_including_gravity_y) {
+    can_provide_acceleration_including_gravity_y_ = true;
+    acceleration_including_gravity_y_ = acceleration_including_gravity_y;
+  }
+  bool can_provide_acceleration_including_gravity_y() const {
+    return can_provide_acceleration_y_;
+  }
+  double acceleration_including_gravity_y() const {
+    return acceleration_including_gravity_y_;
+  }
+
+  void set_acceleration_including_gravity_z(
+      double acceleration_including_gravity_z) {
+    can_provide_acceleration_including_gravity_z_ = true;
+    acceleration_including_gravity_z_ = acceleration_including_gravity_z;
+  }
+  bool can_provide_acceleration_including_gravity_z() const {
+    return can_provide_acceleration_z_;
+  }
+  double acceleration_including_gravity_z() const {
+    return acceleration_including_gravity_z_;
+  }
+
+  void set_rotation_rate_alpha(double rotation_rate_alpha) {
+    can_provide_rotation_rate_alpha_ = true;
+    rotation_rate_alpha_ = rotation_rate_alpha;
+  }
+  bool can_provide_rotation_rate_alpha() const {
+    return can_provide_rotation_rate_alpha_;
+  }
+  double rotation_rate_alpha() const { return rotation_rate_alpha_; }
+
+  void set_rotation_rate_beta(double rotation_rate_beta) {
+    can_provide_rotation_rate_beta_ = true;
+    rotation_rate_beta_ = rotation_rate_beta;
+  }
+  bool can_provide_rotation_rate_beta() const {
+    return can_provide_rotation_rate_beta_;
+  }
+  double rotation_rate_beta() const { return rotation_rate_beta_; }
+
+  void set_rotation_rate_gamma(double rotation_rate_gamma) {
+    can_provide_rotation_rate_gamma_ = true;
+    rotation_rate_gamma_ = rotation_rate_gamma;
+  }
+  bool can_provide_rotation_rate_gamma() const {
+    return can_provide_rotation_rate_gamma_;
+  }
+  double rotation_rate_gamma() const { return rotation_rate_gamma_; }
+
+  void set_interval(double interval) {
+    can_provide_interval_ = true;
+    interval_ = interval;
+  }
+  bool can_provide_interval() const { return can_provide_interval_; }
+  double interval() const { return interval_; }
+
+ private:
+  virtual ~Motion();
+
+  double acceleration_x_;
+  double acceleration_y_;
+  double acceleration_z_;
+  double acceleration_including_gravity_x_;
+  double acceleration_including_gravity_y_;
+  double acceleration_including_gravity_z_;
+  double rotation_rate_alpha_;
+  double rotation_rate_beta_;
+  double rotation_rate_gamma_;
+  double interval_;
+  bool can_provide_acceleration_x_;
+  bool can_provide_acceleration_y_;
+  bool can_provide_acceleration_z_;
+  bool can_provide_acceleration_including_gravity_x_;
+  bool can_provide_acceleration_including_gravity_y_;
+  bool can_provide_acceleration_including_gravity_z_;
+  bool can_provide_rotation_rate_alpha_;
+  bool can_provide_rotation_rate_beta_;
+  bool can_provide_rotation_rate_gamma_;
+  bool can_provide_interval_;
+};
+
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_DEVICE_ORIENTATION_MOTION_H_

content/browser/device_orientation/motion_message_filter.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/device_orientation/motion_message_filter.h"
+
+#include "content/browser/device_orientation/device_data.h"
+#include "content/common/device_motion_messages.h"
+#include "content/public/browser/browser_thread.h"
+
+namespace content {
+
+MotionMessageFilter::MotionMessageFilter()
+    : MessageFilter(DeviceData::kTypeMotion) {
+}
+
+MotionMessageFilter::~MotionMessageFilter() {
+}
+
+bool MotionMessageFilter::OnMessageReceived(const IPC::Message& message,
+                                            bool* message_was_ok) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP_EX(MotionMessageFilter, message, *message_was_ok)
+    IPC_MESSAGE_HANDLER(DeviceMotionHostMsg_StartUpdating, OnStartUpdating)
+    IPC_MESSAGE_HANDLER(DeviceMotionHostMsg_StopUpdating, OnStopUpdating)
+    IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP()
+  return handled;
+}
+
+}  // namespace content

content/browser/device_orientation/motion_message_filter.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_DEVICE_ORIENTATION_MOTION_MESSAGE_FILTER_H_
+#define CONTENT_BROWSER_DEVICE_ORIENTATION_MOTION_MESSAGE_FILTER_H_
+
+#include <map>
+
+#include "content/browser/device_orientation/message_filter.h"
+
+namespace content {
+
+class MotionMessageFilter : public MessageFilter {
+ public:
+  MotionMessageFilter();
+
+  // MessageFilter implementation.
+  virtual bool OnMessageReceived(const IPC::Message& message,
+                                 bool* message_was_ok) OVERRIDE;
+
+ private:
+  virtual ~MotionMessageFilter();
+
+  DISALLOW_COPY_AND_ASSIGN(MotionMessageFilter);
+};
+
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_DEVICE_ORIENTATION_MOTION_MESSAGE_FILTER_H_

content/browser/device_orientation/observer_delegate.cc

@@ -6,6 +6,7 @@
 
 #include "base/logging.h"
 #include "content/browser/device_orientation/device_data.h"
+#include "content/browser/device_orientation/motion.h"
 #include "content/browser/device_orientation/orientation.h"
 #include "ipc/ipc_sender.h"
 
@@ -35,8 +36,16 @@ void ObserverDelegate::OnDeviceDataUpdate(
 }
 
 DeviceData* ObserverDelegate::EmptyDeviceData(DeviceData::Type type) {
-  DCHECK(type == DeviceData::kTypeOrientation);
-  return new Orientation();
+  switch (type) {
+    case DeviceData::kTypeMotion:
+      return new Motion();
+    case DeviceData::kTypeOrientation:
+      return new Orientation();
+    case DeviceData::kTypeTest:
+      NOTREACHED();
+  }
+  NOTREACHED();
+  return NULL;
 }
 
 }  // namespace content

content/browser/device_orientation/orientation_message_filter.h

@@ -15,7 +15,7 @@ class OrientationMessageFilter : public MessageFilter {
  public:
   OrientationMessageFilter();
 
-  // content::BrowserMessageFilter implementation.
+  // MessageFilter implementation.
   virtual bool OnMessageReceived(const IPC::Message& message,
                                  bool* message_was_ok) OVERRIDE;
 

content/browser/device_orientation/provider_unittest.cc

@@ -9,6 +9,7 @@
 #include "base/synchronization/lock.h"
 #include "content/browser/device_orientation/data_fetcher.h"
 #include "content/browser/device_orientation/device_data.h"
+#include "content/browser/device_orientation/motion.h"
 #include "content/browser/device_orientation/orientation.h"
 #include "content/browser/device_orientation/provider.h"
 #include "content/browser/device_orientation/provider_impl.h"
@@ -70,6 +71,90 @@ class UpdateChecker : public Provider::Observer {
   std::queue<scoped_refptr<const DeviceData> > expectations_queue_;
 };
 
+// Class for checking expectations on motion updates from the Provider.
+class MotionUpdateChecker : public UpdateChecker {
+ public:
+  explicit MotionUpdateChecker(int* expectations_count_ptr)
+      : UpdateChecker(DeviceData::kTypeMotion, expectations_count_ptr) {
+  }
+
+  virtual ~MotionUpdateChecker() {}
+
+  // From UpdateChecker.
+  virtual void OnDeviceDataUpdate(const DeviceData* device_data,
+      DeviceData::Type device_data_type) OVERRIDE {
+    ASSERT_FALSE(expectations_queue_.empty());
+    ASSERT_EQ(DeviceData::kTypeMotion, device_data_type);
+
+    scoped_refptr<const Motion> motion(static_cast<const Motion*>(device_data));
+    if (motion == NULL)
+      motion = new Motion();
+
+    scoped_refptr<const Motion> expected(static_cast<const Motion*>(
+        (expectations_queue_.front().get())));
+    expectations_queue_.pop();
+
+    EXPECT_EQ(expected->can_provide_acceleration_x(),
+              motion->can_provide_acceleration_x());
+    EXPECT_EQ(expected->can_provide_acceleration_y(),
+              motion->can_provide_acceleration_y());
+    EXPECT_EQ(expected->can_provide_acceleration_z(),
+              motion->can_provide_acceleration_z());
+
+    EXPECT_EQ(expected->can_provide_acceleration_including_gravity_x(),
+              motion->can_provide_acceleration_including_gravity_x());
+    EXPECT_EQ(expected->can_provide_acceleration_including_gravity_y(),
+              motion->can_provide_acceleration_including_gravity_y());
+    EXPECT_EQ(expected->can_provide_acceleration_including_gravity_z(),
+              motion->can_provide_acceleration_including_gravity_z());
+
+    EXPECT_EQ(expected->can_provide_rotation_rate_alpha(),
+              motion->can_provide_rotation_rate_alpha());
+    EXPECT_EQ(expected->can_provide_rotation_rate_beta(),
+              motion->can_provide_rotation_rate_beta());
+    EXPECT_EQ(expected->can_provide_rotation_rate_gamma(),
+              motion->can_provide_rotation_rate_gamma());
+
+    EXPECT_EQ(expected->can_provide_interval(), motion->can_provide_interval());
+
+    if (expected->can_provide_acceleration_x())
+      EXPECT_EQ(expected->acceleration_x(), motion->acceleration_x());
+    if (expected->can_provide_acceleration_y())
+      EXPECT_EQ(expected->acceleration_y(), motion->acceleration_y());
+    if (expected->can_provide_acceleration_z())
+      EXPECT_EQ(expected->acceleration_z(), motion->acceleration_z());
+
+    if (expected->can_provide_acceleration_including_gravity_x())
+      EXPECT_EQ(expected->acceleration_including_gravity_x(),
+                motion->acceleration_including_gravity_x());
+    if (expected->can_provide_acceleration_including_gravity_y())
+      EXPECT_EQ(expected->acceleration_including_gravity_y(),
+                motion->acceleration_including_gravity_y());
+    if (expected->can_provide_acceleration_including_gravity_z())
+      EXPECT_EQ(expected->acceleration_including_gravity_z(),
+                motion->acceleration_including_gravity_z());
+
+    if (expected->can_provide_rotation_rate_alpha())
+      EXPECT_EQ(expected->rotation_rate_alpha(),
+                motion->rotation_rate_alpha());
+    if (expected->can_provide_rotation_rate_beta())
+      EXPECT_EQ(expected->rotation_rate_beta(),
+                motion->rotation_rate_beta());
+    if (expected->can_provide_rotation_rate_gamma())
+      EXPECT_EQ(expected->rotation_rate_gamma(),
+                motion->rotation_rate_gamma());
+
+    if (expected->can_provide_interval())
+      EXPECT_EQ(expected->interval(), motion->interval());
+
+    --(*expectations_count_ptr_);
+
+    if (*expectations_count_ptr_ == 0) {
+      MessageLoop::current()->PostTask(FROM_HERE, MessageLoop::QuitClosure());
+    }
+  }
+};
+
 // Class for checking expectations on orientation updates from the Provider.
 class OrientationUpdateChecker : public UpdateChecker {
  public:
@@ -523,7 +608,43 @@ TEST_F(DeviceOrientationProviderTest, StartStopStart) {
   MockDeviceDataFactory::SetCurInstance(NULL);
 }
 
-// Tests that Orientation events only fire if the change is significant
+// Tests that Motion events always fire, even if the motion is unchanged.
+TEST_F(DeviceOrientationProviderTest, MotionAlwaysFires) {
+  scoped_refptr<MockDeviceDataFactory> device_data_factory(
+      new MockDeviceDataFactory());
+  MockDeviceDataFactory::SetCurInstance(device_data_factory.get());
+  Init(MockDeviceDataFactory::CreateDataFetcher);
+
+  scoped_refptr<Motion> test_motion(new Motion());
+  test_motion->set_acceleration_x(1);
+  test_motion->set_acceleration_y(2);
+  test_motion->set_acceleration_z(3);
+  test_motion->set_acceleration_including_gravity_x(4);
+  test_motion->set_acceleration_including_gravity_y(5);
+  test_motion->set_acceleration_including_gravity_z(6);
+  test_motion->set_rotation_rate_alpha(7);
+  test_motion->set_rotation_rate_beta(8);
+  test_motion->set_rotation_rate_gamma(9);
+  test_motion->set_interval(10);
+
+  scoped_ptr<MotionUpdateChecker> checker(new MotionUpdateChecker(
+      &pending_expectations_));
+
+  device_data_factory->SetDeviceData(test_motion, DeviceData::kTypeMotion);
+  checker->AddExpectation(test_motion);
+  provider_->AddObserver(checker.get());
+  MessageLoop::current()->Run();
+
+  // The observer should receive the same motion again.
+  device_data_factory->SetDeviceData(test_motion, DeviceData::kTypeMotion);
+  checker->AddExpectation(test_motion);
+  MessageLoop::current()->Run();
+
+  provider_->RemoveObserver(checker.get());
+  MockDeviceDataFactory::SetCurInstance(NULL);
+}
+
+// Tests that Orientation events only fire if the change is significant.
 TEST_F(DeviceOrientationProviderTest, OrientationSignificantlyDifferent) {
   scoped_refptr<MockDeviceDataFactory> device_data_factory(
       new MockDeviceDataFactory());

content/common/content_message_generator.h

@@ -12,6 +12,7 @@
 #include "content/common/clipboard_messages.h"
 #include "content/common/database_messages.h"
 #include "content/common/desktop_notification_messages.h"
+#include "content/common/device_motion_messages.h"
 #include "content/common/device_orientation_messages.h"
 #include "content/common/devtools_messages.h"
 #include "content/common/dom_storage_messages.h"

content/common/device_motion_messages.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.
+
+// IPC messages for device motion.
+// Multiply-included message file, hence no include guard.
+
+#include "ipc/ipc_message_macros.h"
+
+#define IPC_MESSAGE_START DeviceMotionMsgStart
+
+IPC_STRUCT_BEGIN(DeviceMotionMsg_Updated_Params)
+  // These fields have the same meaning as in device_motion::Motion.
+  IPC_STRUCT_MEMBER(bool, can_provide_acceleration_x)
+  IPC_STRUCT_MEMBER(double, acceleration_x)
+  IPC_STRUCT_MEMBER(bool, can_provide_acceleration_y)
+  IPC_STRUCT_MEMBER(double, acceleration_y)
+  IPC_STRUCT_MEMBER(bool, can_provide_acceleration_z)
+  IPC_STRUCT_MEMBER(double, acceleration_z)
+  IPC_STRUCT_MEMBER(bool, can_provide_acceleration_including_gravity_x)
+  IPC_STRUCT_MEMBER(double, acceleration_including_gravity_x)
+  IPC_STRUCT_MEMBER(bool, can_provide_acceleration_including_gravity_y)
+  IPC_STRUCT_MEMBER(double, acceleration_including_gravity_y)
+  IPC_STRUCT_MEMBER(bool, can_provide_acceleration_including_gravity_z)
+  IPC_STRUCT_MEMBER(double, acceleration_including_gravity_z)
+  IPC_STRUCT_MEMBER(bool, can_provide_rotation_rate_alpha)
+  IPC_STRUCT_MEMBER(double, rotation_rate_alpha)
+  IPC_STRUCT_MEMBER(bool, can_provide_rotation_rate_beta)
+  IPC_STRUCT_MEMBER(double, rotation_rate_beta)
+  IPC_STRUCT_MEMBER(bool, can_provide_rotation_rate_gamma)
+  IPC_STRUCT_MEMBER(double, rotation_rate_gamma)
+  IPC_STRUCT_MEMBER(bool, can_provide_interval)
+  IPC_STRUCT_MEMBER(double, interval)
+IPC_STRUCT_END()
+
+// Messages sent from the browser to the renderer.
+
+// Notification that the device's motion has changed.
+IPC_MESSAGE_ROUTED1(DeviceMotionMsg_Updated,
+                    DeviceMotionMsg_Updated_Params)
+
+// Messages sent from the renderer to the browser.
+
+// A RenderView requests to start receiving device motion updates.
+IPC_MESSAGE_CONTROL1(DeviceMotionHostMsg_StartUpdating,
+                     int /* render_view_id */)
+
+// A RenderView requests to stop receiving device motion updates.
+IPC_MESSAGE_CONTROL1(DeviceMotionHostMsg_StopUpdating,
+                     int /* render_view_id */)

content/content_browser.gypi

@@ -288,12 +288,16 @@
     'browser/device_orientation/device_data.h',
     'browser/device_orientation/message_filter.cc',
     'browser/device_orientation/message_filter.h',
+    'browser/device_orientation/motion.cc',
+    'browser/device_orientation/motion.h',
+    'browser/device_orientation/motion_message_filter.cc',
+    'browser/device_orientation/motion_message_filter.h',
     'browser/device_orientation/observer_delegate.cc',
     'browser/device_orientation/observer_delegate.h',
-    'browser/device_orientation/orientation_message_filter.cc',
-    'browser/device_orientation/orientation_message_filter.h',
     'browser/device_orientation/orientation.cc',
     'browser/device_orientation/orientation.h',
+    'browser/device_orientation/orientation_message_filter.cc',
+    'browser/device_orientation/orientation_message_filter.h',
     'browser/device_orientation/provider.cc',
     'browser/device_orientation/provider.h',
     'browser/device_orientation/provider_impl.cc',

content/content_common.gypi

@@ -156,6 +156,7 @@
     'common/debug_flags.cc',
     'common/debug_flags.h',
     'common/desktop_notification_messages.h',
+    'common/device_motion_messages.h',
     'common/device_orientation_messages.h',
     'common/devtools_messages.h',
     'common/dom_storage_messages.h',

ipc/ipc_message_utils.h

@@ -78,6 +78,7 @@ enum IPCMessageStart {
   ClipboardMsgStart,
   BlobMsgStart,
   AppCacheMsgStart,
+  DeviceMotionMsgStart,
   DeviceOrientationMsgStart,
   DesktopNotificationMsgStart,
   GeolocationMsgStart,