[sensors](CrOS/Linux) Implement Sensor device manager for 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"
@@ skipping 14 matching lines @@
 void PlatformSensorProviderBase::CreateSensor(
     mojom::SensorType type,
     const CreateSensorCallback& callback) {
   DCHECK(CalledOnValidThread());
 
   if (!CreateSharedBufferIfNeeded()) {
     callback.Run(nullptr);
     return;
   }
 
-  mojo::ScopedSharedBufferMapping mapping = shared_buffer_handle_->MapAtOffset(
-      kReadingBufferSize, SensorReadingSharedBuffer::GetOffset(type));
+  mojo::ScopedSharedBufferMapping mapping = GetScopedSharedBufferMapping(type);
   if (!mapping) {
     callback.Run(nullptr);
     return;
   }
 
   auto it = requests_map_.find(type);
   if (it != requests_map_.end()) {
     it->second.push_back(callback);
   } else {  // This is the first CreateSensor call.
     memset(mapping.get(), 0, kReadingBufferSize);
@@ skipping 24 matching lines @@
 
   shared_buffer_handle_ =
       mojo::SharedBufferHandle::Create(kSharedBufferSizeInBytes);
   return shared_buffer_handle_.is_valid();
 }
 
 void PlatformSensorProviderBase::RemoveSensor(mojom::SensorType type) {
   DCHECK(CalledOnValidThread());
   DCHECK(ContainsKey(sensor_map_, type));
   sensor_map_.erase(type);
+  SensorRemoved(type);
 
   if (sensor_map_.empty()) {
     AllSensorsRemoved();
     shared_buffer_handle_.reset();
   }
 }
 
 mojo::ScopedSharedBufferHandle
 PlatformSensorProviderBase::CloneSharedBufferHandle() {
   DCHECK(CalledOnValidThread());
@@ skipping 19 matching lines @@
 
   // Inform subscribers about the sensor.
   // |sensor| can be nullptr here.
   auto it = requests_map_.find(type);
   for (auto& callback : it->second)
     callback.Run(sensor);
 
   requests_map_.erase(type);
 }
 
+std::vector<mojom::SensorType> PlatformSensorProviderBase::GetRequestTypes() {

[Mikhail, 2016/12/08 11:15:22]

GetPendingRequestedTypes

+  std::vector<mojom::SensorType> request_types;
+  for (auto const& entry : requests_map_)
+    request_types.push_back(entry.first);
+  return request_types;
+}
+
+mojo::ScopedSharedBufferMapping
+PlatformSensorProviderBase::GetScopedSharedBufferMapping(
+    mojom::SensorType type) {
+  mojo::ScopedSharedBufferMapping mapping = shared_buffer_handle_->MapAtOffset(

[Mikhail, 2016/12/08 11:15:22]

this should not be called several times, map once and then return stored mapping

[maksims (do not use this acc), 2016/12/08 18:39:17]

But it does not actually overwrite existing mapping.
The call chain is the following.

PlatformSensorBase calls CreateSensorInternal with mapping as a parameter. When
CreateSensorInternal is invoked in PlatformSensorProviderLinux, it checks if it
can create a sensor (if enumeration is ready). If not, mapping is just lost, not
saved or used. Then, when enumeration becomes ready, mapping is recreated
according to pending requests for certain type. MapAtOffset is called only once
for each type of sensor.

+      kReadingBufferSize, SensorReadingSharedBuffer::GetOffset(type));
+  return mapping;
+}
+
 }  // namespace device