Support read-only duplicates of Mojo shared buffers.

mojo/edk/embedder/platform_shared_buffer.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 "mojo/edk/embedder/platform_shared_buffer.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 26 matching lines @@
   }
 #endif
 }
 
 }  // namespace
 
 // static
 PlatformSharedBuffer* PlatformSharedBuffer::Create(size_t num_bytes) {
   DCHECK_GT(num_bytes, 0u);
 
-  PlatformSharedBuffer* rv = new PlatformSharedBuffer(num_bytes);
+  PlatformSharedBuffer* rv = new PlatformSharedBuffer(num_bytes, false);
   if (!rv->Init()) {
     // We can't just delete it directly, due to the "in destructor" (debug)
     // check.
     scoped_refptr<PlatformSharedBuffer> deleter(rv);
     return nullptr;
   }
 
   return rv;
 }
 
 // static
 PlatformSharedBuffer* PlatformSharedBuffer::CreateFromPlatformHandle(
     size_t num_bytes,
+    bool read_only,
     ScopedPlatformHandle platform_handle) {
   DCHECK_GT(num_bytes, 0u);
 
-  PlatformSharedBuffer* rv = new PlatformSharedBuffer(num_bytes);
+  PlatformSharedBuffer* rv = new PlatformSharedBuffer(num_bytes, read_only);
   if (!rv->InitFromPlatformHandle(std::move(platform_handle))) {
     // We can't just delete it directly, due to the "in destructor" (debug)
     // check.
     scoped_refptr<PlatformSharedBuffer> deleter(rv);
     return nullptr;
   }
 
   return rv;
 }
 
 // static
 PlatformSharedBuffer* PlatformSharedBuffer::CreateFromSharedMemoryHandle(
     size_t num_bytes,
     bool read_only,
     base::SharedMemoryHandle handle) {
   DCHECK_GT(num_bytes, 0u);
-  DCHECK(!read_only);
 
-  PlatformSharedBuffer* rv = new PlatformSharedBuffer(num_bytes);
+  PlatformSharedBuffer* rv = new PlatformSharedBuffer(num_bytes, read_only);
   rv->InitFromSharedMemoryHandle(handle);
 
   return rv;
 }
 
 size_t PlatformSharedBuffer::GetNumBytes() const {
   return num_bytes_;
 }
 
+bool PlatformSharedBuffer::IsReadOnly() const {
+    return read_only_;
+}
+
 scoped_ptr<PlatformSharedBufferMapping> PlatformSharedBuffer::Map(
     size_t offset,
     size_t length) {
   if (!IsValidMap(offset, length))
     return nullptr;
 
   return MapNoCheck(offset, length);
 }
 
 bool PlatformSharedBuffer::IsValidMap(size_t offset, size_t length) {
@@ skipping 15 matching lines @@
   DCHECK(shared_memory_);
   base::SharedMemoryHandle handle;
   {
     base::AutoLock locker(lock_);
     handle = base::SharedMemory::DuplicateHandle(shared_memory_->handle());
   }
   if (handle == base::SharedMemory::NULLHandle())
     return nullptr;
 
   scoped_ptr<PlatformSharedBufferMapping> mapping(
-      new PlatformSharedBufferMapping(handle, offset, length));
+      new PlatformSharedBufferMapping(handle, read_only_, offset, length));
   if (mapping->Map())
     return make_scoped_ptr(mapping.release());
 
   return nullptr;
 }
 
 ScopedPlatformHandle PlatformSharedBuffer::DuplicatePlatformHandle() {
   DCHECK(shared_memory_);
   base::SharedMemoryHandle handle;
   {
@@ skipping 18 matching lines @@
   return handle;
 }
 
 base::SharedMemoryHandle PlatformSharedBuffer::DuplicateSharedMemoryHandle() {
   DCHECK(shared_memory_);
 
   base::AutoLock locker(lock_);
   return base::SharedMemory::DuplicateHandle(shared_memory_->handle());
 }
 
-PlatformSharedBuffer::PlatformSharedBuffer(size_t num_bytes)
-    : num_bytes_(num_bytes) {}
+PlatformSharedBuffer* PlatformSharedBuffer::CreateReadOnlyDuplicate() {
+  DCHECK(shared_memory_);
+  base::SharedMemoryHandle handle;
+  bool success;
+  {
+    base::AutoLock locker(lock_);
+    success = shared_memory_->ShareReadOnlyToProcess(
+        base::GetCurrentProcessHandle(), &handle);
+  }
+  if (!success || handle == base::SharedMemory::NULLHandle())
+      return nullptr;
+
+  return CreateFromSharedMemoryHandle(num_bytes_, true, handle);
+}
+
+PlatformSharedBuffer::PlatformSharedBuffer(size_t num_bytes, bool read_only)
+    : num_bytes_(num_bytes), read_only_(read_only) {}
 
 PlatformSharedBuffer::~PlatformSharedBuffer() {}
 
 bool PlatformSharedBuffer::Init() {
   DCHECK(!shared_memory_);
+  DCHECK(!read_only_);
 
   base::SharedMemoryCreateOptions options;
   options.size = num_bytes_;
+  // By default, we can share as read-only.
+  options.share_read_only = true;
 #if defined(OS_MACOSX) && !defined(OS_IOS)
   options.type = base::SharedMemoryHandle::MACH;
 #endif
 
   shared_memory_.reset(new base::SharedMemory);
   return shared_memory_->Create(options);
 }
 
 bool PlatformSharedBuffer::InitFromPlatformHandle(
     ScopedPlatformHandle platform_handle) {
   DCHECK(!shared_memory_);
 
 #if defined(OS_WIN)
   base::SharedMemoryHandle handle(platform_handle.release().handle,
                                   base::GetCurrentProcId());
 #elif defined(OS_MACOSX) && !defined(OS_IOS)
   base::SharedMemoryHandle handle;
   if (platform_handle.get().type == PlatformHandle::Type::MACH) {
     handle = base::SharedMemoryHandle(
         platform_handle.release().port, num_bytes_, base::GetCurrentProcId());
   } else {
     handle = base::SharedMemoryHandle(platform_handle.release().handle, false);
   }
 #else
   base::SharedMemoryHandle handle(platform_handle.release().handle, false);
 #endif
 
-  shared_memory_.reset(new base::SharedMemory(handle, false));
+  shared_memory_.reset(new base::SharedMemory(handle, read_only_));
   return true;
 }
 
 void PlatformSharedBuffer::InitFromSharedMemoryHandle(
     base::SharedMemoryHandle handle) {
   DCHECK(!shared_memory_);
 
-  // TODO(crbug.com/556587): Support read-only handles.
-  shared_memory_.reset(new base::SharedMemory(handle, false));
+  shared_memory_.reset(new base::SharedMemory(handle, read_only_));
 }
 
 PlatformSharedBufferMapping::~PlatformSharedBufferMapping() {
   Unmap();
 }
 
 void* PlatformSharedBufferMapping::GetBase() const {
   return base_;
 }
 
@@ skipping 15 matching lines @@
   base_ = static_cast<char*>(shared_memory_.memory()) + offset_rounding;
   return true;
 }
 
 void PlatformSharedBufferMapping::Unmap() {
   shared_memory_.Unmap();
 }
 
 }  // namespace edk
 }  // namespace mojo