Completely revert all my IPC work to see if this was what regressed the page cycler.

ipc/ipc_message_utils.h

 // Copyright (c) 2010 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 <string>
 #include <vector>
 #include <map>
 #include <set>
 
+#include "base/file_path.h"
 #include "base/format_macros.h"
+#include "base/nullable_string16.h"
 #include "base/string16.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
+#include "base/time.h"
 #include "base/tuple.h"
 #include "base/utf_string_conversions.h"
+#include "base/values.h"
+#if defined(OS_POSIX)
+#include "ipc/file_descriptor_set_posix.h"
+#endif
+#include "ipc/ipc_channel_handle.h"
 #include "ipc/ipc_sync_message.h"
 
-#if defined(COMPILER_GCC)
-// GCC "helpfully" tries to inline template methods in release mode. Except we
-// want the majority of the template junk being expanded once in the
-// implementation file (and only provide the definitions in
-// ipc_message_utils_impl.h in those files) and exported, instead of expanded
-// at every call site. Special note: GCC happily accepts the attribute before
-// the method declaration, but only acts on it if it is after.
-#define IPC_MSG_NOINLINE  __attribute__((noinline));
-#elif defined(COMPILER_MSVC)
-// MSVC++ doesn't do this.
-#define IPC_MSG_NOINLINE
-#else
-#error "Please add the noinline property for your new compiler here."
-#endif
-
 // Used by IPC_BEGIN_MESSAGES so that each message class starts from a unique
 // base.  Messages have unique IDs across channels in order for the IPC logging
 // code to figure out the message class from its ID.
 enum IPCMessageStart {
   // By using a start value of 0 for automation messages, we keep backward
   // compatibility with old builds.
   AutomationMsgStart = 0,
   ViewMsgStart,
   ViewHostMsgStart,
   PluginProcessMsgStart,
@@ skipping 19 matching lines @@
   GpuChannelMsgStart,
   GpuVideoDecoderHostMsgStart,
   GpuVideoDecoderMsgStart,
   ServiceMsgStart,
   ServiceHostMsgStart,
   // NOTE: When you add a new message class, also update
   // IPCStatusView::IPCStatusView to ensure logging works.
   LastMsgIndex
 };
 
-class DictionaryValue;
-class FilePath;
-class ListValue;
-class NullableString16;
-
-namespace base {
-class Time;
-struct FileDescriptor;
-}
-
 namespace IPC {
 
-struct ChannelHandle;
-
 //-----------------------------------------------------------------------------
 // An iterator class for reading the fields contained within a Message.
 
 class MessageIterator {
  public:
   explicit MessageIterator(const Message& m) : msg_(m), iter_(NULL) {
   }
   int NextInt() const {
     int val = -1;
     if (!msg_.ReadInt(&iter_, &val))
@@ skipping 217 matching lines @@
     return result;
   }
   static void Log(const param_type& p, std::wstring* l) {
     l->append(StringPrintf(L"%lc", p));
   }
 };
 
 template <>
 struct 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::wstring* l);
+  static void Write(Message* m, const param_type& p) {
+    ParamTraits<int64>::Write(m, p.ToInternalValue());
+  }
+  static bool Read(const Message* m, void** iter, param_type* r) {
+    int64 value;
+    if (!ParamTraits<int64>::Read(m, iter, &value))
+      return false;
+    *r = base::Time::FromInternalValue(value);
+    return true;
+  }
+  static void Log(const param_type& p, std::wstring* l) {
+    ParamTraits<int64>::Log(p.ToInternalValue(), l);
+  }
 };
 
 #if defined(OS_WIN)
 template <>
 struct ParamTraits<LOGFONT> {
   typedef LOGFONT param_type;
   static void Write(Message* m, const param_type& p) {
     m->WriteData(reinterpret_cast<const char*>(&p), sizeof(LOGFONT));
   }
   static bool Read(const Message* m, void** iter, param_type* r) {
@@ skipping 26 matching lines @@
     bool result = m->ReadData(iter, &data, &data_size);
     if (result && data_size == sizeof(MSG)) {
       memcpy(r, data, sizeof(MSG));
     } else {
       result = false;
       NOTREACHED();
     }
 
     return result;
   }
-  static void Log(const param_type& p, std::wstring* l) {
-    l->append(L"<MSG>");
-  }
 };
 #endif  // defined(OS_WIN)
 
 template <>
 struct ParamTraits<DictionaryValue> {
   typedef 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::wstring* l);
 };
@@ skipping 213 matching lines @@
     LogParam(p.first, l);
     l->append(L", ");
     LogParam(p.second, l);
     l->append(L")");
   }
 };
 
 template <>
 struct 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::wstring* l);
+  static void Write(Message* m, const param_type& p) {
+    WriteParam(m, p.string());
+    WriteParam(m, p.is_null());
+  }
+  static bool Read(const Message* m, void** iter, param_type* r) {
+    string16 string;
+    if (!ReadParam(m, iter, &string))
+      return false;
+    bool is_null;
+    if (!ReadParam(m, iter, &is_null))
+      return false;
+    *r = NullableString16(string, is_null);
+    return true;
+  }
+  static void Log(const param_type& p, std::wstring* l) {
+    l->append(L"(");
+    LogParam(p.string(), l);
+    l->append(L", ");
+    LogParam(p.is_null(), l);
+    l->append(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);
@@ skipping 70 matching lines @@
   }
   static void Log(const param_type& p, std::wstring* l) {
     l->append(StringPrintf(L"(%d, %d)", p.x, p.y));
   }
 };
 #endif  // defined(OS_WIN)
 
 template <>
 struct 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::wstring* l);
+  static void Write(Message* m, const param_type& p) {
+    ParamTraits<FilePath::StringType>::Write(m, p.value());
+  }
+  static bool Read(const Message* m, void** iter, param_type* r) {
+    FilePath::StringType value;
+    if (!ParamTraits<FilePath::StringType>::Read(m, iter, &value))
+      return false;
+    *r = FilePath(value);
+    return true;
+  }
+  static void Log(const param_type& p, std::wstring* l) {
+    ParamTraits<FilePath::StringType>::Log(p.value(), 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> {
   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::wstring* l);
+  static void Write(Message* m, const param_type& p) {
+    const bool valid = p.fd >= 0;
+    WriteParam(m, valid);
+
+    if (valid) {
+      if (!m->WriteFileDescriptor(p))
+        NOTREACHED();
+    }
+  }
+  static bool Read(const Message* m, void** iter, param_type* r) {
+    bool valid;
+    if (!ReadParam(m, iter, &valid))
+      return false;
+
+    if (!valid) {
+      r->fd = -1;
+      r->auto_close = false;
+      return true;
+    }
+
+    return m->ReadFileDescriptor(iter, r);
+  }
+  static void Log(const param_type& p, std::wstring* l) {
+    if (p.auto_close) {
+      l->append(StringPrintf(L"FD(%d auto-close)", p.fd));
+    } else {
+      l->append(StringPrintf(L"FD(%d)", p.fd));
+    }
+  }
 };
 #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> {
   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::wstring* l);
+  static void Write(Message* m, const param_type& p) {
+    WriteParam(m, p.name);
+#if defined(OS_POSIX)
+    WriteParam(m, p.socket);
+#endif
+  }
+  static bool Read(const Message* m, void** iter, param_type* r) {
+    return ReadParam(m, iter, &r->name)
+#if defined(OS_POSIX)
+        && ReadParam(m, iter, &r->socket)
+#endif
+        ;
+  }
+  static void Log(const param_type& p, std::wstring* l) {
+    l->append(ASCIIToWide(StringPrintf("ChannelHandle(%s", p.name.c_str())));
+#if defined(OS_POSIX)
+    ParamTraits<base::FileDescriptor>::Log(p.socket, l);
+#endif
+    l->append(L")");
+  }
 };
 
 #if defined(OS_WIN)
 template <>
 struct ParamTraits<XFORM> {
   typedef XFORM param_type;
   static void Write(Message* m, const param_type& p) {
     m->WriteData(reinterpret_cast<const char*>(&p), sizeof(XFORM));
   }
   static bool Read(const Message* m, void** iter, param_type* r) {
@@ skipping 205 matching lines @@
 };
 
 //-----------------------------------------------------------------------------
 // Generic message subclasses
 
 // Used for asynchronous messages.
 template <class ParamType>
 class MessageWithTuple : public Message {
  public:
   typedef ParamType Param;
-  typedef typename TupleTypes<ParamType>::ParamTuple RefParam;
+  typedef typename ParamType::ParamTuple RefParam;
 
-  // The constructor and the Read() method's templated implementations are in
-  // ipc_message_utils_impl.h. The subclass constructor and Log() methods call
-  // the templated versions of these and make sure there are instantiations in
-  // those translation units.
-  MessageWithTuple(int32 routing_id, uint32 type, const RefParam& p);
+  MessageWithTuple(int32 routing_id, uint32 type, const RefParam& p)
+      : Message(routing_id, type, PRIORITY_NORMAL) {
+    WriteParam(this, p);
+  }
 
-  static bool Read(const Message* msg, Param* p) IPC_MSG_NOINLINE;
+  static bool Read(const Message* msg, Param* p) {
+    void* iter = NULL;
+    if (ReadParam(msg, &iter, p))
+      return true;
+    NOTREACHED() << "Error deserializing message " << msg->type();
+    return false;
+  }
 
   // Generic dispatcher.  Should cover most cases.
   template<class T, class Method>
   static bool Dispatch(const Message* msg, T* obj, Method func) {
     Param p;
     if (Read(msg, &p)) {
       DispatchToMethod(obj, func, p);
       return true;
     }
     return false;
@@ skipping 51 matching lines @@
   static bool Dispatch(const Message* msg, T* obj,
                        void (T::*func)(const Message&, TA, TB, TC, TD, TE)) {
     Param p;
     if (Read(msg, &p)) {
       (obj->*func)(*msg, p.a, p.b, p.c, p.d, p.e);
       return true;
     }
     return false;
   }
 
+  static void Log(const Message* msg, std::wstring* l) {
+    Param p;
+    if (Read(msg, &p))
+      LogParam(p, l);
+  }
+
   // Functions used to do manual unpacking.  Only used by the automation code,
   // these should go away once that code uses SyncChannel.
   template<typename TA, typename TB>
   static bool Read(const IPC::Message* msg, TA* a, TB* b) {
     ParamType params;
     if (!Read(msg, &params))
       return false;
     *a = params.a;
     *b = params.b;
     return true;
@@ skipping 29 matching lines @@
       return false;
     *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);
-
-
-#if defined(IPC_MESSAGE_LOG_ENABLED)
-inline void AddOutputParamsToLog(const Message* msg, std::wstring* l) {
-  const std::wstring& output_params = msg->output_params();
-  if (!l->empty() && !output_params.empty())
-    l->append(L", ");
-
-  l->append(output_params);
-}
-
-template <class ReplyParamType>
-inline void LogReplyParamsToMessage(const ReplyParamType& reply_params,
-                                    const Message* msg) {
-  if (msg->received_time() != 0) {
-    std::wstring output_params;
-    LogParam(reply_params, &output_params);
-    msg->set_output_params(output_params);
-  }
-}
-
-inline void ConnectMessageAndReply(const Message* msg, Message* reply) {
-  if (msg->sent_time()) {
-    // Don't log the sync message after dispatch, as we don't have the
-    // output parameters at that point.  Instead, save its data and log it
-    // with the outgoing reply message when it's sent.
-    LogData* data = new LogData;
-    GenerateLogData("", *msg, data);
-    msg->set_dont_log();
-    reply->set_sync_log_data(data);
-  }
-}
-#else
-inline void AddOutputParamsToLog(const Message* msg, std::wstring* l) {}
-
-template <class ReplyParamType>
-inline void LogReplyParamsToMessage(const ReplyParamType& reply_params,
-                                    const Message* msg) {}
-
-inline void ConnectMessageAndReply(const Message* msg, Message* reply) {}
-#endif
-
 // This class assumes that its template argument is a RefTuple (a Tuple with
-// reference elements). This would go into ipc_message_utils_impl.h, but it is
-// also used by chrome_frame.
+// reference elements).
 template <class RefTuple>
 class ParamDeserializer : public MessageReplyDeserializer {
  public:
   explicit ParamDeserializer(const RefTuple& out) : out_(out) { }
 
   bool SerializeOutputParameters(const IPC::Message& msg, void* iter) {
     return ReadParam(&msg, &iter, &out_);
   }
 
   RefTuple out_;
 };
 
+// defined in ipc_logging.cc
+void GenerateLogData(const std::string& channel, const Message& message,
+                     LogData* data);
+
 // Used for synchronous messages.
 template <class SendParamType, class ReplyParamType>
 class MessageWithReply : public SyncMessage {
  public:
   typedef SendParamType SendParam;
-  typedef typename TupleTypes<SendParam>::ParamTuple RefSendParam;
+  typedef typename SendParam::ParamTuple RefSendParam;
   typedef ReplyParamType ReplyParam;
 
   MessageWithReply(int32 routing_id, uint32 type,
-                   const RefSendParam& send, const ReplyParam& reply);
-  static bool ReadSendParam(const Message* msg, SendParam* p) IPC_MSG_NOINLINE;
-  static bool ReadReplyParam(
-      const Message* msg,
-      typename TupleTypes<ReplyParam>::ValueTuple* p) IPC_MSG_NOINLINE;
+                   const RefSendParam& send, const ReplyParam& reply)
+      : SyncMessage(routing_id, type, PRIORITY_NORMAL,
+                    new ParamDeserializer<ReplyParam>(reply)) {
+    WriteParam(this, send);
+  }
+
+  static void Log(const Message* msg, std::wstring* l) {
+    if (msg->is_sync()) {
+      SendParam p;
+      void* iter = SyncMessage::GetDataIterator(msg);
+      if (ReadParam(msg, &iter, &p))
+        LogParam(p, l);
+
+#if defined(IPC_MESSAGE_LOG_ENABLED)
+      const std::wstring& output_params = msg->output_params();
+      if (!l->empty() && !output_params.empty())
+        l->append(L", ");
+
+      l->append(output_params);
+#endif
+    } else {
+      // This is an outgoing reply.  Now that we have the output parameters, we
+      // can finally log the message.
+      typename ReplyParam::ValueTuple p;
+      void* iter = SyncMessage::GetDataIterator(msg);
+      if (ReadParam(msg, &iter, &p))
+        LogParam(p, l);
+    }
+  }
 
   template<class T, class Method>
   static bool Dispatch(const Message* msg, T* obj, Method func) {
     SendParam send_params;
+    void* iter = GetDataIterator(msg);
     Message* reply = GenerateReply(msg);
     bool error;
-    if (ReadSendParam(msg, &send_params)) {
-      typename TupleTypes<ReplyParam>::ValueTuple reply_params;
+    if (ReadParam(msg, &iter, &send_params)) {
+      typename ReplyParam::ValueTuple reply_params;
       DispatchToMethod(obj, func, send_params, &reply_params);
       WriteParam(reply, reply_params);
       error = false;
-      LogReplyParamsToMessage(reply_params, msg);
+#ifdef IPC_MESSAGE_LOG_ENABLED
+      if (msg->received_time() != 0) {
+        std::wstring output_params;
+        LogParam(reply_params, &output_params);
+        msg->set_output_params(output_params);
+      }
+#endif
     } else {
       NOTREACHED() << "Error deserializing message " << msg->type();
       reply->set_reply_error();
       error = true;
     }
 
     obj->Send(reply);
     return !error;
   }
 
   template<class T, class Method>
   static bool DispatchDelayReply(const Message* msg, T* obj, Method func) {
     SendParam send_params;
+    void* iter = GetDataIterator(msg);
     Message* reply = GenerateReply(msg);
     bool error;
-    if (ReadSendParam(msg, &send_params)) {
+    if (ReadParam(msg, &iter, &send_params)) {
       Tuple1<Message&> t = MakeRefTuple(*reply);
-      ConnectMessageAndReply(msg, reply);
+
+#ifdef IPC_MESSAGE_LOG_ENABLED
+      if (msg->sent_time()) {
+        // Don't log the sync message after dispatch, as we don't have the
+        // output parameters at that point.  Instead, save its data and log it
+        // with the outgoing reply message when it's sent.
+        LogData* data = new LogData;
+        GenerateLogData("", *msg, data);
+        msg->set_dont_log();
+        reply->set_sync_log_data(data);
+      }
+#endif
       DispatchToMethod(obj, func, send_params, &t);
       error = false;
     } else {
       NOTREACHED() << "Error deserializing message " << msg->type();
       reply->set_reply_error();
       obj->Send(reply);
       error = true;
     }
     return !error;
   }
@@ skipping 27 matching lines @@
     ReplyParam p(a, b, c, d, e);
     WriteParam(reply, p);
   }
 };
 
 //-----------------------------------------------------------------------------
 
 }  // namespace IPC
 
 #endif  // IPC_IPC_MESSAGE_UTILS_H_