Update mojo sdk to rev e01f9a49449381a5eb430c1fd88bf2cae73ec35a

mojo/edk/system/message_pipe.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_EDK_SYSTEM_MESSAGE_PIPE_H_
 #define MOJO_EDK_SYSTEM_MESSAGE_PIPE_H_
 
+#include <stddef.h>
 #include <stdint.h>
 
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/synchronization/lock.h"
+#include "mojo/edk/embedder/platform_handle_vector.h"
 #include "mojo/edk/system/dispatcher.h"
 #include "mojo/edk/system/handle_signals_state.h"
 #include "mojo/edk/system/memory.h"
 #include "mojo/edk/system/message_in_transit.h"
 #include "mojo/edk/system/message_pipe_endpoint.h"
 #include "mojo/edk/system/system_impl_export.h"
 #include "mojo/public/c/system/message_pipe.h"
 #include "mojo/public/c/system/types.h"
 
 namespace mojo {
 namespace system {
 
+class Channel;
 class ChannelEndpoint;
 class Waiter;
 
 // |MessagePipe| is the secondary object implementing a message pipe (see the
 // explanatory comment in core.cc). It is typically owned by the dispatcher(s)
 // corresponding to the local endpoints. This class is thread-safe.
 class MOJO_SYSTEM_IMPL_EXPORT MessagePipe
     : public base::RefCountedThreadSafe<MessagePipe> {
  public:
   // Creates a |MessagePipe| with two new |LocalMessagePipeEndpoint|s.
@@ skipping 10 matching lines @@
   // (newly-created) |ChannelEndpoint| for the former.
   // Note: This is really only needed in tests (outside of tests, this
   // configuration arises from a local message pipe having its port 0
   // "converted" using |ConvertLocalToProxy()|).
   static MessagePipe* CreateProxyLocal(
       scoped_refptr<ChannelEndpoint>* channel_endpoint);
 
   // Gets the other port number (i.e., 0 -> 1, 1 -> 0).
   static unsigned GetPeerPort(unsigned port);
 
+  // Used by |MessagePipeDispatcher::Deserialize()|. Returns true on success (in
+  // which case, |*message_pipe|/|*port| are set appropriately) and false on
+  // failure (in which case |*message_pipe| may or may not be set to null).
+  static bool Deserialize(Channel* channel,
+                          const void* source,
+                          size_t size,
+                          scoped_refptr<MessagePipe>* message_pipe,
+                          unsigned* port);
+
   // Gets the type of the endpoint (used for assertions, etc.).
   MessagePipeEndpoint::Type GetType(unsigned port);
 
   // These are called by the dispatcher to implement its methods of
   // corresponding names. In all cases, the port |port| must be open.
   void CancelAllWaiters(unsigned port);
   void Close(unsigned port);
   // Unlike |MessagePipeDispatcher::WriteMessage()|, this does not validate its
   // arguments.
   MojoResult WriteMessage(unsigned port,
                           UserPointer<const void> bytes,
                           uint32_t num_bytes,
                           std::vector<DispatcherTransport>* transports,
                           MojoWriteMessageFlags flags);
   MojoResult ReadMessage(unsigned port,
                          UserPointer<void> bytes,
                          UserPointer<uint32_t> num_bytes,
                          DispatcherVector* dispatchers,
                          uint32_t* num_dispatchers,
                          MojoReadMessageFlags flags);
   HandleSignalsState GetHandleSignalsState(unsigned port) const;
   MojoResult AddWaiter(unsigned port,
                        Waiter* waiter,
                        MojoHandleSignals signals,
                        uint32_t context,
                        HandleSignalsState* signals_state);
   void RemoveWaiter(unsigned port,
                     Waiter* waiter,
                     HandleSignalsState* signals_state);
+  void StartSerialize(unsigned port,
+                      Channel* channel,
+                      size_t* max_size,
+                      size_t* max_platform_handles);
+  bool EndSerialize(unsigned port,
+                    Channel* channel,
+                    void* destination,
+                    size_t* actual_size,
+                    embedder::PlatformHandleVector* platform_handles);
 
-  // This is called by the dispatcher to convert a local endpoint to a proxy
-  // endpoint.
+  // Used by |EndSerialize()|. TODO(vtl): Remove this (merge it into
+  // |EndSerialize()|).
   scoped_refptr<ChannelEndpoint> ConvertLocalToProxy(unsigned port);
 
   // This is used by |Channel| to enqueue messages (typically to a
   // |LocalMessagePipeEndpoint|). Unlike |WriteMessage()|, |port| is the
   // *destination* port.
   MojoResult EnqueueMessage(unsigned port,
                             scoped_ptr<MessageInTransit> message);
 
  private:
   MessagePipe();
@@ skipping 23 matching lines @@
   base::Lock lock_;  // Protects the following members.
   scoped_ptr<MessagePipeEndpoint> endpoints_[2];
 
   DISALLOW_COPY_AND_ASSIGN(MessagePipe);
 };
 
 }  // namespace system
 }  // namespace mojo
 
 #endif  // MOJO_EDK_SYSTEM_MESSAGE_PIPE_H_