[mojo-edk] Explicitly serialise HANDLEs into messages instead of PlatformHandles.

mojo/edk/system/channel.h

 // Copyright 2016 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_CHANNEL_H_
 #define MOJO_EDK_SYSTEM_CHANNEL_H_
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
@@ skipping 73 matching lines @@
     struct MachPortsExtraHeader {
       // Actual number of Mach ports encoded in the extra header.
       uint16_t num_ports;
 
       // Array of encoded Mach ports. If |num_ports| > 0, |entires[0]| through
       // to |entries[num_ports-1]| inclusive are valid.
       MachPortsEntry entries[0];
     };
     static_assert(sizeof(MachPortsExtraHeader) == 2,
                   "sizeof(MachPortsExtraHeader) must be 2 bytes");
+#elif defined(OS_WIN)
+    struct HandleEntry {
+      // The windows HANDLE. HANDLEs are guaranteed to fit inside 32-bits.
+      // See: https://msdn.microsoft.com/en-us/library/aa384203(VS.85).aspx
+      uint32_t handle;
+    };
+    static_assert(sizeof(HandleEntry) == 4,
+                  "sizeof(HandleEntry) must be 4 bytes");
 #endif
 #pragma pack(pop)
 
     // Allocates and owns a buffer for message data with enough capacity for
     // |payload_size| bytes plus a header, plus |max_handles| platform handles.
     Message(size_t payload_size,
             size_t max_handles,
             Header::MessageType message_type = Header::MessageType::NORMAL);
 
     ~Message();
@@ skipping 17 matching lines @@
       return header_->num_header_bytes - sizeof(Header);
     }
 
     void* mutable_payload() { return data_ + header_->num_header_bytes; }
     const void* payload() const { return data_ + header_->num_header_bytes; }
     size_t payload_size() const;
 #endif  // defined(OS_CHROMEOS) || defined(OS_ANDROID)
 
     size_t num_handles() const { return header_->num_handles; }
     bool has_handles() const { return header_->num_handles > 0; }
-    PlatformHandle* handles();
 #if defined(OS_MACOSX) && !defined(OS_IOS)
     bool has_mach_ports() const;
 #endif
 
     // Note: SetHandles() and TakeHandles() invalidate any previous value of
     // handles().
     void SetHandles(ScopedPlatformHandleVectorPtr new_handles);
     ScopedPlatformHandleVectorPtr TakeHandles();
     // Version of TakeHandles that returns a vector of platform handles suitable
     // for transfer over an underlying OS mechanism. i.e. file descriptors over
     // a unix domain socket. Any handle that cannot be transferred this way,
     // such as Mach ports, will be removed.
     ScopedPlatformHandleVectorPtr TakeHandlesForTransport();
 
 #if defined(OS_WIN)
     // Prepares the handles in this message for use in a different process.
     // Upon calling this the handles should belong to |from_process|; after the
     // call they'll belong to |to_process|. The source handles are always
     // closed by this call. Returns false iff one or more handles failed
     // duplication.
     static bool RewriteHandles(base::ProcessHandle from_process,
                                base::ProcessHandle to_process,
-                               PlatformHandle* handles,
-                               size_t num_handles);
+                               PlatformHandleVector* handles);
 #endif
 
    private:
     size_t size_;
     size_t max_handles_;
     char* data_;
     Header* header_;
 
+    ScopedPlatformHandleVectorPtr handle_vector_;
+
 #if defined(OS_WIN)
     // On Windows, handles are serialised into the extra header section.
-    PlatformHandle* handles_ = nullptr;
-#else
-    ScopedPlatformHandleVectorPtr handle_vector_;
-#endif
-
-#if defined(OS_MACOSX) && !defined(OS_IOS)
+    HandleEntry* handles_ = nullptr;
+#elif defined(OS_MACOSX) && !defined(OS_IOS)
     // On OSX, handles are serialised into the extra header section.
     MachPortsExtraHeader* mach_ports_header_ = nullptr;
 #endif
 
     DISALLOW_COPY_AND_ASSIGN(Message);
   };
 
   // Delegate methods are called from the I/O task runner with which the Channel
   // was created (see Channel::Create).
   class Delegate {
@@ skipping 93 matching lines @@
   Delegate* delegate_;
   const std::unique_ptr<ReadBuffer> read_buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(Channel);
 };
 
 }  // namespace edk
 }  // namespace mojo
 
 #endif  // MOJO_EDK_SYSTEM_CHANNEL_H_