Adding support for sending/receiving proto bufs to dbus library.

dbus/message.h

 // Copyright (c) 2011 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 "third_party/protobuf/src/google/protobuf/message_lite.h"

[satorux1, 2012/01/31 21:42:31]

I think you can remove the include from .h file, by forward-declaring the class:

namespace google {
namespace protobuf {
class MessageLite;
}
}

Then have the #include line in .cc file.

This will speed up the build time for clients of dbus/message.h which don't use
protobuf

[rharrison, 2012/02/01 19:03:20]

Done.

 
 namespace dbus {
 
 class MessageWriter;
 class MessageReader;
 
 // 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
@@ skipping 263 matching lines @@
   // Appends the array of strings. Arrays of strings are often used for
   // exchanging lists of names hence it's worth having a specialized
   // function.
   void AppendArrayOfStrings(const std::vector<std::string>& strings);
 
   // Appends the array of object paths. Arrays of object paths are often
   // used when exchanging object paths, hence it's worth having a
   // specialized function.
   void AppendArrayOfObjectPaths(const std::vector<std::string>& object_paths);
 
+  // Appends the protocol buffer. The buffer is serialized into an array of

[satorux1, 2012/01/31 21:42:31]

Appends the protocol buffer as an array of bytes.

[rharrison, 2012/02/01 19:03:20]

Done.

+  // bytes before communication, since protocol buffers are not a native dbus
+  // type. On the receiving size the array of bytes needs to be read and
+  // deserialized into a protocol buffer of the correct type. There are methods
+  // in MessageReader to assist in this.
+  // Return true on succes and fail when serialization is not successful.
+  bool AppendProtocolBuffer(const google::protobuf::MessageLite& protobuf);

[satorux1, 2012/01/31 21:42:31]

AppendProtoAsArrayOfBytes() would make it clear that the protocol buffer message
is appended as an array of bytes.

[rharrison, 2012/02/01 19:03:20]

Done.

+
   // Appends the byte wrapped in a variant data container. Variants are
   // widely used in D-Bus services so it's worth having a specialized
   // function. For instance, The third parameter of
   // "org.freedesktop.DBus.Properties.Set" is a variant.
   void AppendVariantOfByte(uint8 value);
   void AppendVariantOfBool(bool value);
   void AppendVariantOfInt16(int16 value);
   void AppendVariantOfUint16(uint16 value);
   void AppendVariantOfInt32(int32 value);
   void AppendVariantOfUint32(uint32 value);
@@ skipping 78 matching lines @@
   bool PopArrayOfStrings(std::vector<std::string>* strings);
 
   // Gets the array of object paths at the current iterator position.
   // Returns true and advances the iterator on success.
   //
   // Arrays of object paths are often used to communicate with D-Bus
   // services like NetworkManager, hence it's worth having a specialized
   // function.
   bool PopArrayOfObjectPaths(std::vector<std::string>* object_paths);
 
+  // Gets the array of bytes at the current iterator position. It then parses
+  // this binary blob into the protocol buffer supplied.
+  // Returns true and advances the iterator on success. On failure returns false
+  // and emits an error message on the source of the failure. The two most
+  // common errors come from the iterator not currently being at a byte array or
+  // the wrong type of protocol buffer is passed in and the parse fails.
+  bool PopProtocolBuffer(google::protobuf::MessageLite* protobuf);

[satorux1, 2012/01/31 21:42:31]

PopArrayOfBytesAsProto() ?

[rharrison, 2012/02/01 19:03:20]

Done.

+
   // Gets the byte from the variant data container at the current iterator
   // position.
   // Returns true and advances the iterator on success.
   //
   // Variants are widely used in D-Bus services so it's worth having a
   // specialized function. For instance, The return value type of
   // "org.freedesktop.DBus.Properties.Get" is a variant.
   bool PopVariantOfByte(uint8* value);
   bool PopVariantOfBool(bool* value);
   bool PopVariantOfInt16(int16* value);
@@ skipping 27 matching lines @@
 
   Message* message_;
   DBusMessageIter raw_message_iter_;
 
   DISALLOW_COPY_AND_ASSIGN(MessageReader);
 };
 
 }  // namespace dbus
 
 #endif  // DBUS_MESSAGE_H_