Add a flag to dump IPC messages sent from the renderer to the browser.

ipc/ipc_channel_proxy.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_CHANNEL_PROXY_H_
 #define IPC_IPC_CHANNEL_PROXY_H_
 
 #include <vector>
 
 #include "base/memory/ref_counted.h"
@@ skipping 39 matching lines @@
 // the consumer of IPC::ChannelProxy the ability to respond to incoming
 // messages on this background thread instead of on their own thread, which may
 // be bogged down with other processing.  The result can be greatly improved
 // latency for messages that can be handled on a background thread.
 //
 // The consumer of IPC::ChannelProxy is responsible for allocating the Thread
 // instance where the IPC::Channel will be created and operated.
 //
 class IPC_EXPORT ChannelProxy : public Sender, public base::NonThreadSafe {
  public:
+  // Interface for a filter to be imposed on outgoing messages which can

[inferno, 2015/03/05 18:46:48]

All code ifdefed.

+  // re-write the message. Used for testing.
+  class OutgoingMessageFilter {
+   public:
+    virtual Message* Rewrite(Message* message) = 0;
+  };
+
   // Initializes a channel proxy.  The channel_handle and mode parameters are
   // passed directly to the underlying IPC::Channel.  The listener is called on
   // the thread that creates the ChannelProxy.  The filter's OnMessageReceived
   // method is called on the thread where the IPC::Channel is running.  The
   // filter may be null if the consumer is not interested in handling messages
   // on the background thread.  Any message not handled by the filter will be
   // dispatched to the listener.  The given task runner correspond to a thread
   // on which IPC::Channel is created and used (e.g. IO thread).
   static scoped_ptr<ChannelProxy> Create(
       const IPC::ChannelHandle& channel_handle,
@@ skipping 35 matching lines @@
   // Ordinarily, messages sent to the ChannelProxy are routed to the matching
   // listener on the worker thread.  This API allows code to intercept messages
   // before they are sent to the worker thread.
   // If you call this before the target process is launched, then you're
   // guaranteed to not miss any messages.  But if you call this anytime after,
   // then some messages might be missed since the filter is added internally on
   // the IO thread.
   void AddFilter(MessageFilter* filter);
   void RemoveFilter(MessageFilter* filter);
 
+  void set_outgoing_message_filter(OutgoingMessageFilter* filter) {
+    outgoing_message_filter_ = filter;
+  }
+
   // Set the task runner on which dispatched messages are posted. Both the new
   // task runner and the existing task runner must run on the same thread, and
   // must belong to the calling thread.
   void SetListenerTaskRunner(
     scoped_refptr<base::SingleThreadTaskRunner> listener_task_runner);
 
   // Called to clear the pointer to the IPC task runner when it's going away.
   void ClearIPCTaskRunner();
 
   // Get the process ID for the connected peer.
@@ skipping 100 matching lines @@
     // Lock for pending_filters_.
     base::Lock pending_filters_lock_;
 
     // Cached copy of the peer process ID. Set on IPC but read on both IPC and
     // listener threads.
     base::ProcessId peer_pid_;
   };
 
   Context* context() { return context_.get(); }
 
+  OutgoingMessageFilter* outgoing_message_filter() {

[inferno, 2015/03/05 18:46:48]

() const {

+    return outgoing_message_filter_;
+  }
+
  private:
   friend class IpcSecurityTestUtil;
 
   // By maintaining this indirection (ref-counted) to our internal state, we
   // can safely be destroyed while the background thread continues to do stuff
   // that involves this data.
   scoped_refptr<Context> context_;
 
   // Whether the channel has been initialized.
   bool did_init_;
+
+  OutgoingMessageFilter* outgoing_message_filter_;
 };
 
 }  // namespace IPC
 
 #endif  // IPC_IPC_CHANNEL_PROXY_H_