Change NaCl IPC PPAPI proxy startup to support a NaCl-Browser process

ppapi/proxy/serialized_structs.h

 // Copyright (c) 2012 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 PPAPI_PROXY_SERIALIZED_STRUCTS_H_
 #define PPAPI_PROXY_SERIALIZED_STRUCTS_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 89 matching lines @@
 struct PPPVideoCapture_Buffer {
   ppapi::HostResource resource;
   uint32_t size;
   base::SharedMemoryHandle handle;
 };
 
 // We put all our handles in a unified structure to make it easy to translate
 // them in NaClIPCAdapter for use in NaCl.
 class PPAPI_PROXY_EXPORT SerializedHandle {
  public:
-  enum Type { INVALID, SHARED_MEMORY, SOCKET };
+  enum Type { INVALID, SHARED_MEMORY, SOCKET, CHANNEL_HANDLE };
   struct Header {
     Header() : type(INVALID), size(0) {}
     Header(Type type_arg, uint32_t size_arg)
         : type(type_arg), size(size_arg) {
     }
     Type type;
     uint32_t size;
   };
 
   SerializedHandle();
   // Create an invalid handle of the given type.
   explicit SerializedHandle(Type type);
 
   // Create a shared memory handle.
   SerializedHandle(const base::SharedMemoryHandle& handle, uint32_t size);
 
-  // Create a socket handle.
-  // TODO(dmichael): If we have other ways to use FDs later, this would be
-  //                 ambiguous.
-  explicit SerializedHandle(
-      const IPC::PlatformFileForTransit& socket_descriptor);
+  // Create a socket or channel handle.
+  SerializedHandle(const Type type,
+                   const IPC::PlatformFileForTransit& descriptor);
 
   Type type() const { return type_; }
   bool is_shmem() const { return type_ == SHARED_MEMORY; }
   bool is_socket() const { return type_ == SOCKET; }
+  bool is_channel_handle() const { return type_ == CHANNEL_HANDLE; }
   const base::SharedMemoryHandle& shmem() const {
     DCHECK(is_shmem());
     return shm_handle_;
   }
   uint32_t size() const {
     DCHECK(is_shmem());
     return size_;
   }
   const IPC::PlatformFileForTransit& descriptor() const {
-    DCHECK(is_socket());
+    DCHECK(is_socket() || is_channel_handle());
     return descriptor_;
   }
   void set_shmem(const base::SharedMemoryHandle& handle, uint32_t size) {
     type_ = SHARED_MEMORY;
     shm_handle_ = handle;
     size_ = size;
 
     descriptor_ = IPC::InvalidPlatformFileForTransit();
   }
   void set_socket(const IPC::PlatformFileForTransit& socket) {
     type_ = SOCKET;
     descriptor_ = socket;
 
     shm_handle_ = base::SharedMemory::NULLHandle();
     size_ = 0;
   }
+  void set_channel_handle(const IPC::PlatformFileForTransit& descriptor) {
+    type_ = CHANNEL_HANDLE;
+
+    descriptor_ = descriptor;
+    shm_handle_ = base::SharedMemory::NULLHandle();
+    size_ = 0;
+  }
   void set_null_shmem() {
     set_shmem(base::SharedMemory::NULLHandle(), 0);
   }
   void set_null_socket() {
     set_socket(IPC::InvalidPlatformFileForTransit());
   }
+  void set_null_channel_handle() {
+    set_channel_handle(IPC::InvalidPlatformFileForTransit());
+  }
   bool IsHandleValid() const;
 
   Header header() const {
     return Header(type_, size_);
   }
 
   // Write/Read a Header, which contains all the data except the handle. This
   // allows us to write the handle in a platform-specific way, as is necessary
   // in NaClIPCAdapter to share handles with NaCl from Windows.
   static bool WriteHeader(const Header& hdr, Pickle* pickle);
   static bool ReadHeader(PickleIterator* iter, Header* hdr);
 
  private:
   // The kind of handle we're holding.
   Type type_;
 
   // We hold more members than we really need; we can't easily use a union,
   // because we hold non-POD types. But these types are pretty light-weight. If
   // we add more complex things later, we should come up with a more memory-
   // efficient strategy.
   // These are valid if type == SHARED_MEMORY.
   base::SharedMemoryHandle shm_handle_;
   uint32_t size_;
 
-  // This is valid if type == SOCKET.
+  // This is valid if type == SOCKET || type == CHANNEL_HANDLE.
   IPC::PlatformFileForTransit descriptor_;
 };
 
 // TODO(tomfinegan): This is identical to PPPVideoCapture_Buffer, maybe replace
 // both with a single type?
 struct PPPDecryptor_Buffer {
   ppapi::HostResource resource;
   uint32_t size;
   base::SharedMemoryHandle handle;
 };
 
 #if defined(OS_WIN)
 typedef HANDLE ImageHandle;
 #elif defined(OS_MACOSX) || defined(OS_ANDROID)
 typedef base::SharedMemoryHandle ImageHandle;
 #else
 // On X Windows this is a SysV shared memory key.
 typedef int ImageHandle;
 #endif
 
 }  // namespace proxy
 }  // namespace ppapi
 
 #endif  // PPAPI_PROXY_SERIALIZED_STRUCTS_H_