[sensors] PlatformSensorProvider implementations are notified when there are no sensor instances

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"
@@ skipping 69 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()) {
-    message_loop_.reset(new base::MessageLoopForIO);
-  }
+      : provider_(new FakePlatformSensorProvider()),
+        sensor_client_(new PlatformSensorTestClient()),
+        message_loop_(new base::MessageLoopForIO) {}
 
  protected:
   scoped_refptr<PlatformSensor> CreateSensor(
       mojom::SensorType type,
       TestSensorCreateCallback* callback) {
-    FakePlatformSensorProvider::GetInstance()->CreateSensor(
-        type, callback->callback());
+    provider_->CreateSensor(type, callback->callback());
     return callback->WaitForResult();
   }
 
+  std::unique_ptr<FakePlatformSensorProvider> provider_;
   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, &callback1);
   EXPECT_TRUE(sensor1);
   EXPECT_EQ(SensorType::AMBIENT_LIGHT, sensor1->GetType());
@@ skipping 17 matching lines @@
   EXPECT_EQ(SensorType::GYROSCOPE, sensor4->GetType());
 
   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, &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);
+      provider_->GetSensor(SensorType::GYROSCOPE);
   EXPECT_FALSE(sensor2);
 
   // Get Ambient Light sensor.
   scoped_refptr<PlatformSensor> sensor3 =
-      sensor_provider->GetSensor(SensorType::AMBIENT_LIGHT);
+      provider_->GetSensor(SensorType::AMBIENT_LIGHT);
   EXPECT_TRUE(sensor3);
 
   EXPECT_EQ(sensor1->GetType(), sensor3->GetType());
 }
 
+TEST_F(PlatformSensorProviderTest, CreateAndRemoveSensors) {
+  TestSensorCreateCallback callback1;
+  scoped_refptr<PlatformSensor> sensor1 =
+      CreateSensor(SensorType::AMBIENT_LIGHT, &callback1);
+  EXPECT_TRUE(sensor1);
+
+  TestSensorCreateCallback callback2;
+  scoped_refptr<PlatformSensor> sensor2 =
+      CreateSensor(SensorType::PROXIMITY, &callback2);
+  EXPECT_TRUE(sensor2);
+
+  EXPECT_TRUE(provider_->HasSensors());
+
+  EXPECT_CALL(*provider_, AllSensorsRemoved()).Times(1);
+
+  sensor1 = nullptr;
+  sensor2 = nullptr;
+
+  EXPECT_FALSE(provider_->HasSensors());
+}
+
 TEST_F(PlatformSensorProviderTest, TestSensorLeaks) {
-  PlatformSensorProvider* sensor_provider =
-      FakePlatformSensorProvider::GetInstance();
-
   // Create Ambient Light sensor.
   TestSensorCreateCallback callback1;
   scoped_refptr<PlatformSensor> sensor1 =
       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);
+      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;
@@ skipping 156 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