[sensors] Introduce asynchronous way to create sensors.

device/generic_sensor/sensor_provider_impl.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/sensor_provider_impl.h"
 
 #include <utility>
 
 #include "device/generic_sensor/platform_sensor_provider.h"
 #include "device/generic_sensor/sensor_impl.h"
@@ skipping 14 matching lines @@
 // static
 void SensorProviderImpl::Create(mojom::SensorProviderRequest request) {
   PlatformSensorProvider* provider = PlatformSensorProvider::GetInstance();
   if (provider) {
     mojo::MakeStrongBinding(base::WrapUnique(new SensorProviderImpl(provider)),
                             std::move(request));
   }
 }
 
 SensorProviderImpl::SensorProviderImpl(PlatformSensorProvider* provider)
-    : provider_(provider) {
+    : provider_(provider), weak_ptr_factory_(this) {
   DCHECK(provider_);
 }
 
 SensorProviderImpl::~SensorProviderImpl() {}
 
 void SensorProviderImpl::GetSensor(mojom::SensorType type,
                                    mojom::SensorRequest sensor_request,
                                    const GetSensorCallback& callback) {
   auto cloned_handle = provider_->CloneSharedBufferHandle();
   if (!cloned_handle.is_valid()) {
     callback.Run(nullptr, nullptr);
     return;
   }
 
   scoped_refptr<PlatformSensor> sensor = provider_->GetSensor(type);
   if (!sensor) {
-    sensor = provider_->CreateSensor(
-        type, mojom::SensorInitParams::kReadBufferSize, GetBufferOffset(type));
+    PlatformSensorProviderBase::CreateSensorCallback cb = base::Bind(
+        &SensorProviderImpl::SensorCreated, weak_ptr_factory_.GetWeakPtr(),
+        type, base::Passed(&cloned_handle), base::Passed(&sensor_request),
+        callback);
+    provider_->CreateSensor(type, mojom::SensorInitParams::kReadBufferSize,
+                            GetBufferOffset(type), cb);

[timvolodine, 2016/09/30 18:50:48]

you mentioned this is 'synchronous' on android/mac i.e. the callback is executed
immediately, are there any potential re-entrancy issues, if for example I call
GetSensor inside the GetSensorCallback?

[maksims (do not use this acc), 2016/10/03 12:58:11]

It's technically possible, but it would be considered as a programming error if
one calls getSensor on the same process using the same sensor_provider_impl. Do
you think this should be fixed on this level?

[timvolodine, 2016/10/03 17:44:12]

I think this should be addressed to some extent to avoid potential future
issues.. I would either use a PostTask (instead of immediate callback
invocation) or maybe a dcheck with a comment to avoid reentrancy. But handling
everything in async way seems the easiest approach (probably without much if any
overhead).

[maksims (do not use this acc), 2016/10/04 07:21:34]

Sure. As per discussion with shalamov@, we had the same conclusion (I mean using
PostTask to run the callback.

+    return;
   }
 
+  SensorCreated(type, std::move(cloned_handle), std::move(sensor_request),
+                callback, std::move(sensor));
+}
+
+void SensorProviderImpl::SensorCreated(
+    mojom::SensorType type,
+    mojo::ScopedSharedBufferHandle cloned_handle,
+    mojom::SensorRequest sensor_request,
+    const GetSensorCallback& callback,
+    scoped_refptr<PlatformSensor> sensor) {
   if (!sensor) {
     callback.Run(nullptr, nullptr);
     return;
   }
 
   auto sensor_impl = base::MakeUnique<SensorImpl>(sensor);
 
   auto init_params = mojom::SensorInitParams::New();
   init_params->memory = std::move(cloned_handle);
   init_params->buffer_offset = GetBufferOffset(type);
   init_params->mode = sensor->GetReportingMode();
   init_params->default_configuration = sensor->GetDefaultConfiguration();
 
   callback.Run(std::move(init_params), sensor_impl->GetClient());
 
   mojo::MakeStrongBinding(std::move(sensor_impl), std::move(sensor_request));
 }
 
 }  // namespace device