Support tracking of IPC messages as tasks in profiler

ipc/ipc_message_macros.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.
 
 // Defining IPC Messages
 //
 // Your IPC messages will be defined by macros inside of an XXX_messages.h
 // header file.  Most of the time, the system can automatically generate all
 // of messaging mechanism from these definitions, but sometimes some manual
 // coding is required.  In these cases, you will also have an XXX_messages.cc
 // implemation file as well.
 //
 // The senders of your messages will include your XXX_messages.h file to
 // get the full set of definitions they need to send your messages.
 //
 // Each XXX_messages.h file must be registered with the IPC system.  This
 // requires adding two things:
 //   - An XXXMsgStart value to the IPCMessageStart enum in ipc_message_utils.h
 //   - An inclusion of XXX_messages.h file in a message generator .h file
 //
 // The XXXMsgStart value is an enumeration that ensures uniqueness for
 // each different message file.  Later, you will use this inside your
-// XXX_messages.h file before invoking message declatation macros:
+// XXX_messages.h file before invoking message declaration macros:
 //     #define IPC_MESSAGE_START XXXMsgStart
 //       ( ... your macro invocations go here ... )
 //
 // Message Generator Files
 //
 // A message generator .h header file pulls in all other message-declaring
 // headers for a given component.  It is included by a message generator
 // .cc file, which is where all the generated code will wind up.  Typically,
 // you will use an existing generator (e.g. common_message_generator.cc
 // in /chrome/common), but there are circumstances where you may add a
@@ skipping 135 matching lines @@
 // The handler function will look like:
 //     void OnSyncMessageName(const type1& in1, IPC::Message* reply_msg);
 //
 // Receiver stashes the IPC::Message* pointer, and when it's ready, it does:
 //     ViewHostMsg_SyncMessageName::WriteReplyParams(reply_msg, out1, out2);
 //     Send(reply_msg);
 
 #ifndef IPC_IPC_MESSAGE_MACROS_H_
 #define IPC_IPC_MESSAGE_MACROS_H_
 
+#include "base/profiler/scoped_profile.h"
 #include "ipc/ipc_message_utils.h"
 #include "ipc/param_traits_macros.h"
 
 #if defined(IPC_MESSAGE_IMPL)
 #include "ipc/ipc_message_utils_impl.h"
 #endif
 
 // Override this to force message classes to be exported.
 #ifndef IPC_MESSAGE_EXPORT
 #define IPC_MESSAGE_EXPORT
@@ skipping 744 matching lines @@
     bool& msg_is_ok__ = msg_is_ok; \
     switch (ipc_message__.type()) { \
 
 #define IPC_BEGIN_MESSAGE_MAP(class_name, msg) \
   { \
     typedef class_name _IpcMessageHandlerClass; \
     const IPC::Message& ipc_message__ = msg; \
     bool msg_is_ok__ = true; \
     switch (ipc_message__.type()) { \
 
-#define IPC_MESSAGE_FORWARD(msg_class, obj, member_func) \
-  case msg_class::ID: \
-    msg_is_ok__ = msg_class::Dispatch(&ipc_message__, obj, this, \
-                                      &member_func); \
-    break;
+#define IPC_MESSAGE_FORWARD(msg_class, obj, member_func)                       \
+    case msg_class::ID: {                                                      \
+        TRACK_RUN_IN_IPC_HANDLER(member_func);                                 \
+        msg_is_ok__ = msg_class::Dispatch(&ipc_message__, obj, this,           \
+                                      &member_func);                           \
+      }                                                                        \
+      break;
 
 #define IPC_MESSAGE_HANDLER(msg_class, member_func) \
   IPC_MESSAGE_FORWARD(msg_class, this, _IpcMessageHandlerClass::member_func)
 
-#define IPC_MESSAGE_FORWARD_DELAY_REPLY(msg_class, obj, member_func) \
-    case msg_class::ID: \
-    msg_is_ok__ = msg_class::DispatchDelayReply(&ipc_message__, obj, \
-                                                &member_func); \
-    break;
+#define IPC_MESSAGE_FORWARD_DELAY_REPLY(msg_class, obj, member_func)           \
+    case msg_class::ID: {                                                      \
+        TRACK_RUN_IN_IPC_HANDLER(member_func);                                 \
+        msg_is_ok__ = msg_class::DispatchDelayReply(&ipc_message__, obj,       \
+                                                  &member_func);               \
+      }                                                                        \
+      break;
 
 #define IPC_MESSAGE_HANDLER_DELAY_REPLY(msg_class, member_func) \
   IPC_MESSAGE_FORWARD_DELAY_REPLY(msg_class, this, \
                                   _IpcMessageHandlerClass::member_func)
 
 #define IPC_MESSAGE_HANDLER_GENERIC(msg_class, code) \
   case msg_class::ID: \
     code; \
     break;
 
-#define IPC_REPLY_HANDLER(func) \
-   case IPC_REPLY_ID: \
-     func(ipc_message__); \
+#define IPC_REPLY_HANDLER(func)                                                \
+   case IPC_REPLY_ID: {                                                        \
+         TRACK_RUN_IN_IPC_HANDLER(func);                                       \
+         func(ipc_message__);                                                  \
+     }                                                                         \
      break;
 
 
 #define IPC_MESSAGE_UNHANDLED(code) \
   default: \
     code; \
     break;
 
 #define IPC_MESSAGE_UNHANDLED_ERROR() \
   IPC_MESSAGE_UNHANDLED(NOTREACHED() << \
@@ skipping 12 matching lines @@
 // This corresponds to an enum value from IPCMessageStart.
 #define IPC_MESSAGE_CLASS(message) \
   IPC_MESSAGE_ID_CLASS(message.type())
 
 #endif  // IPC_IPC_MESSAGE_MACROS_H_
 
 // Clean up IPC_MESSAGE_START in this unguarded section so that the
 // XXX_messages.h files need not do so themselves.  This makes the
 // XXX_messages.h files easier to write.
 #undef IPC_MESSAGE_START