Mojo: Add Dispatcher::{DuplicateBufferHandle,MapBuffer} methods.

mojo/system/dispatcher.h

 // 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.
 
 #ifndef MOJO_SYSTEM_DISPATCHER_H_
 #define MOJO_SYSTEM_DISPATCHER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 73 matching lines @@
                             uint32_t* buffer_num_bytes,
                             MojoWriteDataFlags flags);
   MojoResult EndWriteData(uint32_t num_bytes_written);
   MojoResult ReadData(void* elements,
                       uint32_t* num_bytes,
                       MojoReadDataFlags flags);
   MojoResult BeginReadData(const void** buffer,
                            uint32_t* buffer_num_bytes,
                            MojoReadDataFlags flags);
   MojoResult EndReadData(uint32_t num_bytes_read);
+  // |options| may be null. |new_dispatcher| must not be null, but
+  // |*new_dispatcher| should be null (and will contain the dispatcher for the
+  // new handle on success).
+  MojoResult DuplicateBufferHandle(
+      const MojoDuplicateBufferHandleOptions* options,
+      scoped_refptr<Dispatcher>* new_dispatcher);
+  MojoResult MapBuffer(uint64_t offset,
+                       uint64_t num_bytes,
+                       void** buffer,
+                       MojoMapBufferFlags flags);
 
   // Adds a waiter to this dispatcher. The waiter will be woken up when this
   // object changes state to satisfy |flags| with result |wake_result| (which
   // must be >= 0, i.e., a success status). It will also be woken up when it
   // becomes impossible for the object to ever satisfy |flags| with a suitable
   // error status.
   //
   // Returns:
   //  - |MOJO_RESULT_OK| if the waiter was added;
   //  - |MOJO_RESULT_ALREADY_EXISTS| if |flags| is already satisfied;
@@ skipping 61 matching lines @@
                                               uint32_t* buffer_num_bytes,
                                               MojoWriteDataFlags flags);
   virtual MojoResult EndWriteDataImplNoLock(uint32_t num_bytes_written);
   virtual MojoResult ReadDataImplNoLock(void* elements,
                                         uint32_t* num_bytes,
                                         MojoReadDataFlags flags);
   virtual MojoResult BeginReadDataImplNoLock(const void** buffer,
                                              uint32_t* buffer_num_bytes,
                                              MojoReadDataFlags flags);
   virtual MojoResult EndReadDataImplNoLock(uint32_t num_bytes_read);
+  virtual MojoResult DuplicateBufferHandleImplNoLock(
+      const MojoDuplicateBufferHandleOptions* options,
+      scoped_refptr<Dispatcher>* new_dispatcher);
+  virtual MojoResult MapBufferImplNoLock(uint64_t offset,
+                                         uint64_t num_bytes,
+                                         void** buffer,
+                                         MojoMapBufferFlags flags);
   virtual MojoResult AddWaiterImplNoLock(Waiter* waiter,
                                          MojoWaitFlags flags,
                                          MojoResult wake_result);
   virtual void RemoveWaiterImplNoLock(Waiter* waiter);
 
   // Available to subclasses. (Note: Returns a non-const reference, just like
   // |base::AutoLock|'s constructor takes a non-const reference.)
   base::Lock& lock() const { return lock_; }
 
  private:
@@ skipping 65 matching lines @@
 inline DispatcherTransport DispatcherTryStartTransport(Dispatcher* dispatcher) {
   return Dispatcher::CoreImplAccess::TryStartTransport(dispatcher);
 }
 
 }  // namespace test
 
 }  // namespace system
 }  // namespace mojo
 
 #endif  // MOJO_SYSTEM_DISPATCHER_H_