Support read-only duplicates of Mojo shared buffers.

mojo/edk/system/core.cc

 // Copyright 2013 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/system/core.h"
 
 #include <string.h>
 
 #include <utility>
 
@@ skipping 142 matching lines @@
   phd->Close();
   return MOJO_RESULT_OK;
 }
 
 MojoResult Core::CreateSharedBufferWrapper(
     base::SharedMemoryHandle shared_memory_handle,
     size_t num_bytes,
     bool read_only,
     MojoHandle* mojo_wrapper_handle) {
   DCHECK(num_bytes);
-  CHECK(!read_only);
   scoped_refptr<PlatformSharedBuffer> platform_buffer =
       PlatformSharedBuffer::CreateFromSharedMemoryHandle(num_bytes, read_only,
                                                          shared_memory_handle);
   if (!platform_buffer)
     return MOJO_RESULT_UNKNOWN;
 
   scoped_refptr<SharedBufferDispatcher> dispatcher;
   MojoResult result = SharedBufferDispatcher::CreateFromPlatformSharedBuffer(
       platform_buffer, &dispatcher);
   if (result != MOJO_RESULT_OK)
@@ skipping 33 matching lines @@
       static_cast<SharedBufferDispatcher*>(dispatcher.get());
   scoped_refptr<PlatformSharedBuffer> platform_shared_buffer =
       shm_dispatcher->PassPlatformSharedBuffer();
 
   if (!platform_shared_buffer)
     return MOJO_RESULT_INVALID_ARGUMENT;
 
   if (num_bytes)
     *num_bytes = platform_shared_buffer->GetNumBytes();
   if (read_only)
-    *read_only = false;
+    *read_only = platform_shared_buffer->IsReadOnly();
   *shared_memory_handle = platform_shared_buffer->DuplicateSharedMemoryHandle();
 
   shm_dispatcher->Close();
   return result;
 }
 
 void Core::RequestShutdown(const base::Closure& callback) {
   base::Closure on_shutdown;
   if (base::ThreadTaskRunnerHandle::IsSet()) {
     on_shutdown = base::Bind(base::IgnoreResult(&base::TaskRunner::PostTask),
@@ skipping 636 matching lines @@
     scoped_ptr<NodeController> node_controller) {
   // It's OK to leak this reference. At this point we know the IO loop is still
   // running, and we know the NodeController will observe its eventual
   // destruction. This tells the NodeController to delete itself when that
   // happens.
   node_controller.release()->DestroyOnIOThreadShutdown();
 }
 
 }  // namespace edk
 }  // namespace mojo