Minimal Chrome Frame with Aura.

ipc/ipc_message_utils.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 IPC_IPC_MESSAGE_UTILS_H_
 #define IPC_IPC_MESSAGE_UTILS_H_
 
 #include <algorithm>
 #include <map>
 #include <set>
@@ skipping 457 matching lines @@
   static void Write(Message* m, const param_type& p);
   static bool Read(const Message* m, PickleIterator* iter, param_type* r);
   static void Log(const param_type& p, std::string* l);
 };
 
 template <>
 struct SimilarTypeTraits<base::PlatformFileError> {
   typedef int Type;
 };
 
+#if defined(OS_WIN)
+template <>
+struct SimilarTypeTraits<HWND> {
+  typedef HANDLE Type;

[jam, 2013/02/27 20:35:34]

we already send HWNDs in IPCs, so I'm not sure why this is needed? i.e. see
https://code.google.com/p/chromium/codesearch#chromium/src/ipc/ipc_message_ut...

an example ipc that looks like it's already sent in win aura:
PluginProcessHostMsg_PluginWindowDestroyed

or is this needed now because you removed the entry for gfx::PluginWindowHandle
?

[grt (UTC plus 2), 2013/02/28 02:48:41]

That code sends HANDLEs, not HWNDs. In practice, they're the same thing, but I
believe that macro magic makes them distinct types (at least in debug builds) to
help catch developer mistakes (like calling CloseHandle instead of CloseWindow
on an HWND). This fact (that they're distinct types) makes the template-fu fail
when an HWND is marshaled.
That's exactly it. The PluginWindowHandle thing looked to me like a "why can't
we marshal HWNDs?" hack (see the accompanying comment) and made all attempts to
send an HWND succeed. My solution here (which came about after a fair amount of
cursing at cryptic msvc template-related error messages) tells the IPC
marshaling system that when it sees an HWND it can safely cast it to a HANDLE
and use the HANDLE marshaling that you pointed to above.

+};
+#endif  // defined(OS_WIN)
+
 template <>
 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, PickleIterator* iter, param_type* r);
   static void Log(const param_type& p, std::string* l);
 };
 
 template <>
 struct IPC_EXPORT ParamTraits<base::TimeDelta> {
@@ skipping 372 matching lines @@
   template<typename TA, typename TB, typename TC, typename TD, typename TE>
   static void WriteReplyParams(Message* reply, TA a, TB b, TC c, TD d, TE e) {
     ReplyParam p(a, b, c, d, e);
     WriteParam(reply, p);
   }
 };
 
 }  // namespace IPC
 
 #endif  // IPC_IPC_MESSAGE_UTILS_H_