dbus: add support for passing file descriptors

dbus/message.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 DBUS_MESSAGE_H_
 #define DBUS_MESSAGE_H_
 #pragma once
 
 #include <string>
 #include <vector>
 #include <dbus/dbus.h>
 
 #include "base/basictypes.h"
+#include "dbus/file_descriptor.h"
 #include "dbus/object_path.h"
 
 namespace google {
 namespace protobuf {
 
 class MessageLite;
 
 }  // namespace protobuf
 }  // namespace google
 
 
 namespace dbus {
 
 class MessageWriter;
 class MessageReader;
 
+// DBUS_TYPE_UNIX_FD was added in D-Bus version 1.4
+#if defined(DBUS_TYPE_UNIX_FD)
+const bool kDBusTypeUnixFdIsSupported = true;
+#else
+const bool kDBusTypeUnixFdIsSupported = false;
+#define DBUS_TYPE_UNIX_FD      ((int) 'h')
+#endif
+
 // Message is the base class of D-Bus message types. Client code must use
 // sub classes such as MethodCall and Response instead.
 //
 // The class name Message is very generic, but there should be no problem
 // as the class is inside 'dbus' namespace. We chose to name this way, as
 // libdbus defines lots of types starting with DBus, such as
 // DBusMessage. We should avoid confusion and conflict with these types.
 class Message {
  public:
   // The message type used in D-Bus.  Redefined here so client code
@@ skipping 20 matching lines @@
     UINT32 = DBUS_TYPE_UINT32,
     INT64 = DBUS_TYPE_INT64,
     UINT64 = DBUS_TYPE_UINT64,
     DOUBLE = DBUS_TYPE_DOUBLE,
     STRING = DBUS_TYPE_STRING,
     OBJECT_PATH = DBUS_TYPE_OBJECT_PATH,
     ARRAY = DBUS_TYPE_ARRAY,
     STRUCT = DBUS_TYPE_STRUCT,
     DICT_ENTRY = DBUS_TYPE_DICT_ENTRY,
     VARIANT = DBUS_TYPE_VARIANT,
+    UNIX_FD = DBUS_TYPE_UNIX_FD,
   };
 
   // Returns the type of the message. Returns MESSAGE_INVALID if
   // raw_message_ is NULL.
   MessageType GetMessageType();
 
   // Returns the type of the message as string like "MESSAGE_METHOD_CALL"
   // for instance.
   std::string GetMessageTypeAsString();
 
@@ skipping 181 matching lines @@
   void AppendBool(bool value);
   void AppendInt16(int16 value);
   void AppendUint16(uint16 value);
   void AppendInt32(int32 value);
   void AppendUint32(uint32 value);
   void AppendInt64(int64 value);
   void AppendUint64(uint64 value);
   void AppendDouble(double value);
   void AppendString(const std::string& value);
   void AppendObjectPath(const ObjectPath& value);
+  void AppendFileDescriptor(const FileDescriptor& value);
 
   // Opens an array. The array contents can be added to the array with
   // |sub_writer|. The client code must close the array with
   // CloseContainer(), once all contents are added.
   //
   // |signature| parameter is used to supply the D-Bus type signature of
   // the array contents. For instance, if you want an array of strings,
   // then you pass "s" as the signature.
   //
   // See the spec for details about the type signatures.
@@ skipping 89 matching lines @@
   bool PopBool(bool* value);
   bool PopInt16(int16* value);
   bool PopUint16(uint16* value);
   bool PopInt32(int32* value);
   bool PopUint32(uint32* value);
   bool PopInt64(int64* value);
   bool PopUint64(uint64* value);
   bool PopDouble(double* value);
   bool PopString(std::string* value);
   bool PopObjectPath(ObjectPath* value);
+  bool PopFileDescriptor(FileDescriptor* value);
 
   // Sets up the given message reader to read an array at the current
   // iterator position.
   // Returns true and advances the iterator on success.
   // Returns false if the data type is not an array
   bool PopArray(MessageReader* sub_reader);
   bool PopStruct(MessageReader* sub_reader);
   bool PopDictEntry(MessageReader* sub_reader);
   bool PopVariant(MessageReader* sub_reader);
 
@@ skipping 71 matching lines @@
 
   Message* message_;
   DBusMessageIter raw_message_iter_;
 
   DISALLOW_COPY_AND_ASSIGN(MessageReader);
 };
 
 }  // namespace dbus
 
 #endif  // DBUS_MESSAGE_H_