PPAPI/NaCl: Make NaClIPCAdapter transfer handles more generally

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>
 
+#include "base/logging.h"
 #include "base/shared_memory.h"
 #include "build/build_config.h"
 #include "ipc/ipc_platform_file.h"
 #include "ppapi/c/pp_bool.h"
 #include "ppapi/c/pp_instance.h"
 #include "ppapi/c/pp_point.h"
 #include "ppapi/c/pp_rect.h"
 #include "ppapi/proxy/serialized_var.h"
 #include "ppapi/shared_impl/host_resource.h"
 
+class Pickle;
 struct PP_FontDescription_Dev;
 
 namespace ppapi {
 namespace proxy {
 
 class Dispatcher;
 
 // PP_FontDescript_Dev has to be redefined with a SerializedVar in place of
 // the PP_Var used for the face name.
 struct PPAPI_PROXY_EXPORT SerializedFontDescription {
@@ skipping 63 matching lines @@
   int64_t bytes_received;
   int64_t total_bytes_to_be_received;
 };
 
 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 };
+  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);
+
+  Type type() const { return type_; }
+  bool is_shmem() const { return type_ == SHARED_MEMORY; }
+  bool is_socket() const { return type_ == SOCKET; }
+  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());
+    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_null_shmem() {
+    set_shmem(base::SharedMemory::NULLHandle(), 0);
+  }
+  void set_null_socket() {
+    set_socket(IPC::InvalidPlatformFileForTransit());
+  }
+  bool IsHandleValid() const;
+
+  // Write all the data except the handle to the given pickle. This allows us
+  // to write the handle in a platform-specific way, as is necessary in
+  // NaClIPCAdapter to share handles with NaCl from Windows.
+  bool WriteHeader(Pickle* pickle) const;
+
+ 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.
+  IPC::PlatformFileForTransit descriptor_;
+};
+
 #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_