[sensors] Introduce asynchronous way to create sensors.

device/generic_sensor/platform_sensor_provider_base.h

 // 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.
 
 #ifndef DEVICE_GENERIC_SENSOR_PLATFORM_SENSOR_PROVIDER_BASE_H_
 #define DEVICE_GENERIC_SENSOR_PLATFORM_SENSOR_PROVIDER_BASE_H_
 
 #include "base/macros.h"
 
 #include "base/threading/non_thread_safe.h"
 #include "device/generic_sensor/platform_sensor.h"
 
 namespace device {
 
 // Base class that defines factory methods for PlatformSensor creation.
 // Its implementations must be accessed via GetInstance() method.
 class PlatformSensorProviderBase : public base::NonThreadSafe {
  public:
+  using CreateSensorCallback =
+      base::Callback<void(scoped_refptr<PlatformSensor>)>;
+
   // Creates new instance of PlatformSensor.
-  scoped_refptr<PlatformSensor> CreateSensor(mojom::SensorType type,
-                                             uint64_t size,
-                                             uint64_t offset);
+  void CreateSensor(mojom::SensorType type,
+                    uint64_t size,
+                    uint64_t offset,
+                    const CreateSensorCallback& callback);
 
   // Gets previously created instance of PlatformSensor by sensor type |type|.
   scoped_refptr<PlatformSensor> GetSensor(mojom::SensorType type);
 
   // Shared buffer getters.
   mojo::ScopedSharedBufferHandle CloneSharedBufferHandle();
 
  protected:
   PlatformSensorProviderBase();
   virtual ~PlatformSensorProviderBase();
 
   // Method that must be implemented by platform specific classes.
-  virtual scoped_refptr<PlatformSensor> CreateSensorInternal(
-      mojom::SensorType type,
-      mojo::ScopedSharedBufferMapping mapping,
-      uint64_t buffer_size) = 0;
+  virtual void CreateSensorInternal(mojom::SensorType type,
+                                    mojo::ScopedSharedBufferMapping mapping,
+                                    uint64_t buffer_size,
+                                    const CreateSensorCallback& callback) = 0;
 
  private:
   friend class PlatformSensor;  // To call RemoveSensor();
 
   bool CreateSharedBufferIfNeeded();
   void RemoveSensor(mojom::SensorType type);
+  void NotifySensorCreated(mojom::SensorType type,
+                           scoped_refptr<PlatformSensor> sensor);
 
  private:
+  using CallbackQueue =
+      std::vector<base::Callback<void(scoped_refptr<PlatformSensor>)>>;
+
   std::map<mojom::SensorType, PlatformSensor*> sensor_map_;
+  std::map<mojom::SensorType, CallbackQueue> requests_map_;

[Mikhail, 2016/09/26 09:52:23]

let's keep PlatformSensorProvider simple and move pending requests management to
SensorProviderImpl

[maksims (do not use this acc), 2016/09/27 10:17:25]

We cannot do so. SensorProviderImpl is not a singleton class. Thus, when one
opens a new tab, new SensorProviderImpl is created and there are different maps
of callbacks. Request for creating a sensor will be triggered again and again.
What is more, SensorProviderImpl will have to have two different paths to create
sensors. 1) If no sensor, save callbacks to map and trigger a provider to create
sensors. On callback run origin callbacks. 
2) If there was a sensor, directly establish a sensor and run callback. Thus,
there will be more code.

   mojo::ScopedSharedBufferHandle shared_buffer_handle_;
 
   DISALLOW_COPY_AND_ASSIGN(PlatformSensorProviderBase);
 };
 
 }  // namespace device
 
 #endif  // DEVICE_GENERIC_SENSOR_PLATFORM_SENSOR_PROVIDER_BASE_H_