[sensors] Introduce asynchronous way to create sensors.

device/generic_sensor/platform_sensor_provider_unittest.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 "base/bind.h"
+#include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
+
 #include "device/generic_sensor/fake_platform_sensor.h"
 #include "device/generic_sensor/fake_platform_sensor_provider.h"
 #include "device/generic_sensor/public/interfaces/sensor_provider.mojom.h"
 
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace device {
 
 using mojom::SensorInitParams;
 using mojom::SensorType;
 
 namespace {
 
 uint64_t GetBufferOffset(mojom::SensorType type) {
   return (static_cast<uint64_t>(SensorType::LAST) -
           static_cast<uint64_t>(type)) *
          SensorInitParams::kReadBufferSize;
 }
 
+using CreateSensorCallback =
+    base::Callback<void(scoped_refptr<PlatformSensor>)>;
+;
+
 }  // namespace
 
+class TestSensorCreateCallback {
+ public:
+  TestSensorCreateCallback()
+      : callback_(base::Bind(&TestSensorCreateCallback::SetResult,
+                             base::Unretained(this))) {}
+
+  scoped_refptr<PlatformSensor> WaitForResult() {
+    run_loop_.Run();
+    scoped_refptr<PlatformSensor> sensor = sensor_;
+    sensor_ = nullptr;
+    return sensor;
+  }
+
+  const CreateSensorCallback& callback() const { return callback_; }
+
+ private:
+  void SetResult(scoped_refptr<PlatformSensor> sensor) {
+    sensor_ = sensor;
+    run_loop_.Quit();
+  }
+
+  const CreateSensorCallback callback_;
+  base::RunLoop run_loop_;
+  scoped_refptr<PlatformSensor> sensor_;
+};
+
 class PlatformSensorTestClient : public PlatformSensor::Client {
  public:
   PlatformSensorTestClient()
       : notification_suspended_(false),
         sensor_reading_changed_(false),
         sensor_error_(false) {}
 
   ~PlatformSensorTestClient() override {
     if (sensor_)
       sensor_->RemoveClient(this);
@@ skipping 22 matching lines @@
  private:
   scoped_refptr<PlatformSensor> sensor_;
   bool notification_suspended_;
   bool sensor_reading_changed_;
   bool sensor_error_;
 };
 
 class PlatformSensorProviderTest : public ::testing::Test {
  public:
   PlatformSensorProviderTest()
-      : sensor_client_(new PlatformSensorTestClient()) {}
+      : sensor_client_(new PlatformSensorTestClient()) {
+    message_loop_.reset(new base::MessageLoopForIO);
+  }
 
  protected:
-  scoped_refptr<PlatformSensor> CreateSensor(mojom::SensorType type) {
-    return FakePlatformSensorProvider::GetInstance()->CreateSensor(
-        type, SensorInitParams::kReadBufferSize, GetBufferOffset(type));
+  scoped_refptr<PlatformSensor> CreateSensor(
+      mojom::SensorType type,
+      TestSensorCreateCallback* callback) {
+    FakePlatformSensorProvider::GetInstance()->CreateSensor(
+        type, SensorInitParams::kReadBufferSize, GetBufferOffset(type),
+        callback->callback());
+    return callback->WaitForResult();
   }
 
   std::unique_ptr<PlatformSensorTestClient> sensor_client_;
+  std::unique_ptr<base::MessageLoop> message_loop_;
 };
 
 TEST_F(PlatformSensorProviderTest, CreateSensorsAndCheckType) {
+  TestSensorCreateCallback callback1;
   scoped_refptr<PlatformSensor> sensor1 =
-      CreateSensor(SensorType::AMBIENT_LIGHT);
+      CreateSensor(SensorType::AMBIENT_LIGHT, &callback1);
   EXPECT_TRUE(sensor1);
   EXPECT_EQ(SensorType::AMBIENT_LIGHT, sensor1->GetType());
 
-  scoped_refptr<PlatformSensor> sensor2 = CreateSensor(SensorType::PROXIMITY);
+  TestSensorCreateCallback callback2;
+  scoped_refptr<PlatformSensor> sensor2 =
+      CreateSensor(SensorType::PROXIMITY, &callback2);
   EXPECT_TRUE(sensor2);
   EXPECT_EQ(SensorType::PROXIMITY, sensor2->GetType());
 
+  TestSensorCreateCallback callback3;
   scoped_refptr<PlatformSensor> sensor3 =
-      CreateSensor(SensorType::ACCELEROMETER);
+      CreateSensor(SensorType::ACCELEROMETER, &callback3);
   EXPECT_TRUE(sensor3);
   EXPECT_EQ(SensorType::ACCELEROMETER, sensor3->GetType());
 
-  scoped_refptr<PlatformSensor> sensor4 = CreateSensor(SensorType::GYROSCOPE);
+  TestSensorCreateCallback callback4;
+  scoped_refptr<PlatformSensor> sensor4 =
+      CreateSensor(SensorType::GYROSCOPE, &callback4);
   EXPECT_TRUE(sensor4);
   EXPECT_EQ(SensorType::GYROSCOPE, sensor4->GetType());
 
-  scoped_refptr<PlatformSensor> sensor5 = CreateSensor(SensorType::PRESSURE);
+  TestSensorCreateCallback callback5;
+  scoped_refptr<PlatformSensor> sensor5 =
+      CreateSensor(SensorType::PRESSURE, &callback5);
   EXPECT_TRUE(sensor5);
   EXPECT_EQ(SensorType::PRESSURE, sensor5->GetType());
 }
 
 TEST_F(PlatformSensorProviderTest, CreateAndGetSensor) {
   PlatformSensorProvider* sensor_provider =
       FakePlatformSensorProvider::GetInstance();
 
   // Create Ambient Light sensor.
+  TestSensorCreateCallback callback1;
   scoped_refptr<PlatformSensor> sensor1 =
-      CreateSensor(SensorType::AMBIENT_LIGHT);
+      CreateSensor(SensorType::AMBIENT_LIGHT, &callback1);
   EXPECT_TRUE(sensor1);
   EXPECT_EQ(SensorType::AMBIENT_LIGHT, sensor1->GetType());
 
   // Try to get Gyroscope sensor, which has not been created yet.
   scoped_refptr<PlatformSensor> sensor2 =
       sensor_provider->GetSensor(SensorType::GYROSCOPE);
   EXPECT_FALSE(sensor2);
 
   // Get Ambient Light sensor.
   scoped_refptr<PlatformSensor> sensor3 =
       sensor_provider->GetSensor(SensorType::AMBIENT_LIGHT);
   EXPECT_TRUE(sensor3);
 
   EXPECT_EQ(sensor1->GetType(), sensor3->GetType());
 
   // Try to create a sensor with zero buffer and offset.
-  scoped_refptr<PlatformSensor> sensor4 =
-      sensor_provider->CreateSensor(SensorType::GYROSCOPE, 0, 0);
+  TestSensorCreateCallback callback4;
+  sensor_provider->CreateSensor(SensorType::GYROSCOPE, 0, 0,
+                                callback4.callback());
+  scoped_refptr<PlatformSensor> sensor4 = callback4.WaitForResult();
   EXPECT_FALSE(sensor4);
 
   scoped_refptr<PlatformSensor> sensor5 =
       sensor_provider->GetSensor(SensorType::GYROSCOPE);
   EXPECT_FALSE(sensor5);
 }
 
 TEST_F(PlatformSensorProviderTest, TestSensorLeaks) {
   PlatformSensorProvider* sensor_provider =
       FakePlatformSensorProvider::GetInstance();
 
   // Create Ambient Light sensor.
+  TestSensorCreateCallback callback1;
   scoped_refptr<PlatformSensor> sensor1 =
-      CreateSensor(SensorType::AMBIENT_LIGHT);
+      CreateSensor(SensorType::AMBIENT_LIGHT, &callback1);
   EXPECT_TRUE(sensor1);
   EXPECT_EQ(SensorType::AMBIENT_LIGHT, sensor1->GetType());
 
   // Sensor should be automatically destroyed.
   sensor1 = nullptr;
   scoped_refptr<PlatformSensor> sensor2 =
       sensor_provider->GetSensor(SensorType::AMBIENT_LIGHT);
   EXPECT_FALSE(sensor2);
 }
 
 // This test assumes that a mock sensor has a constant maximum frequency value
 // of 50 hz (different from the base sensor class that has a range from 0 to
 // 60) and tests whether a mock sensor can be started with a value range from 0
 // to 60.
 TEST_F(PlatformSensorProviderTest, StartListeningWithDifferentParameters) {
   const double too_high_frequency = 60;
   const double normal_frequency = 39;
+  TestSensorCreateCallback callback;
   scoped_refptr<PlatformSensor> sensor =
-      CreateSensor(SensorType::AMBIENT_LIGHT);
+      CreateSensor(SensorType::AMBIENT_LIGHT, &callback);
   FakePlatformSensor* fake_sensor =
       static_cast<FakePlatformSensor*>(sensor.get());
   EXPECT_TRUE(fake_sensor);
   sensor_client_->SetSensor(sensor);
 
   PlatformSensorConfiguration config(too_high_frequency);
   EXPECT_EQ(too_high_frequency, config.frequency());
   EXPECT_FALSE(fake_sensor->StartListening(sensor_client_.get(), config));
   EXPECT_FALSE(fake_sensor->started());
 
   config.set_frequency(normal_frequency);
   EXPECT_EQ(normal_frequency, config.frequency());
   EXPECT_TRUE(fake_sensor->StartListening(sensor_client_.get(), config));
   EXPECT_TRUE(fake_sensor->started());
 
   EXPECT_TRUE(fake_sensor->StopListening(sensor_client_.get(), config));
   EXPECT_FALSE(fake_sensor->started());
 }
 
 // If a client is in a suspended mode, a NotifySensorReadingChanged()
 // notification must not be sent to the client but NotifySensorError() must be.
 TEST_F(PlatformSensorProviderTest, TestNotificationSuspended) {
   const int num = 5;
-  scoped_refptr<PlatformSensor> sensor = CreateSensor(SensorType::GYROSCOPE);
+  TestSensorCreateCallback callback;
+  scoped_refptr<PlatformSensor> sensor =
+      CreateSensor(SensorType::GYROSCOPE, &callback);
   FakePlatformSensor* fake_sensor =
       static_cast<FakePlatformSensor*>(sensor.get());
 
   std::vector<std::unique_ptr<PlatformSensorTestClient>> clients;
   for (int i = 0; i < num; i++) {
     std::unique_ptr<PlatformSensorTestClient> client(
         new PlatformSensorTestClient());
     client->SetSensor(fake_sensor);
     clients.push_back(std::move(client));
   }
@@ skipping 17 matching lines @@
   for (auto const& client : clients) {
     EXPECT_TRUE(client->sensor_reading_changed());
     EXPECT_TRUE(client->sensor_error());
   }
 }
 
 // Tests that when all clients are removed, config maps are removed as well.
 TEST_F(PlatformSensorProviderTest, TestAddRemoveClients) {
   const int num = 5;
 
+  TestSensorCreateCallback callback;
   scoped_refptr<PlatformSensor> sensor =
-      CreateSensor(SensorType::AMBIENT_LIGHT);
+      CreateSensor(SensorType::AMBIENT_LIGHT, &callback);
   FakePlatformSensor* fake_sensor =
       static_cast<FakePlatformSensor*>(sensor.get());
   EXPECT_TRUE(fake_sensor->config_map().empty());
 
   std::vector<std::unique_ptr<PlatformSensorTestClient>> clients;
   PlatformSensorConfiguration config(30);
   for (int i = 0; i < num; i++) {
     std::unique_ptr<PlatformSensorTestClient> client(
         new PlatformSensorTestClient());
     client->SetSensor(fake_sensor);
     EXPECT_TRUE(fake_sensor->StartListening(client.get(), config));
     EXPECT_TRUE(fake_sensor->started());
 
     clients.push_back(std::move(client));
   }
   EXPECT_FALSE(fake_sensor->config_map().empty());
 
   for (const auto& client : clients)
     fake_sensor->RemoveClient(client.get());
 
   EXPECT_TRUE(fake_sensor->config_map().empty());
 }
 
 // Tests a sensor cannot be updated if it has one suspended client.
 TEST_F(PlatformSensorProviderTest, TestUpdateSensorOneClient) {
+  TestSensorCreateCallback callback;
   scoped_refptr<PlatformSensor> sensor =
-      CreateSensor(SensorType::AMBIENT_LIGHT);
+      CreateSensor(SensorType::AMBIENT_LIGHT, &callback);
   FakePlatformSensor* fake_sensor =
       static_cast<FakePlatformSensor*>(sensor.get());
   EXPECT_TRUE(fake_sensor->config_map().empty());
 
   sensor_client_->SetSensor(fake_sensor);
 
   PlatformSensorConfiguration config(30);
   fake_sensor->StartListening(sensor_client_.get(), config);
 
   sensor_client_->set_notification_suspended(true);
   EXPECT_TRUE(sensor_client_->IsNotificationSuspended());
 
   fake_sensor->UpdateSensor();
   EXPECT_FALSE(fake_sensor->started());
 
   sensor_client_->set_notification_suspended(false);
   EXPECT_FALSE(sensor_client_->IsNotificationSuspended());
 
   fake_sensor->UpdateSensor();
   EXPECT_TRUE(fake_sensor->started());
 }
 
 // Tests a sensor can be updated if it has one suspended client and other
 // clients are not suspended.
 TEST_F(PlatformSensorProviderTest, TestUpdateSensorManyClients) {
   const int num = 5;
 
+  TestSensorCreateCallback callback;
   scoped_refptr<PlatformSensor> sensor =
-      CreateSensor(SensorType::AMBIENT_LIGHT);
+      CreateSensor(SensorType::AMBIENT_LIGHT, &callback);
   FakePlatformSensor* fake_sensor =
       static_cast<FakePlatformSensor*>(sensor.get());
   EXPECT_TRUE(fake_sensor->config_map().empty());
 
   sensor_client_->SetSensor(fake_sensor);
   std::vector<std::unique_ptr<PlatformSensorTestClient>> clients;
   for (int i = 0; i < num; i++) {
     std::unique_ptr<PlatformSensorTestClient> client(
         new PlatformSensorTestClient());
     client->SetSensor(fake_sensor);
@@ skipping 19 matching lines @@
   sensor_client_->set_notification_suspended(false);
   EXPECT_FALSE(sensor_client_->IsNotificationSuspended());
   for (const auto& client : clients)
     EXPECT_FALSE(client->IsNotificationSuspended());
 
   fake_sensor->UpdateSensor();
   EXPECT_TRUE(fake_sensor->started());
 }
 
 }  // namespace device