Convert device_sensors to use mojo.

content/browser/device_sensors/data_fetcher_shared_memory_base.cc

 // Copyright 2014 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 "content/browser/device_sensors/data_fetcher_shared_memory_base.h"
 
 #include <stddef.h>
 #include <string.h>
 
 #include "base/bind.h"
@@ skipping 101 matching lines @@
 DataFetcherSharedMemoryBase::DataFetcherSharedMemoryBase()
     : started_consumers_(0) {
 }
 
 DataFetcherSharedMemoryBase::~DataFetcherSharedMemoryBase() {
   DCHECK_EQ(0u, started_consumers_);
 
   // make sure polling thread stops asap.
   if (polling_thread_)
     polling_thread_->Stop();
-
-  STLDeleteContainerPairSecondPointers(shared_memory_map_.begin(),
-      shared_memory_map_.end());
 }
 
 bool DataFetcherSharedMemoryBase::StartFetchingDeviceData(
     ConsumerType consumer_type) {
   if (started_consumers_ & consumer_type)
     return true;
 
   void* buffer = GetSharedMemoryBuffer(consumer_type);
   if (!buffer)
     return false;
@@ skipping 41 matching lines @@
   return true;
 }
 
 void DataFetcherSharedMemoryBase::Shutdown() {
   StopFetchingDeviceData(CONSUMER_TYPE_MOTION);
   StopFetchingDeviceData(CONSUMER_TYPE_ORIENTATION);
   StopFetchingDeviceData(CONSUMER_TYPE_ORIENTATION_ABSOLUTE);
   StopFetchingDeviceData(CONSUMER_TYPE_LIGHT);
 }
 
-base::SharedMemoryHandle
-DataFetcherSharedMemoryBase::GetSharedMemoryHandleForProcess(
-    ConsumerType consumer_type, base::ProcessHandle process) {
-  SharedMemoryMap::const_iterator it = shared_memory_map_.find(consumer_type);
+mojo::ScopedSharedBufferHandle
+DataFetcherSharedMemoryBase::GetSharedMemoryHandle(ConsumerType consumer_type) {
+  auto it = shared_memory_map_.find(consumer_type);
   if (it == shared_memory_map_.end())
-    return base::SharedMemory::NULLHandle();
+    return mojo::ScopedSharedBufferHandle();
 
-  base::SharedMemoryHandle renderer_handle;
-  it->second->ShareToProcess(process, &renderer_handle);
-  return renderer_handle;
+  return it->second.first->Clone();
 }
 
 bool DataFetcherSharedMemoryBase::InitAndStartPollingThreadIfNecessary() {
   if (polling_thread_)
     return true;
 
   polling_thread_.reset(
       new PollingThread("Inertial Device Sensor poller", this));
 
   if (!polling_thread_->Start()) {
       LOG(ERROR) << "Failed to start inertial sensor data polling thread";
       return false;
   }
   return true;
 }
 
 void DataFetcherSharedMemoryBase::Fetch(unsigned consumer_bitmask) {
   NOTIMPLEMENTED();
 }
 
 DataFetcherSharedMemoryBase::FetcherType
 DataFetcherSharedMemoryBase::GetType() const {
   return FETCHER_TYPE_DEFAULT;
 }
 
 base::TimeDelta DataFetcherSharedMemoryBase::GetInterval() const {
   return base::TimeDelta::FromMicroseconds(kInertialSensorIntervalMicroseconds);
 }
 
-base::SharedMemory* DataFetcherSharedMemoryBase::GetSharedMemory(
+void* DataFetcherSharedMemoryBase::GetSharedMemoryBuffer(
     ConsumerType consumer_type) {
-  SharedMemoryMap::const_iterator it = shared_memory_map_.find(consumer_type);
+  auto it = shared_memory_map_.find(consumer_type);
   if (it != shared_memory_map_.end())
-    return it->second;
+    return it->second.second.get();
 
   size_t buffer_size = GetConsumerSharedMemoryBufferSize(consumer_type);
   if (buffer_size == 0)
     return nullptr;
 
-  std::unique_ptr<base::SharedMemory> new_shared_mem(new base::SharedMemory);
-  if (new_shared_mem->CreateAndMapAnonymous(buffer_size)) {
-    if (void* mem = new_shared_mem->memory()) {
-      memset(mem, 0, buffer_size);
-      base::SharedMemory* shared_mem = new_shared_mem.release();
-      shared_memory_map_[consumer_type] = shared_mem;
-      return shared_mem;
-    }
-  }
-  LOG(ERROR) << "Failed to initialize shared memory";
-  return nullptr;
-}
-
-void* DataFetcherSharedMemoryBase::GetSharedMemoryBuffer(
-    ConsumerType consumer_type) {
-  if (base::SharedMemory* shared_memory = GetSharedMemory(consumer_type))
-    return shared_memory->memory();
-  return nullptr;
+  mojo::ScopedSharedBufferHandle buffer =
+      mojo::SharedBufferHandle::Create(buffer_size);
+  mojo::ScopedSharedBufferMapping mapping = buffer->Map(buffer_size);
+  if (!mapping)
+    return nullptr;
+  void* mem = mapping.get();
+  memset(mem, 0, buffer_size);
+  shared_memory_map_[consumer_type] =
+      std::make_pair(std::move(buffer), std::move(mapping));
+  return mem;
 }
 
 base::MessageLoop* DataFetcherSharedMemoryBase::GetPollingMessageLoop() const {
   return polling_thread_ ? polling_thread_->message_loop() : nullptr;
 }
 
 bool DataFetcherSharedMemoryBase::IsPollingTimerRunningForTesting() const {
   return polling_thread_ ? polling_thread_->IsTimerRunning() : false;
 }
 
 }  // namespace content