[sensors] [win] Fix ambient light not working properly Windows 10.

device/generic_sensor/platform_sensor_and_provider_unittest_win.cc

 // Copyright 2016 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 <SensorsApi.h>
 #include <Sensors.h>  // NOLINT
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
@@ skipping 206 matching lines @@
     PlatformSensorProviderWin::GetInstance()->CreateSensor(
         type, base::Bind(&PlatformSensorAndProviderTestWin::SensorCreated,
                          base::Unretained(this)));
     run_loop_->Run();
     scoped_refptr<PlatformSensor> sensor;
     sensor.swap(platform_sensor_);
     run_loop_ = nullptr;
     return sensor;
   }
 
+  // Listening the sensor is asynchronous, therefore inner loop is used to wait
+  // for SetEventSink to be called.
+  bool StartListening(scoped_refptr<PlatformSensor> sensor,
+                      PlatformSensor::Client* client,
+                      const PlatformSensorConfiguration& config) {
+    run_loop_ = base::MakeUnique<base::RunLoop>();
+    bool ret = sensor->StartListening(client, config);
+    run_loop_->Run();
+    run_loop_ = nullptr;
+    return ret;
+  }
+
+  void QuitInnerLoop() { run_loop_->Quit(); }
+
   // Sets sensor with REFSENSOR_TYPE_ID |sensor| to be supported by mocked
   // ISensorMager and it will be present in ISensorCollection.
   void SetSupportedSensor(REFSENSOR_TYPE_ID sensor) {
     // Returns mock ISensorCollection.
     EXPECT_CALL(*sensor_manager_, GetSensorsByType(sensor, _))
         .WillOnce(Invoke(
             [this](REFSENSOR_TYPE_ID type, ISensorCollection** collection) {
               sensor_collection_->QueryInterface(
                   __uuidof(ISensorCollection),
                   reinterpret_cast<void**>(collection));
@@ skipping 17 matching lines @@
         }));
 
     // Handles |SetEventSink| call that is used to subscribe to sensor events
     // through ISensorEvents interface. ISensorEvents is stored and attached to
     // |sensor_events_| that is used later to generate fake error, state and
     // data change events.
     ON_CALL(*sensor_, SetEventSink(NotNull()))
         .WillByDefault(Invoke([this](ISensorEvents* events) {
           events->AddRef();
           sensor_events_.Attach(events);
+          if (this->run_loop_) {
+            message_loop_.task_runner()->PostTask(
+                FROM_HERE,
+                base::Bind(&PlatformSensorAndProviderTestWin::QuitInnerLoop,
+                           base::Unretained(this)));
+          }
           return S_OK;
         }));
 
     // When |SetEventSink| is called with nullptr, it means that client is no
     // longer interested in sensor events and ISensorEvents can be released.
     ON_CALL(*sensor_, SetEventSink(IsNull()))
         .WillByDefault(Invoke([this](ISensorEvents* events) {
           sensor_events_.Release();
+          if (this->run_loop_) {
+            message_loop_.task_runner()->PostTask(
+                FROM_HERE,
+                base::Bind(&PlatformSensorAndProviderTestWin::QuitInnerLoop,
+                           base::Unretained(this)));
+          }
           return S_OK;
         }));
   }
 
   // Sets minimal reporting frequency for the mock sensor.
   void SetSupportedReportingFrequency(double frequency) {
     ON_CALL(*sensor_, GetProperty(SENSOR_PROPERTY_MIN_REPORT_INTERVAL, _))
         .WillByDefault(
             Invoke([frequency](REFPROPERTYKEY key, PROPVARIANT* pProperty) {
               pProperty->vt = VT_UI4;
@@ skipping 144 matching lines @@
 
 // Tests that PlatformSensor::StartListening succeeds and notification about
 // modified sensor reading is sent to the PlatformSensor::Client interface.
 TEST_F(PlatformSensorAndProviderTestWin, SensorStarted) {
   SetSupportedReportingFrequency(10);
   SetSupportedSensor(SENSOR_TYPE_AMBIENT_LIGHT);
 
   EXPECT_CALL(*sensor_, SetEventSink(NotNull())).Times(1);
   EXPECT_CALL(*sensor_, SetEventSink(IsNull())).Times(1);
   EXPECT_CALL(*sensor_, SetProperties(NotNull(), _))
-      .WillOnce(Invoke(
+      .WillRepeatedly(Invoke(
           [](IPortableDeviceValues* props, IPortableDeviceValues** result) {
             ULONG value = 0;
             HRESULT hr = props->GetUnsignedIntegerValue(
                 SENSOR_PROPERTY_CURRENT_REPORT_INTERVAL, &value);
             EXPECT_TRUE(SUCCEEDED(hr));
             // 10Hz is 100msec
             EXPECT_THAT(value, 100);
             return hr;
           }));
 
   auto sensor = CreateSensor(SensorType::AMBIENT_LIGHT);
   EXPECT_TRUE(sensor);
 
   auto client = base::MakeUnique<NiceMock<MockPlatformSensorClient>>(sensor);
   PlatformSensorConfiguration configuration(10);
-  EXPECT_TRUE(sensor->StartListening(client.get(), configuration));
+  EXPECT_TRUE(StartListening(sensor, client.get(), configuration));
 
   EXPECT_CALL(*client, OnSensorReadingChanged()).Times(1);
   GenerateDataUpdatedEvent({{SENSOR_DATA_TYPE_LIGHT_LEVEL_LUX, 3.14}});
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(sensor->StopListening(client.get(), configuration));
 }
 
 // Tests that OnSensorError is called when sensor is disconnected.
 TEST_F(PlatformSensorAndProviderTestWin, SensorRemoved) {
   SetSupportedSensor(SENSOR_TYPE_AMBIENT_LIGHT);
   auto sensor = CreateSensor(SensorType::AMBIENT_LIGHT);
   EXPECT_TRUE(sensor);
 
   auto client = base::MakeUnique<NiceMock<MockPlatformSensorClient>>(sensor);
   PlatformSensorConfiguration configuration(10);
-  EXPECT_TRUE(sensor->StartListening(client.get(), configuration));
+  EXPECT_TRUE(StartListening(sensor, client.get(), configuration));
   EXPECT_CALL(*client, OnSensorError()).Times(1);
 
   GenerateLeaveEvent();
   base::RunLoop().RunUntilIdle();
 }
 
 // Tests that OnSensorError is called when sensor is in an error state.
 TEST_F(PlatformSensorAndProviderTestWin, SensorStateChangedToError) {
   SetSupportedSensor(SENSOR_TYPE_AMBIENT_LIGHT);
   auto sensor = CreateSensor(SensorType::AMBIENT_LIGHT);
   EXPECT_TRUE(sensor);
 
   auto client = base::MakeUnique<NiceMock<MockPlatformSensorClient>>(sensor);
   PlatformSensorConfiguration configuration(10);
-  EXPECT_TRUE(sensor->StartListening(client.get(), configuration));
+  EXPECT_TRUE(StartListening(sensor, client.get(), configuration));
   EXPECT_CALL(*client, OnSensorError()).Times(1);
 
   GenerateStateChangeEvent(SENSOR_STATE_ERROR);
   base::RunLoop().RunUntilIdle();
 }
 
 // Tests that OnSensorError is not called when sensor is in a ready state.
 TEST_F(PlatformSensorAndProviderTestWin, SensorStateChangedToReady) {
   SetSupportedSensor(SENSOR_TYPE_AMBIENT_LIGHT);
   auto sensor = CreateSensor(SensorType::AMBIENT_LIGHT);
   EXPECT_TRUE(sensor);
 
   auto client = base::MakeUnique<NiceMock<MockPlatformSensorClient>>(sensor);
   PlatformSensorConfiguration configuration(10);
-  EXPECT_TRUE(sensor->StartListening(client.get(), configuration));
+  EXPECT_TRUE(StartListening(sensor, client.get(), configuration));
   EXPECT_CALL(*client, OnSensorError()).Times(0);
 
   GenerateStateChangeEvent(SENSOR_STATE_READY);
   base::RunLoop().RunUntilIdle();
 }
 
 // Tests that GetMaximumSupportedFrequency provides correct value.
 TEST_F(PlatformSensorAndProviderTestWin, GetMaximumSupportedFrequency) {
   SetSupportedReportingFrequency(20);
   SetSupportedSensor(SENSOR_TYPE_AMBIENT_LIGHT);
@@ skipping 18 matching lines @@
   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));
+  EXPECT_TRUE(StartListening(sensor, client.get(), configuration));
   EXPECT_CALL(*client, OnSensorReadingChanged()).Times(1);
 
   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}});
 
   base::RunLoop().RunUntilIdle();
@@ skipping 12 matching lines @@
   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_TRUE(StartListening(sensor, client.get(), configuration));
   EXPECT_CALL(*client, OnSensorReadingChanged()).Times(1);
 
   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,
@@ skipping 20 matching lines @@
   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_TRUE(StartListening(sensor, client.get(), configuration));
   EXPECT_CALL(*client, OnSensorReadingChanged()).Times(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}});
 
   base::RunLoop().RunUntilIdle();
   SensorReadingSharedBuffer* buffer =
       static_cast<SensorReadingSharedBuffer*>(mapping.get());
   EXPECT_THAT(buffer->reading.values[0],
               -x_magn_field * kMicroteslaInMilligauss);
   EXPECT_THAT(buffer->reading.values[1],
               -y_magn_field * kMicroteslaInMilligauss);
   EXPECT_THAT(buffer->reading.values[2],
               -z_magn_field * kMicroteslaInMilligauss);
   EXPECT_TRUE(sensor->StopListening(client.get(), configuration));
 }
 
 }  // namespace device