Create ipc.dll.

ipc/ipc_message_utils.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 IPC_IPC_MESSAGE_UTILS_H_
 #define IPC_IPC_MESSAGE_UTILS_H_
 #pragma once
 
 #include <algorithm>
 #include <map>
@@ skipping 179 matching lines @@
 
 template <>
 struct ParamTraits<int> {
   typedef int param_type;
   static void Write(Message* m, const param_type& p) {
     m->WriteInt(p);
   }
   static bool Read(const Message* m, void** iter, param_type* r) {
     return m->ReadInt(iter, r);
   }
-  static void Log(const param_type& p, std::string* l);
+  IPC_EXPORT static void Log(const param_type& p, std::string* l);
 };
 
 template <>
 struct ParamTraits<unsigned int> {
   typedef unsigned int param_type;
   static void Write(Message* m, const param_type& p) {
     m->WriteInt(p);
   }
   static bool Read(const Message* m, void** iter, param_type* r) {
     return m->ReadInt(iter, reinterpret_cast<int*>(r));
   }
-  static void Log(const param_type& p, std::string* l);
+  IPC_EXPORT static void Log(const param_type& p, std::string* l);
 };
 
 template <>
 struct ParamTraits<long> {
   typedef long param_type;
   static void Write(Message* m, const param_type& p) {
     m->WriteLong(p);
   }
   static bool Read(const Message* m, void** iter, param_type* r) {
     return m->ReadLong(iter, r);
   }
-  static void Log(const param_type& p, std::string* l);
+  IPC_EXPORT static void Log(const param_type& p, std::string* l);
 };
 
 template <>
 struct ParamTraits<unsigned long> {
   typedef unsigned long param_type;
   static void Write(Message* m, const param_type& p) {
     m->WriteLong(p);
   }
   static bool Read(const Message* m, void** iter, param_type* r) {
     return m->ReadLong(iter, reinterpret_cast<long*>(r));
   }
-  static void Log(const param_type& p, std::string* l);
+  IPC_EXPORT static void Log(const param_type& p, std::string* l);
 };
 
 template <>
 struct ParamTraits<long long> {
   typedef long long param_type;
   static void Write(Message* m, const param_type& p) {
     m->WriteInt64(static_cast<int64>(p));
   }
   static bool Read(const Message* m, void** iter, param_type* r) {
     return m->ReadInt64(iter, reinterpret_cast<int64*>(r));
   }
-  static void Log(const param_type& p, std::string* l);
+  IPC_EXPORT static void Log(const param_type& p, std::string* l);
 };
 
 template <>
 struct ParamTraits<unsigned long long> {
   typedef unsigned long long param_type;
   static void Write(Message* m, const param_type& p) {
     m->WriteInt64(p);
   }
   static bool Read(const Message* m, void** iter, param_type* r) {
     return m->ReadInt64(iter, reinterpret_cast<int64*>(r));
   }
-  static void Log(const param_type& p, std::string* l);
+  IPC_EXPORT static void Log(const param_type& p, std::string* l);
 };
 
 template <>
-struct ParamTraits<unsigned short> {
+struct IPC_EXPORT ParamTraits<unsigned short> {
   typedef unsigned short 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::string* l);
 };
 
 // Note that the IPC layer doesn't sanitize NaNs and +/- INF values.  Clients
 // should be sure to check the sanity of these values after receiving them over
 // IPC.
 template <>
@@ skipping 34 matching lines @@
     }
     memcpy(r, data, sizeof(param_type));
     return true;
   }
   static void Log(const param_type& p, std::string* l) {
     l->append(StringPrintf("%e", p));
   }
 };
 
 template <>
-struct ParamTraits<base::Time> {
+struct IPC_EXPORT ParamTraits<base::Time> {
   typedef base::Time 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::string* l);
 };
 
 template <>
-struct ParamTraits<base::TimeDelta> {
+struct IPC_EXPORT ParamTraits<base::TimeDelta> {
   typedef base::TimeDelta 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::string* l);
 };
 
 #if defined(OS_WIN)
 template <>
 struct ParamTraits<LOGFONT> {
   typedef LOGFONT param_type;
@@ skipping 37 matching lines @@
 
     return result;
   }
   static void Log(const param_type& p, std::string* l) {
     l->append("<MSG>");
   }
 };
 #endif  // defined(OS_WIN)
 
 template <>
-struct ParamTraits<base::DictionaryValue> {
+struct IPC_EXPORT ParamTraits<base::DictionaryValue> {
   typedef base::DictionaryValue 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::string* l);
 };
 
 template <>
-struct ParamTraits<base::ListValue> {
+struct IPC_EXPORT ParamTraits<base::ListValue> {
   typedef base::ListValue 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::string* l);
 };
 
 template <>
 struct ParamTraits<std::string> {
   typedef std::string param_type;
   static void Write(Message* m, const param_type& p) {
@@ skipping 173 matching lines @@
 
 template <>
 struct ParamTraits<std::wstring> {
   typedef std::wstring param_type;
   static void Write(Message* m, const param_type& p) {
     m->WriteWString(p);
   }
   static bool Read(const Message* m, void** iter, param_type* r) {
     return m->ReadWString(iter, r);
   }
-  static void Log(const param_type& p, std::string* l);
+  IPC_EXPORT static void Log(const param_type& p, std::string* l);
 };
 
 template <class A, class B>
 struct ParamTraits<std::pair<A, B> > {
   typedef std::pair<A, B> param_type;
   static void Write(Message* m, const param_type& p) {
     WriteParam(m, p.first);
     WriteParam(m, p.second);
   }
   static bool Read(const Message* m, void** iter, param_type* r) {
     return ReadParam(m, iter, &r->first) && ReadParam(m, iter, &r->second);
   }
   static void Log(const param_type& p, std::string* l) {
     l->append("(");
     LogParam(p.first, l);
     l->append(", ");
     LogParam(p.second, l);
     l->append(")");
   }
 };
 
 template <>
-struct ParamTraits<NullableString16> {
+struct IPC_EXPORT ParamTraits<NullableString16> {
   typedef NullableString16 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::string* l);
 };
 
 // If WCHAR_T_IS_UTF16 is defined, then string16 is a std::wstring so we don't
 // need this trait.
 #if !defined(WCHAR_T_IS_UTF16)
 template <>
 struct ParamTraits<string16> {
   typedef string16 param_type;
   static void Write(Message* m, const param_type& p) {
     m->WriteString16(p);
   }
   static bool Read(const Message* m, void** iter, param_type* r) {
     return m->ReadString16(iter, r);
   }
-  static void Log(const param_type& p, std::string* l);
+  IPC_EXPORT static void Log(const param_type& p, std::string* l);
 };
 #endif
 
 // and, a few more useful types...
 #if defined(OS_WIN)
 template <>
 struct ParamTraits<HANDLE> {
   typedef HANDLE param_type;
   static void Write(Message* m, const param_type& p) {
     // Note that HWNDs/HANDLE/HCURSOR/HACCEL etc are always 32 bits, even on 64
@@ skipping 51 matching lines @@
     r->y = y;
     return true;
   }
   static void Log(const param_type& p, std::string* l) {
     l->append(StringPrintf("(%d, %d)", p.x, p.y));
   }
 };
 #endif  // defined(OS_WIN)
 
 template <>
-struct ParamTraits<FilePath> {
+struct IPC_EXPORT ParamTraits<FilePath> {
   typedef FilePath 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::string* 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> {
+struct IPC_EXPORT ParamTraits<base::FileDescriptor> {
   typedef base::FileDescriptor 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::string* l);
 };
 #endif  // defined(OS_POSIX)
 
 // A ChannelHandle is basically a platform-inspecific wrapper around the
 // fact that IPC endpoints are handled specially on POSIX.  See above comments
 // on FileDescriptor for more background.
 template<>
-struct ParamTraits<IPC::ChannelHandle> {
+struct IPC_EXPORT ParamTraits<IPC::ChannelHandle> {
   typedef ChannelHandle 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::string* l);
 };
 
 #if defined(OS_WIN)
 template <>
 struct ParamTraits<XFORM> {
   typedef XFORM param_type;
@@ skipping 12 matching lines @@
     }
 
     return result;
   }
   static void Log(const param_type& p, std::string* l) {
     l->append("<XFORM>");
   }
 };
 #endif  // defined(OS_WIN)
 
-struct LogData {
+struct IPC_EXPORT LogData {
   LogData();
   ~LogData();
 
   std::string channel;
   int32 routing_id;
   uint32 type;  // "User-defined" message type, from ipc_message.h.
   std::string flags;
   int64 sent;  // Time that the message was sent (i.e. at Send()).
   int64 receive;  // Time before it was dispatched (i.e. before calling
                   // OnMessageReceived).
   int64 dispatch;  // Time after it was dispatched (i.e. after calling
                    // OnMessageReceived).
   std::string message_name;
   std::string params;
 };
 
 template <>
-struct ParamTraits<LogData> {
+struct IPC_EXPORT ParamTraits<LogData> {
   typedef LogData 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::string* l) {
     // Doesn't make sense to implement this!
   }
 };
 
 template <>
 struct ParamTraits<Message> {
@@ skipping 271 matching lines @@
     *a = params.a;
     *b = params.b;
     *c = params.c;
     *d = params.d;
     *e = params.e;
     return true;
   }
 };
 
 // defined in ipc_logging.cc
-void GenerateLogData(const std::string& channel, const Message& message,
-                     LogData* data);
+IPC_EXPORT void GenerateLogData(const std::string& channel,
+                                const Message& message,
+                                LogData* data);
 
 
 #if defined(IPC_MESSAGE_LOG_ENABLED)
 inline void AddOutputParamsToLog(const Message* msg, std::string* l) {
   const std::string& output_params = msg->output_params();
   if (!l->empty() && !output_params.empty())
     l->append(", ");
 
   l->append(output_params);
 }
@@ skipping 128 matching lines @@
     ReplyParam p(a, b, c, d, e);
     WriteParam(reply, p);
   }
 };
 
 //-----------------------------------------------------------------------------
 
 }  // namespace IPC
 
 #endif  // IPC_IPC_MESSAGE_UTILS_H_