[Sensors] Improvements in shared buffer managing

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 kReadingBufferSize = sizeof(SensorReadingSharedBuffer);
 const uint64_t kSharedBufferSizeInBytes =
-    mojom::SensorInitParams::kReadBufferSize *
-    static_cast<uint64_t>(mojom::SensorType::LAST);
+    kReadingBufferSize * static_cast<uint64_t>(mojom::SensorType::LAST);
 
 }  // namespace
 
 PlatformSensorProviderBase::PlatformSensorProviderBase() = default;
 PlatformSensorProviderBase::~PlatformSensorProviderBase() = default;
 
 void PlatformSensorProviderBase::CreateSensor(
     mojom::SensorType type,
-    uint64_t size,
-    uint64_t offset,
     const CreateSensorCallback& callback) {
   DCHECK(CalledOnValidThread());
 
   if (!CreateSharedBufferIfNeeded()) {
     callback.Run(nullptr);
     return;
   }
 
-  mojo::ScopedSharedBufferMapping mapping =
-      shared_buffer_handle_->MapAtOffset(size, offset);
+  mojo::ScopedSharedBufferMapping mapping = shared_buffer_handle_->MapAtOffset(
+      kReadingBufferSize, GetSharedBufferOffset(type));
   if (!mapping) {
     callback.Run(nullptr);
     return;
   }
 
   auto it = requests_map_.find(type);
   if (it != requests_map_.end()) {
     it->second.push_back(callback);
-  } else {
+  } else {  // This is the first CreateSensor call.
+    memset(mapping.get(), 0, kReadingBufferSize);
+
     requests_map_[type] = CallbackQueue({callback});
 
     CreateSensorInternal(
-        type, std::move(mapping), size,
+        type, std::move(mapping),
         base::Bind(&PlatformSensorProviderBase::NotifySensorCreated,
                    base::Unretained(this), type));
   }
 }
 
 scoped_refptr<PlatformSensor> PlatformSensorProviderBase::GetSensor(
     mojom::SensorType type) {
   DCHECK(CalledOnValidThread());
 
   auto it = sensor_map_.find(type);
@@ skipping 40 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);
 }
 
+uint64_t PlatformSensorProviderBase::GetSharedBufferOffset(

[Ken Rockot(use gerrit already), 2016/10/10 16:02:08]

nit: This doesn't need to be a member function at all, and maybe it should be a
helper function in the public client library? Presumably clients need to know
where to read the sensor data too. Could be in sensor_reading.h/cc?

[Mikhail, 2016/10/10 18:29:20]

Thanks for hint! I've moved it here from sensor_impl.cc but sensor_reading.h is
a better place indeed. 

+    mojom::SensorType type) {
+  return (static_cast<uint64_t>(mojom::SensorType::LAST) -
+          static_cast<uint64_t>(type)) *
+         kReadingBufferSize;
+}
+
 }  // namespace device