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"
 
+namespace google {
+namespace protobuf {
+
+class MessageLite;
+
+}  // namespace protobuf
+}  // namespace google
+
+
 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
 // as the class is inside 'dbus' namespace. We chose to name this way, as
@@ skipping 262 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 as an array of bytes. The buffer is serialized
+  // into an array of 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 AppendProtoAsArrayOfBytes(const google::protobuf::MessageLite& protobuf);
+
   // 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 PopArrayOfBytesAsProto(google::protobuf::MessageLite* protobuf);
+
   // 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_