[sensors][win] Implementation of motion sensors for Win platform

device/generic_sensor/platform_sensor_and_provider_unittest_win.cc

Index: device/generic_sensor/platform_sensor_and_provider_unittest_win.cc
diff --git a/device/generic_sensor/platform_sensor_and_provider_unittest_win.cc b/device/generic_sensor/platform_sensor_and_provider_unittest_win.cc
index f0f44bd71c442f3767c5adfb4b824638f4af2bf5..12ddf4229d7079d71dccbb76df91ec5d9c5e86b6 100644
--- a/device/generic_sensor/platform_sensor_and_provider_unittest_win.cc
+++ b/device/generic_sensor/platform_sensor_and_provider_unittest_win.cc
@@ -20,8 +20,10 @@ using ::testing::IsNull;
 using ::testing::NiceMock;
 using ::testing::NotNull;
 using ::testing::Return;
+using ::testing::WithArgs;
 
 namespace device {
+
 using mojom::SensorType;
 
 template <class Interface>
@@ -296,9 +298,18 @@ class PlatformSensorAndProviderTestWin : public ::testing::Test {
     sensor_events_->OnStateChanged(sensor_.get(), state);
   }
 
+  struct PropertyKeyCompare {
+    bool operator()(REFPROPERTYKEY a, REFPROPERTYKEY b) const {
+      if (a.fmtid == b.fmtid)
+        return a.pid < b.pid;
+      return false;
+    }
+  };
+  using SensorData = std::map<PROPERTYKEY, double, PropertyKeyCompare>;
+
   // Generates OnDataUpdated event and creates ISensorDataReport with fake
   // |value| for property with |key|.
-  void GenerateDataUpdatedEvent(REFPROPERTYKEY key, double value) {
+  void GenerateDataUpdatedEvent(const SensorData& values) {
     if (!sensor_events_)
       return;
 
@@ -317,12 +328,17 @@ class PlatformSensorAndProviderTestWin : public ::testing::Test {
           return S_OK;
         }));
 
-    EXPECT_CALL(*mock_report, GetSensorValue(key, _))
-        .WillOnce(Invoke([value](REFPROPERTYKEY, PROPVARIANT* variant) {
-          variant->vt = VT_R8;
-          variant->dblVal = value;
-          return S_OK;
-        }));
+    EXPECT_CALL(*mock_report, GetSensorValue(_, _))
+        .WillRepeatedly(WithArgs<0, 1>(
+            Invoke([&values](REFPROPERTYKEY key, PROPVARIANT* variant) {
+              auto it = values.find(key);
+              if (it == values.end())
+                return E_FAIL;
+
+              variant->vt = VT_R8;
+              variant->dblVal = (*it).second;

[Mikhail, 2016/11/09 10:42:58]

nit: it->second

[shalamov, 2016/11/10 13:38:09]

Done.

+              return S_OK;
+            })));
 
     sensor_events_->OnDataUpdated(sensor_.get(), data_report.get());
   }
@@ -367,10 +383,9 @@ class MockPlatformSensorClient : public PlatformSensor::Client {
 // Tests that PlatformSensorManager returns null sensor when sensor
 // is not implemented.
 TEST_F(PlatformSensorAndProviderTestWin, SensorIsNotImplemented) {
-  EXPECT_CALL(*sensor_manager_,
-              GetSensorsByType(SENSOR_TYPE_ACCELEROMETER_3D, _))
+  EXPECT_CALL(*sensor_manager_, GetSensorsByType(SENSOR_TYPE_PRESSURE, _))
       .Times(0);
-  EXPECT_FALSE(CreateSensor(SensorType::ACCELEROMETER));
+  EXPECT_FALSE(CreateSensor(SensorType::PRESSURE));
 }
 
 // Tests that PlatformSensorManager returns null sensor when sensor
@@ -436,7 +451,7 @@ TEST_F(PlatformSensorAndProviderTestWin, SensorStarted) {
   EXPECT_TRUE(sensor->StartListening(client.get(), configuration));
 
   EXPECT_CALL(*client, OnSensorReadingChanged()).Times(1);
-  GenerateDataUpdatedEvent(SENSOR_DATA_TYPE_LIGHT_LEVEL_LUX, 3.14);
+  GenerateDataUpdatedEvent({{SENSOR_DATA_TYPE_LIGHT_LEVEL_LUX, 3.14}});
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(sensor->StopListening(client.get(), configuration));
 }
@@ -486,4 +501,112 @@ TEST_F(PlatformSensorAndProviderTestWin, SensorStateChangedToReady) {
   base::RunLoop().RunUntilIdle();
 }
 
+// Tests that Accelerometer readings are correctly converted.
+TEST_F(PlatformSensorAndProviderTestWin, CheckAccelerometerReadingConversion) {
+  mojo::ScopedSharedBufferHandle handle =
+      PlatformSensorProviderWin::GetInstance()->CloneSharedBufferHandle();
+  mojo::ScopedSharedBufferMapping mapping = handle->MapAtOffset(
+      sizeof(SensorReadingSharedBuffer),
+      SensorReadingSharedBuffer::GetOffset(SensorType::ACCELEROMETER));
+
+  SetSupportedSensor(SENSOR_TYPE_ACCELEROMETER_3D);
+  auto sensor = CreateSensor(SensorType::ACCELEROMETER);
+  EXPECT_TRUE(sensor);
+
+  auto client = base::MakeUnique<NiceMock<MockPlatformSensorClient>>(sensor);
+  PlatformSensorConfiguration configuration(10);
+  EXPECT_TRUE(sensor->StartListening(client.get(), configuration));
+
+  // Should not be called for sensors with CONTINUOUS reporting mode.
+  EXPECT_CALL(*client, OnSensorReadingChanged()).Times(0);
+
+  double gravity = 9.80665;
+  double x_accel = 0.25;
+  double y_accel = -0.25;
+  double z_accel = -0.5;
+  GenerateDataUpdatedEvent({{SENSOR_DATA_TYPE_ACCELERATION_X_G, x_accel},
+                            {SENSOR_DATA_TYPE_ACCELERATION_Y_G, y_accel},
+                            {SENSOR_DATA_TYPE_ACCELERATION_Z_G, z_accel}});
+
+  SensorReadingSharedBuffer* buffer =
+      static_cast<SensorReadingSharedBuffer*>(mapping.get());
+  EXPECT_THAT(buffer->reading.values[0], -x_accel * gravity);
+  EXPECT_THAT(buffer->reading.values[1], -y_accel * gravity);
+  EXPECT_THAT(buffer->reading.values[2], -z_accel * gravity);
+  EXPECT_TRUE(sensor->StopListening(client.get(), configuration));
+}
+
+// Tests that Gyroscope readings are correctly converted.
+TEST_F(PlatformSensorAndProviderTestWin, CheckGyroscopeReadingConversion) {
+  mojo::ScopedSharedBufferHandle handle =
+      PlatformSensorProviderWin::GetInstance()->CloneSharedBufferHandle();
+  mojo::ScopedSharedBufferMapping mapping = handle->MapAtOffset(
+      sizeof(SensorReadingSharedBuffer),
+      SensorReadingSharedBuffer::GetOffset(SensorType::GYROSCOPE));
+
+  SetSupportedSensor(SENSOR_TYPE_GYROMETER_3D);
+  auto sensor = CreateSensor(SensorType::GYROSCOPE);
+  EXPECT_TRUE(sensor);
+
+  auto client = base::MakeUnique<NiceMock<MockPlatformSensorClient>>(sensor);
+  PlatformSensorConfiguration configuration(10);
+  EXPECT_TRUE(sensor->StartListening(client.get(), configuration));
+  EXPECT_CALL(*client, OnSensorReadingChanged()).Times(0);
+
+  double rad_in_deg = 0.0174533;
+  double x_ang_accel = 0.0;
+  double y_ang_accel = -1.8;
+  double z_ang_accel = -98.7;
+
+  GenerateDataUpdatedEvent(
+      {{SENSOR_DATA_TYPE_ANGULAR_ACCELERATION_X_DEGREES_PER_SECOND_SQUARED,
+        x_ang_accel},
+       {SENSOR_DATA_TYPE_ANGULAR_ACCELERATION_Y_DEGREES_PER_SECOND_SQUARED,
+        y_ang_accel},
+       {SENSOR_DATA_TYPE_ANGULAR_ACCELERATION_Z_DEGREES_PER_SECOND_SQUARED,
+        z_ang_accel}});
+
+  SensorReadingSharedBuffer* buffer =
+      static_cast<SensorReadingSharedBuffer*>(mapping.get());
+  EXPECT_THAT(buffer->reading.values[0], -x_ang_accel * rad_in_deg);
+  EXPECT_THAT(buffer->reading.values[1], -y_ang_accel * rad_in_deg);
+  EXPECT_THAT(buffer->reading.values[2], -z_ang_accel * rad_in_deg);
+  EXPECT_TRUE(sensor->StopListening(client.get(), configuration));
+}
+
+// Tests that Magnetometer readings are correctly converted.
+TEST_F(PlatformSensorAndProviderTestWin, CheckMagnetometerReadingConversion) {
+  mojo::ScopedSharedBufferHandle handle =
+      PlatformSensorProviderWin::GetInstance()->CloneSharedBufferHandle();
+  mojo::ScopedSharedBufferMapping mapping = handle->MapAtOffset(
+      sizeof(SensorReadingSharedBuffer),
+      SensorReadingSharedBuffer::GetOffset(SensorType::MAGNETOMETER));
+
+  SetSupportedSensor(SENSOR_TYPE_COMPASS_3D);
+  auto sensor = CreateSensor(SensorType::MAGNETOMETER);
+  EXPECT_TRUE(sensor);
+
+  auto client = base::MakeUnique<NiceMock<MockPlatformSensorClient>>(sensor);
+  PlatformSensorConfiguration configuration(10);
+  EXPECT_TRUE(sensor->StartListening(client.get(), configuration));
+  EXPECT_CALL(*client, OnSensorReadingChanged()).Times(0);
+
+  double utesla_in_mgauss = 0.1;
+  double x_magn_field = 112.0;
+  double y_magn_field = -162.0;
+  double z_magn_field = 457.0;
+
+  GenerateDataUpdatedEvent(
+      {{SENSOR_DATA_TYPE_MAGNETIC_FIELD_STRENGTH_X_MILLIGAUSS, x_magn_field},
+       {SENSOR_DATA_TYPE_MAGNETIC_FIELD_STRENGTH_Y_MILLIGAUSS, y_magn_field},
+       {SENSOR_DATA_TYPE_MAGNETIC_FIELD_STRENGTH_Z_MILLIGAUSS, z_magn_field}});
+
+  SensorReadingSharedBuffer* buffer =
+      static_cast<SensorReadingSharedBuffer*>(mapping.get());
+  EXPECT_THAT(buffer->reading.values[0], -x_magn_field * utesla_in_mgauss);
+  EXPECT_THAT(buffer->reading.values[1], -y_magn_field * utesla_in_mgauss);
+  EXPECT_THAT(buffer->reading.values[2], -z_magn_field * utesla_in_mgauss);
+  EXPECT_TRUE(sensor->StopListening(client.get(), configuration));
+}
+
 }  // namespace device