Mojo: (Theoretically) implement the read side of platform handle passing.

mojo/system/raw_channel.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_RAW_CHANNEL_H_
 #define MOJO_SYSTEM_RAW_CHANNEL_H_
 
 #include <deque>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/synchronization/lock.h"
+#include "mojo/embedder/platform_handle_vector.h"
 #include "mojo/embedder/scoped_platform_handle.h"
 #include "mojo/system/constants.h"
 #include "mojo/system/message_in_transit.h"
 #include "mojo/system/system_impl_export.h"
 
 namespace base {
 class MessageLoopForIO;
 }
 
 namespace mojo {
@@ skipping 67 matching lines @@
 
   // Returns true if the write buffer is empty (i.e., all messages written using
   // |WriteMessage()| have actually been sent.
   // TODO(vtl): We should really also notify our delegate when the write buffer
   // becomes empty (or something like that).
   bool IsWriteBufferEmpty();
 
   // Returns the amount of space needed in the |MessageInTransit|'s
   // |TransportData|'s "platform handle table" per platform handle (to be
   // attached to a message). (This amount may be zero.)
   virtual size_t GetSerializedPlatformHandleSize() const = 0;

[yzshen1, 2014/05/11 07:16:59]

I have the feeling that this method belongs to the platform handle
serialization/deserialization code. But I have no idea how that code interacts
with raw channel. (Please also see my comment in transport_data.h)

[viettrungluu, 2014/05/12 17:33:28]

It doesn't. Because there may be multiple ways of serializing a platform handle
(e.g., on Windows).

 
  protected:
   // Return values of |[Schedule]Read()| and |[Schedule]WriteNoLock()|.
   enum IOResult {
     IO_SUCCEEDED,
     IO_FAILED,
     IO_PENDING
   };
 
   class MOJO_SYSTEM_IMPL_EXPORT ReadBuffer {
@@ skipping 88 matching lines @@
   // The implementing subclass must guarantee that:
   // - |bytes_read| is untouched unless |Read()| returns |IO_SUCCEEDED|;
   // - if the method returns |IO_PENDING|, |OnReadCompleted()| will be called on
   //   the I/O thread to report the result, unless |Shutdown()| is called.
   virtual IOResult Read(size_t* bytes_read) = 0;
   // Similar to |Read()|, except that the implementing subclass must also
   // guarantee that the method doesn't succeed synchronously, i.e., it only
   // returns |IO_FAILED| or |IO_PENDING|.
   virtual IOResult ScheduleRead() = 0;
 
+  // Called by |OnReadCompleted()| to get the platform handles associated with
+  // the given platform handle table (from a message). This should only be
+  // called when |num_platform_handles| is nonzero. Returns null if the
+  // |num_platform_handles| handles are not available. Only called on the I/O
+  // thread (without |write_lock_| held).
+  virtual scoped_ptr<embedder::PlatformHandleVector> GetReadPlatformHandles(
+      size_t num_platform_handles,
+      const void* platform_handle_table) = 0;
+
   // Writes contents in |write_buffer_no_lock()|.
   // This class guarantees that:
   // - the |PlatformHandle|s given by |GetPlatformHandlesToSend()| and the
   //   buffer(s) given by |GetBuffers()| will remain valid until write
   //   completion (see also the comments for |OnShutdownNoLock()|);
   // - a second write is not started if there is a pending write;
   // - the method is called under |write_lock_|.
   //
   // The implementing subclass must guarantee that:
   // - |platform_handles_written| and |bytes_written| are untouched unless
@@ skipping 55 matching lines @@
   // are only used/invalidated on the I/O thread.
   base::WeakPtrFactory<RawChannel> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RawChannel);
 };
 
 }  // namespace system
 }  // namespace mojo
 
 #endif  // MOJO_SYSTEM_RAW_CHANNEL_H_