dbus: Make it possible to build as shared_library.

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_
 
 #include <string>
 #include <vector>
 #include <dbus/dbus.h>
 
 #include "base/basictypes.h"
+#include "dbus/dbus_export.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)
 #define DBUS_TYPE_UNIX_FD      ((int) 'h')
 #endif
 
 // Returns true if Unix FD passing is supported in libdbus.
 // The check is done runtime rather than compile time as the libdbus
 // version used at runtime may be different from the one used at compile time.
-bool IsDBusTypeUnixFdSupported();
+CHROME_DBUS_EXPORT bool IsDBusTypeUnixFdSupported();
 
 // 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 {
+class CHROME_DBUS_EXPORT Message {
  public:
   // The message type used in D-Bus.  Redefined here so client code
   // doesn't need to use raw D-Bus macros. DBUS_MESSAGE_TYPE_INVALID
   // etc. are #define macros. Having an enum type here makes code a bit
   // more type-safe.
   enum MessageType {
     MESSAGE_INVALID = DBUS_MESSAGE_TYPE_INVALID,
     MESSAGE_METHOD_CALL = DBUS_MESSAGE_TYPE_METHOD_CALL,
     MESSAGE_METHOD_RETURN = DBUS_MESSAGE_TYPE_METHOD_RETURN,
     MESSAGE_SIGNAL = DBUS_MESSAGE_TYPE_SIGNAL,
@@ skipping 72 matching lines @@
  private:
   // Helper function used in ToString().
   std::string ToStringInternal(const std::string& indent,
                                MessageReader* reader);
 
   DBusMessage* raw_message_;
   DISALLOW_COPY_AND_ASSIGN(Message);
 };
 
 // MessageCall is a type of message used for calling a method via D-Bus.
-class MethodCall : public Message {
+class CHROME_DBUS_EXPORT MethodCall : public Message {
  public:
   // Creates a method call message for the specified interface name and
   // the method name.
   //
   // For instance, to call "Get" method of DBUS_INTERFACE_INTROSPECTABLE
   // interface ("org.freedesktop.DBus.Introspectable"), create a method
   // call like this:
   //
   //   MethodCall method_call(DBUS_INTERFACE_INTROSPECTABLE, "Get");
   //
   // The constructor creates the internal raw message.
   MethodCall(const std::string& interface_name,
              const std::string& method_name);
 
   // Returns a newly created MethodCall from the given raw message of the
   // type DBUS_MESSAGE_TYPE_METHOD_CALL. The caller must delete the
   // returned object. Takes the ownership of |raw_message|.
   static MethodCall* FromRawMessage(DBusMessage* raw_message);
 
  private:
   // Creates a method call message. The internal raw message is NULL.
   // Only used internally.
   MethodCall();
 
   DISALLOW_COPY_AND_ASSIGN(MethodCall);
 };
 
 // Signal is a type of message used to send a signal.
-class Signal : public Message {
+class CHROME_DBUS_EXPORT Signal : public Message {
  public:
   // Creates a signal message for the specified interface name and the
   // method name.
   //
   // For instance, to send "PropertiesChanged" signal of
   // DBUS_INTERFACE_INTROSPECTABLE interface
   // ("org.freedesktop.DBus.Introspectable"), create a signal like this:
   //
   //   Signal signal(DBUS_INTERFACE_INTROSPECTABLE, "PropertiesChanged");
   //
   // The constructor creates the internal raw_message_.
   Signal(const std::string& interface_name,
          const std::string& method_name);
 
   // Returns a newly created SIGNAL from the given raw message of the type
   // DBUS_MESSAGE_TYPE_SIGNAL. The caller must delete the returned
   // object. Takes the ownership of |raw_message|.
   static Signal* FromRawMessage(DBusMessage* raw_message);
 
  private:
   // Creates a signal message. The internal raw message is NULL.
   // Only used internally.
   Signal();
 
   DISALLOW_COPY_AND_ASSIGN(Signal);
 };
 
 // Response is a type of message used for receiving a response from a
 // method via D-Bus.
-class Response : public Message {
+class CHROME_DBUS_EXPORT Response : public Message {
  public:
   // Returns a newly created Response from the given raw message of the
   // type DBUS_MESSAGE_TYPE_METHOD_RETURN. The caller must delete the
   // returned object. Takes the ownership of |raw_message|.
   static Response* FromRawMessage(DBusMessage* raw_message);
 
   // Returns a newly created Response from the given method call. The
   // caller must delete the returned object. Used for implementing
   // exported methods.
   static Response* FromMethodCall(MethodCall* method_call);
 
   // Returns a newly created Response with an empty payload. The caller
   // must delete the returned object. Useful for testing.
   static Response* CreateEmpty();
 
  protected:
   // Creates a Response message. The internal raw message is NULL.
   Response();
 
  private:
   DISALLOW_COPY_AND_ASSIGN(Response);
 };
 
 // ErrorResponse is a type of message used to return an error to the
 // caller of a method.
-class ErrorResponse: public Response {
+class CHROME_DBUS_EXPORT ErrorResponse: public Response {
  public:
   // Returns a newly created Response from the given raw message of the
   // type DBUS_MESSAGE_TYPE_METHOD_RETURN. The caller must delete the
   // returned object. Takes the ownership of |raw_message|.
   static ErrorResponse* FromRawMessage(DBusMessage* raw_message);
 
   // Returns a newly created ErrorResponse from the given method call, the
   // error name, and the error message.  The error name looks like
   // "org.freedesktop.DBus.Error.Failed". Used for returning an error to a
   // failed method call.
@@ skipping 18 matching lines @@
 //
 // For instance, instead of doing something like:
 //
 //   // We shouldn't add '&' to str here, but it compiles with '&' added.
 //   dbus_g_proxy_call(..., G_TYPE_STRING, str, G_TYPE_INVALID, ...)
 //
 // We want to do something like:
 //
 //   writer.AppendString(str);
 //
-class MessageWriter {
+class CHROME_DBUS_EXPORT MessageWriter {
  public:
   // Data added with Append* will be written to |message|, which may be NULL
   // to create a sub-writer for passing to OpenArray, etc.
   explicit MessageWriter(Message* message);
   ~MessageWriter();
 
   // Appends a byte to the message.
   void AppendByte(uint8 value);
   void AppendBool(bool value);
   void AppendInt16(int16 value);
@@ skipping 80 matching lines @@
   bool container_is_open_;
 
   DISALLOW_COPY_AND_ASSIGN(MessageWriter);
 };
 
 // MessageReader is used to read incoming messages such as responses for
 // method calls.
 //
 // MessageReader manages an internal iterator to read data. All functions
 // starting with Pop advance the iterator on success.
-class MessageReader {
+class CHROME_DBUS_EXPORT MessageReader {
  public:
   // The data will be read from the given |message|, which may be NULL to
   // create a sub-reader for passing to PopArray, etc.
   explicit MessageReader(Message* message);
   ~MessageReader();
 
   // Returns true if the reader has more data to read. The function is
   // used to iterate contents in a container like:
   //
   //   while (reader.HasMoreData())
@@ skipping 99 matching lines @@
 
   Message* message_;
   DBusMessageIter raw_message_iter_;
 
   DISALLOW_COPY_AND_ASSIGN(MessageReader);
 };
 
 }  // namespace dbus
 
 #endif  // DBUS_MESSAGE_H_