Mojo: Implement passing of shared buffers across processes on POSIX.

mojo/system/shared_buffer_dispatcher.h

 // 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.
 
 #ifndef MOJO_SYSTEM_SHARED_BUFFER_DISPATCHER_H_
 #define MOJO_SYSTEM_SHARED_BUFFER_DISPATCHER_H_
 
 #include "base/macros.h"
 #include "mojo/system/raw_shared_buffer.h"
 #include "mojo/system/simple_dispatcher.h"
@@ skipping 17 matching lines @@
   // Static factory method: |validated_options| must be validated (obviously).
   // On failure, |*result| will be left as-is.
   static MojoResult Create(
       const MojoCreateSharedBufferOptions& validated_options,
       uint64_t num_bytes,
       scoped_refptr<SharedBufferDispatcher>* result);
 
   // |Dispatcher| public methods:
   virtual Type GetType() const OVERRIDE;
 
+  // The "opposite" of |SerializeAndClose()|. (Typically this is called by
+  // |Dispatcher::Deserialize()|.)
+  static scoped_refptr<SharedBufferDispatcher> Deserialize(
+      Channel* channel,
+      const void* source,
+      size_t size,
+      embedder::PlatformHandleVector* platform_handles);
+
  private:
   explicit SharedBufferDispatcher(
       scoped_refptr<RawSharedBuffer> shared_buffer_);
   virtual ~SharedBufferDispatcher();
 
   // |Dispatcher| protected methods:
   virtual void CloseImplNoLock() OVERRIDE;
   virtual scoped_refptr<Dispatcher>
       CreateEquivalentDispatcherAndCloseImplNoLock() OVERRIDE;
   virtual MojoResult DuplicateBufferHandleImplNoLock(
       const MojoDuplicateBufferHandleOptions* options,
       scoped_refptr<Dispatcher>* new_dispatcher) OVERRIDE;
   virtual MojoResult MapBufferImplNoLock(
       uint64_t offset,
       uint64_t num_bytes,
       MojoMapBufferFlags flags,
       scoped_ptr<RawSharedBufferMapping>* mapping) OVERRIDE;
+  virtual void StartSerializeImplNoLock(Channel* channel,
+                                        size_t* max_size,
+                                        size_t* max_platform_handles) OVERRIDE;
+  virtual bool EndSerializeAndCloseImplNoLock(
+      Channel* channel,
+      void* destination,
+      size_t* actual_size,
+      embedder::PlatformHandleVector* platform_handles) OVERRIDE;
 
   // |SimpleDispatcher| methods:
   virtual MojoWaitFlags SatisfiedFlagsNoLock() const OVERRIDE;
   virtual MojoWaitFlags SatisfiableFlagsNoLock() const OVERRIDE;
 
   scoped_refptr<RawSharedBuffer> shared_buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(SharedBufferDispatcher);
 };
 
 }  // namespace system
 }  // namespace mojo
 
 #endif  // MOJO_SYSTEM_SHARED_BUFFER_DISPATCHER_H_