[sensors] Introduce asynchronous way to create sensors.

device/generic_sensor/platform_sensor_provider_base.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 "device/generic_sensor/platform_sensor_provider_base.h"
 
 #include <utility>
 
 #include "base/stl_util.h"
 #include "device/generic_sensor/public/interfaces/sensor_provider.mojom.h"
 
 namespace device {
 
 namespace {
 
 const uint64_t kSharedBufferSizeInBytes =
     mojom::SensorInitParams::kReadBufferSize *
     static_cast<uint64_t>(mojom::SensorType::LAST);
 
 }  // namespace
 
 PlatformSensorProviderBase::PlatformSensorProviderBase() = default;
 PlatformSensorProviderBase::~PlatformSensorProviderBase() = default;
 
-scoped_refptr<PlatformSensor> PlatformSensorProviderBase::CreateSensor(
+void PlatformSensorProviderBase::CreateSensor(
     mojom::SensorType type,
     uint64_t size,
-    uint64_t offset) {
+    uint64_t offset,
+    const CreateSensorCallback& callback) {
   DCHECK(CalledOnValidThread());
 
   if (!CreateSharedBufferIfNeeded())
-    return nullptr;
+    return;

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

it has to run callback with nullptr, right?

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

Done.

 
   mojo::ScopedSharedBufferMapping mapping =
       shared_buffer_handle_->MapAtOffset(size, offset);
   if (!mapping)
-    return nullptr;
+    return;

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

ditto

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

Done.

 
-  scoped_refptr<PlatformSensor> new_sensor =
-      CreateSensorInternal(type, std::move(mapping), size);
-  if (!new_sensor)
-    return nullptr;
+  auto it = requests_map_.find(type);
+  if (it != requests_map_.end()) {
+    it->second.push_back(callback);
+  } else {
+    DCHECK(!ContainsKey(requests_map_, type));

[shalamov, 2016/09/27 11:27:01]

This DCHECK would never fail, right? Maybe it is better to check that there are
no duplicate pending requests in the request queue.

[maksims (do not use this acc), 2016/09/27 12:19:37]

Done.

 
-  DCHECK(!ContainsKey(sensor_map_, type));
-  sensor_map_[type] = new_sensor.get();
+    CallbackQueue pending_requests;

[Mikhail, 2016/09/27 11:29:19]

nit: could be 'requests_map_[type] = CallbackQueue({callback});'

[maksims (do not use this acc), 2016/09/27 12:19:37]

Done.

+    pending_requests.push_back(callback);
+    requests_map_[type] = pending_requests;
 
-  return new_sensor;
+    CreateSensorInternal(
+        type, std::move(mapping), size,
+        base::Bind(&PlatformSensorProviderBase::NotifySensorCreated,
+                   base::Unretained(this), type));
+  }
 }
 
 scoped_refptr<PlatformSensor> PlatformSensorProviderBase::GetSensor(
     mojom::SensorType type) {
   DCHECK(CalledOnValidThread());
 
   auto it = sensor_map_.find(type);
   if (it != sensor_map_.end())
     return it->second;
   return nullptr;
@@ skipping 18 matching lines @@
     shared_buffer_handle_.reset();
 }
 
 mojo::ScopedSharedBufferHandle
 PlatformSensorProviderBase::CloneSharedBufferHandle() {
   DCHECK(CalledOnValidThread());
   CreateSharedBufferIfNeeded();
   return shared_buffer_handle_->Clone();
 }
 
+void PlatformSensorProviderBase::NotifySensorCreated(
+    mojom::SensorType type,
+    scoped_refptr<PlatformSensor> sensor) {
+  DCHECK(CalledOnValidThread());
+  DCHECK(!ContainsKey(sensor_map_, type));
+  DCHECK(ContainsKey(requests_map_, type));
+
+  if (sensor)
+    sensor_map_[type] = sensor.get();
+
+  // Inform subscribers about the sensor.
+  // |sensor| can be nullptr here.
+  auto it = requests_map_.find(type);
+  if (it != requests_map_.end()) {

[Mikhail, 2016/09/27 11:29:19]

it can never be 'it == requests_map_.end()', condition should be omitted.

[maksims (do not use this acc), 2016/09/27 12:19:37]

Right. Done!

+    for (auto& cb : it->second) {
+      cb.Run(sensor);
+    }
+  }
+  requests_map_.erase(type);
+}
+
 }  // namespace device