Initial checkin of the out of process worker implementation....

chrome/common/ipc_message_utils.h

 // Copyright (c) 2006-2008 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 CHROME_COMMON_IPC_MESSAGE_UTILS_H_
 #define CHROME_COMMON_IPC_MESSAGE_UTILS_H_
 
 #include <string>
 #include <vector>
 #include <map>
 
 #include "base/file_path.h"
 #include "base/string_util.h"
+#include "base/string16.h"
 #include "base/tuple.h"
 #if defined(OS_POSIX)
 #include "chrome/common/file_descriptor_set_posix.h"
 #endif
 #include "chrome/common/ipc_maybe.h"
 #include "chrome/common/ipc_sync_message.h"
 #include "chrome/common/thumbnail_score.h"
 #include "chrome/common/transport_dib.h"
 #include "webkit/glue/cache_manager.h"
 #include "webkit/glue/console_message_level.h"
@@ skipping 25 matching lines @@
   ViewMsgStart,
   ViewHostMsgStart,
   PluginProcessMsgStart,
   PluginProcessHostMsgStart,
   PluginMsgStart,
   PluginHostMsgStart,
   NPObjectMsgStart,
   TestMsgStart,
   DevToolsAgentMsgStart,
   DevToolsClientMsgStart,
+  WorkerProcessMsgStart,
+  WorkerProcessHostMsgStart,
+  WorkerMsgStart,
+  WorkerHostMsgStart,
   // NOTE: When you add a new message class, also update
   // IPCStatusView::IPCStatusView to ensure logging works.
   // NOTE: this enum is used by IPC_MESSAGE_MACRO to generate a unique message
   // id.  Only 4 bits are used for the message type, so if this enum needs more
   // than 16 entries, that code needs to be updated.
   LastMsgIndex
 };
 
 COMPILE_ASSERT(LastMsgIndex <= 16, need_to_update_IPC_MESSAGE_MACRO);
 
@@ skipping 416 matching lines @@
       if (!ReadParam(m, iter, &value))
         return false;
     }
     return true;
   }
   static void Log(const param_type& p, std::wstring* l) {
     l->append(L"<std::map>");
   }
 };
 
+
 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::wstring* l) {
     l->append(p);
   }
 };
 
+
+// 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->WriteData(reinterpret_cast<const char*>(p.data()),
+                 static_cast<int>(p.size() * sizeof(char16)));
+  }
+  static bool Read(const Message* m, void** iter, param_type* r) {
+    const char *data;
+    int data_size = 0;
+    if (!m->ReadData(iter, &data, &data_size))
+      return false;
+    r->assign(reinterpret_cast<const char16*>(data),
+              data_size / sizeof(char16));
+    return true;
+  }
+  static void Log(const param_type& p, std::wstring* l) {
+    l->append(UTF16ToWide(p));
+  }
+};
+
+#endif
+
 template <>
 struct ParamTraits<GURL> {
   typedef GURL param_type;
   static void Write(Message* m, const param_type& p);
   static bool Read(const Message* m, void** iter, param_type* p);
   static void Log(const param_type& p, std::wstring* l);
 };
 
 // and, a few more useful types...
 #if defined(OS_WIN)
@@ skipping 367 matching lines @@
       ReadParam(m, iter, &r->dispatch) &&
       ReadParam(m, iter, &r->params);
     r->type = static_cast<uint16>(type);
     return result;
   }
   static void Log(const param_type& p, std::wstring* l) {
     // Doesn't make sense to implement this!
   }
 };
 
+
+template <>
+struct ParamTraits<webkit_glue::WebApplicationInfo> {
+  typedef webkit_glue::WebApplicationInfo 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::wstring* l);
+};
+
+
+#if defined(OS_WIN)
+template<>
+struct ParamTraits<TransportDIB::Id> {
+  typedef TransportDIB::Id param_type;
+  static void Write(Message* m, const param_type& p) {
+    WriteParam(m, p.handle);
+    WriteParam(m, p.sequence_num);
+  }
+  static bool Read(const Message* m, void** iter, param_type* r) {
+    return (ReadParam(m, iter, &r->handle) &&
+            ReadParam(m, iter, &r->sequence_num));
+  }
+  static void Log(const param_type& p, std::wstring* l) {
+    l->append(L"TransportDIB(");
+    LogParam(p.handle, l);
+    l->append(L", ");
+    LogParam(p.sequence_num, l);
+    l->append(L")");
+  }
+};
+#endif
+
+template<typename A>
+struct ParamTraits<Maybe<A> > {
+  typedef struct Maybe<A> param_type;
+  static void Write(Message* m, const param_type& p) {
+    WriteParam(m, p.valid);
+    if (p.valid)
+      WriteParam(m, p.value);
+  }
+  static bool Read(const Message* m, void** iter, param_type* r) {
+    if (!ReadParam(m, iter, &r->valid))
+      return false;
+
+    if (r->valid)
+      return ReadParam(m, iter, &r->value);
+    return true;
+  }
+  static void Log(const param_type& p, std::wstring* l) {
+    if (p.valid) {
+      l->append(L"Just ");
+      ParamTraits<A>::Log(p.value, l);
+    } else {
+      l->append(L"Nothing");
+    }
+
+  }
+};
+
+
 template <>
 struct ParamTraits<Message> {
   static void Write(Message* m, const Message& p) {
     m->WriteInt(p.size());
     m->WriteData(reinterpret_cast<const char*>(p.data()), p.size());
   }
   static bool Read(const Message* m, void** iter, Message* r) {
     int size;
     if (!m->ReadInt(iter, &size))
       return false;
     const char* data;
     if (!m->ReadData(iter, &data, &size))
       return false;
     *r = Message(data, size);
     return true;
   }
   static void Log(const Message& p, std::wstring* l) {
     l->append(L"<IPC::Message>");
   }
 };
 
+
 template <>
 struct ParamTraits<Tuple0> {
   typedef Tuple0 param_type;
   static void Write(Message* m, const param_type& p) {
   }
   static bool Read(const Message* m, void** iter, param_type* r) {
     return true;
   }
   static void Log(const param_type& p, std::wstring* l) {
   }
@@ skipping 136 matching lines @@
     LogParam(p.c, l);
     l->append(L", ");
     LogParam(p.d, l);
     l->append(L", ");
     LogParam(p.e, l);
     l->append(L", ");
     LogParam(p.f, l);
   }
 };
 
-#if defined(OS_WIN)
-template<>
-struct ParamTraits<TransportDIB::Id> {
-  typedef TransportDIB::Id param_type;
-  static void Write(Message* m, const param_type& p) {
-    WriteParam(m, p.handle);
-    WriteParam(m, p.sequence_num);
-  }
-  static bool Read(const Message* m, void** iter, param_type* r) {
-    return (ReadParam(m, iter, &r->handle) &&
-            ReadParam(m, iter, &r->sequence_num));
-  }
-  static void Log(const param_type& p, std::wstring* l) {
-    l->append(L"TransportDIB(");
-    LogParam(p.handle, l);
-    l->append(L", ");
-    LogParam(p.sequence_num, l);
-    l->append(L")");
-  }
-};
-#endif
-
-template<typename A>
-struct ParamTraits<Maybe<A> > {
-  typedef struct Maybe<A> param_type;
-  static void Write(Message* m, const param_type& p) {
-    WriteParam(m, p.valid);
-    if (p.valid)
-      WriteParam(m, p.value);
-  }
-  static bool Read(const Message* m, void** iter, param_type* r) {
-    if (!ReadParam(m, iter, &r->valid))
-      return false;
-
-    if (r->valid)
-      return ReadParam(m, iter, &r->value);
-    return true;
-  }
-  static void Log(const param_type& p, std::wstring* l) {
-    if (p.valid) {
-      l->append(L"Just ");
-      ParamTraits<A>::Log(p.value, l);
-    } else {
-      l->append(L"Nothing");
-    }
-
-  }
-};
-
-template <>
-struct ParamTraits<webkit_glue::WebApplicationInfo> {
-  typedef webkit_glue::WebApplicationInfo 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::wstring* l);
-};
 
 
 //-----------------------------------------------------------------------------
 // Generic message subclasses
 
 // Used for asynchronous messages.
 template <class ParamType>
 class MessageWithTuple : public Message {
  public:
   typedef ParamType Param;
@@ skipping 301 matching lines @@
     l->append(L"<FindInPageRequest>");
   }
 };
 
 //-----------------------------------------------------------------------------
 
 }  // namespace IPC
 
 #endif  // CHROME_COMMON_IPC_MESSAGE_UTILS_H_