POSIX: Rewrite IPC's interaction with FileDescriptor

chrome/common/ipc_message_utils.h

 // Copyright (c) 2006-2008 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 CHROME_COMMON_IPC_MESSAGE_UTILS_H_
 #define CHROME_COMMON_IPC_MESSAGE_UTILS_H_
 
 #include <string>
 #include <vector>
 #include <map>
 
 #include "base/file_path.h"
 #include "base/string_util.h"
 #include "base/string16.h"
 #include "base/tuple.h"
 #if defined(OS_POSIX)
 #include "chrome/common/file_descriptor_set_posix.h"
 #endif
-#include "chrome/common/ipc_maybe.h"
 #include "chrome/common/ipc_sync_message.h"
 #include "chrome/common/thumbnail_score.h"
 #include "chrome/common/transport_dib.h"
 #include "webkit/glue/cache_manager.h"
 #include "webkit/glue/console_message_level.h"
 #include "webkit/glue/find_in_page_request.h"
 #include "webkit/glue/webcursor.h"
 #include "webkit/glue/window_open_disposition.h"
 
 // Forward declarations.
@@ skipping 657 matching lines @@
 
 template <>
 struct ParamTraits<gfx::Size> {
   typedef gfx::Size param_type;
   static void Write(Message* m, const param_type& p);
   static bool Read(const Message* m, void** iter, param_type* r);
   static void Log(const param_type& p, std::wstring* l);
 };
 
 #if defined(OS_POSIX)
+// FileDescriptors may be serialised over IPC channels on POSIX. On the
+// receiving side, the FileDescriptor is a valid duplicate of the file
+// descriptor which was transmitted: *it is not just a copy of the integer like
+// HANDLEs on Windows*. The only exception is if the file descriptor is < 0. In
+// this case, the receiving end will see a value of -1. *Zero is a valid file
+// descriptor*.
+//
+// The received file descriptor will have the |auto_close| flag set to true. The
+// code which handles the message is responsible for taking ownership of it.
+// File descriptors are OS resources and must be closed when no longer needed.
+//
+// When sending a file descriptor, the file descriptor must be valid at the time
+// of transmission. Since transmission is not synchronous, one should consider
+// dup()ing any file descriptors to be transmitted and setting the |auto_close|
+// flag, which causes the file descriptor to be closed after writing.
 template<>
 struct ParamTraits<base::FileDescriptor> {
   typedef base::FileDescriptor param_type;
   static void Write(Message* m, const param_type& p) {
-    if (!m->WriteFileDescriptor(p))
-      NOTREACHED();
+    const bool valid = p.fd >= 0;
+    WriteParam(m, valid);
+
+    if (valid) {
+      if (!m->WriteFileDescriptor(p))
+        NOTREACHED();
+    }
   }
   static bool Read(const Message* m, void** iter, param_type* r) {
-    return m->ReadFileDescriptor(iter, r);
+    bool valid;
+    if (!ReadParam(m, iter, &valid))
+      return false;
+
+    if (valid) {
+      return m->ReadFileDescriptor(iter, r);
+    } else {

[darin (slow to review), 2009/03/05 19:42:12]

nit: no need for else after return

+      r->fd = -1;
+      r->auto_close = false;
+      return true;
+    }
   }
   static void Log(const param_type& p, std::wstring* l) {
     if (p.auto_close) {
       l->append(StringPrintf(L"FD(%d auto-close)", p.fd));
     } else {
       l->append(StringPrintf(L"FD(%d)", p.fd));
     }
   }
 };
 #endif // defined(OS_POSIX)
@@ skipping 224 matching lines @@
   static void Log(const param_type& p, std::wstring* l) {
     l->append(L"TransportDIB(");
     LogParam(p.handle, l);
     l->append(L", ");
     LogParam(p.sequence_num, l);
     l->append(L")");
   }
 };
 #endif
 
-template<typename A>
-struct ParamTraits<Maybe<A> > {
-  typedef struct Maybe<A> param_type;
-  static void Write(Message* m, const param_type& p) {
-    WriteParam(m, p.valid);
-    if (p.valid)
-      WriteParam(m, p.value);
-  }
-  static bool Read(const Message* m, void** iter, param_type* r) {
-    if (!ReadParam(m, iter, &r->valid))
-      return false;
-
-    if (r->valid)
-      return ReadParam(m, iter, &r->value);
-    return true;
-  }
-  static void Log(const param_type& p, std::wstring* l) {
-    if (p.valid) {
-      l->append(L"Just ");
-      ParamTraits<A>::Log(p.value, l);
-    } else {
-      l->append(L"Nothing");
-    }
-
-  }
-};
-
-
 template <>
 struct ParamTraits<Message> {
   static void Write(Message* m, const Message& p) {
     m->WriteInt(p.size());
     m->WriteData(reinterpret_cast<const char*>(p.data()), p.size());
   }
   static bool Read(const Message* m, void** iter, Message* r) {
     int size;
     if (!m->ReadInt(iter, &size))
       return false;
     const char* data;
     if (!m->ReadData(iter, &data, &size))
       return false;
     *r = Message(data, size);
     return true;
   }
   static void Log(const Message& p, std::wstring* l) {
     l->append(L"<IPC::Message>");
   }
 };
 
-
 template <>
 struct ParamTraits<Tuple0> {
   typedef Tuple0 param_type;
   static void Write(Message* m, const param_type& p) {
   }
   static bool Read(const Message* m, void** iter, param_type* r) {
     return true;
   }
   static void Log(const param_type& p, std::wstring* l) {
   }
@@ skipping 457 matching lines @@
     l->append(L"<FindInPageRequest>");
   }
 };
 
 //-----------------------------------------------------------------------------
 
 }  // namespace IPC
 
 #endif  // CHROME_COMMON_IPC_MESSAGE_UTILS_H_