Implements part of Device Motion in the Renderer

content/browser/device_orientation/provider_unittest.cc

Index: content/browser/device_orientation/provider_unittest.cc
diff --git a/content/browser/device_orientation/provider_unittest.cc b/content/browser/device_orientation/provider_unittest.cc
index a80b0353591e29db98e5aac342f99ec5a10a14bb..dbcf1d15c6a7086dc05804248b860dd9aea43c07 100644
--- a/content/browser/device_orientation/provider_unittest.cc
+++ b/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.

[hans, 2012/08/13 13:35:19]

i was just about to ask for a test like that :)

+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());