Mojo: Add a platform interface for shared memory (embedder::PlatformSharedBuffer).

mojo/system/shared_buffer_dispatcher.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/system/shared_buffer_dispatcher.h"
 
 #include <limits>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 52 matching lines @@
 // static
 MojoResult SharedBufferDispatcher::Create(
     const MojoCreateSharedBufferOptions& /*validated_options*/,
     uint64_t num_bytes,
     scoped_refptr<SharedBufferDispatcher>* result) {
   if (!num_bytes)
     return MOJO_RESULT_INVALID_ARGUMENT;
   if (num_bytes > kMaxSharedMemoryNumBytes)
     return MOJO_RESULT_RESOURCE_EXHAUSTED;
 
-  scoped_refptr<RawSharedBuffer> shared_buffer(
+  // TODO(vtl): Call out to "platform support" for this.
+  scoped_refptr<embedder::PlatformSharedBuffer> shared_buffer(
       RawSharedBuffer::Create(static_cast<size_t>(num_bytes)));
   if (!shared_buffer)
     return MOJO_RESULT_RESOURCE_EXHAUSTED;
 
   *result = new SharedBufferDispatcher(shared_buffer);
   return MOJO_RESULT_OK;
 }
 
 Dispatcher::Type SharedBufferDispatcher::GetType() const {
   return kTypeSharedBuffer;
@@ skipping 28 matching lines @@
   }
 
   // Starts off invalid, which is what we want.
   embedder::PlatformHandle platform_handle;
   // We take ownership of the handle, so we have to invalidate the one in
   // |platform_handles|.
   std::swap(platform_handle, (*platform_handles)[platform_handle_index]);
 
   // Wrapping |platform_handle| in a |ScopedPlatformHandle| means that it'll be
   // closed even if creation fails.
-  scoped_refptr<RawSharedBuffer> shared_buffer(
+  scoped_refptr<embedder::PlatformSharedBuffer> shared_buffer(
       RawSharedBuffer::CreateFromPlatformHandle(
           num_bytes, embedder::ScopedPlatformHandle(platform_handle)));
   if (!shared_buffer) {
     LOG(ERROR)
         << "Invalid serialized shared buffer dispatcher (invalid num_bytes?)";
     return scoped_refptr<SharedBufferDispatcher>();
   }
 
   return scoped_refptr<SharedBufferDispatcher>(
       new SharedBufferDispatcher(shared_buffer));
 }
 
 SharedBufferDispatcher::SharedBufferDispatcher(
-    scoped_refptr<RawSharedBuffer> shared_buffer)
+    scoped_refptr<embedder::PlatformSharedBuffer> shared_buffer)
     : shared_buffer_(shared_buffer) {
   DCHECK(shared_buffer_);
 }
 
 SharedBufferDispatcher::~SharedBufferDispatcher() {
 }
 
 // static
 MojoResult SharedBufferDispatcher::ValidateDuplicateOptions(
     UserPointer<const MojoDuplicateBufferHandleOptions> in_options,
@@ skipping 29 matching lines @@
 void SharedBufferDispatcher::CloseImplNoLock() {
   lock().AssertAcquired();
   DCHECK(shared_buffer_);
   shared_buffer_ = NULL;
 }
 
 scoped_refptr<Dispatcher>
 SharedBufferDispatcher::CreateEquivalentDispatcherAndCloseImplNoLock() {
   lock().AssertAcquired();
   DCHECK(shared_buffer_);
-  scoped_refptr<RawSharedBuffer> shared_buffer;
+  scoped_refptr<embedder::PlatformSharedBuffer> shared_buffer;
   shared_buffer.swap(shared_buffer_);
   return scoped_refptr<Dispatcher>(new SharedBufferDispatcher(shared_buffer));
 }
 
 MojoResult SharedBufferDispatcher::DuplicateBufferHandleImplNoLock(
     UserPointer<const MojoDuplicateBufferHandleOptions> options,
     scoped_refptr<Dispatcher>* new_dispatcher) {
   lock().AssertAcquired();
 
   MojoDuplicateBufferHandleOptions validated_options;
   MojoResult result = ValidateDuplicateOptions(options, &validated_options);
   if (result != MOJO_RESULT_OK)
     return result;
 
   *new_dispatcher = new SharedBufferDispatcher(shared_buffer_);
   return MOJO_RESULT_OK;
 }
 
 MojoResult SharedBufferDispatcher::MapBufferImplNoLock(
     uint64_t offset,
     uint64_t num_bytes,
     MojoMapBufferFlags flags,
-    scoped_ptr<RawSharedBufferMapping>* mapping) {
+    scoped_ptr<embedder::PlatformSharedBufferMapping>* mapping) {
   lock().AssertAcquired();
   DCHECK(shared_buffer_);
 
   if (offset > static_cast<uint64_t>(std::numeric_limits<size_t>::max()))
     return MOJO_RESULT_INVALID_ARGUMENT;
   if (num_bytes > static_cast<uint64_t>(std::numeric_limits<size_t>::max()))
     return MOJO_RESULT_INVALID_ARGUMENT;
 
   if (!shared_buffer_->IsValidMap(static_cast<size_t>(offset),
                                   static_cast<size_t>(num_bytes)))
@@ skipping 31 matching lines @@
   // one else can make any more references to it), so we can just take its
   // handle.
   embedder::ScopedPlatformHandle platform_handle(
       shared_buffer_->HasOneRef() ? shared_buffer_->PassPlatformHandle()
                                   : shared_buffer_->DuplicatePlatformHandle());
   if (!platform_handle.is_valid()) {
     shared_buffer_ = NULL;
     return false;
   }
 
-  serialization->num_bytes = shared_buffer_->num_bytes();
+  serialization->num_bytes = shared_buffer_->GetNumBytes();
   serialization->platform_handle_index = platform_handles->size();
   platform_handles->push_back(platform_handle.release());
   *actual_size = sizeof(SerializedSharedBufferDispatcher);
 
   shared_buffer_ = NULL;
 
   return true;
 }
 
 }  // namespace system
 }  // namespace mojo