ChannelProxy: Send() from UI thread when ChannelMojo is used.

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 37 matching lines @@
 // An IPC::ChannelProxy can have a MessageFilter associated with it, which will
 // be notified of incoming messages on the IPC::Channel's thread.  This gives
 // 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.
 //
+// Thread-safe send
+//
+// A particular |Channel| implementation has thread-safe |Send()|
+// implementation. If it is supported, ChannelProxy bypasses inter-thread
+// messaging and calls |Send()| immediately. The |channel_| variable is touched
+// from multiple threads in this case, so |ChannelProxy::channel_lifetime_lock_|
+// is used to protect it.
+// This lock overhead is paid only if the underlying channel supports the
+// thread-safe send.
+//
 class IPC_EXPORT ChannelProxy : public Sender, public base::NonThreadSafe {
  public:
   // 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).
@@ skipping 118 matching lines @@
     void OnSendMessage(scoped_ptr<Message> message_ptr);
     void OnAddFilter();
     void OnRemoveFilter(MessageFilter* filter);
 
     // Methods called on the listener thread.
     void AddFilter(MessageFilter* filter);
     void OnDispatchConnected();
     void OnDispatchError();
     void OnDispatchBadMessage(const Message& message);
 
+    // Sends |message| from appropriate thread.
+    void Send(Message* message);
+    void SendFromThisThread(Message* message);
+    void ClearChannel();
+
     scoped_refptr<base::SingleThreadTaskRunner> listener_task_runner_;
     Listener* listener_;
 
     // List of filters.  This is only accessed on the IPC thread.
     std::vector<scoped_refptr<MessageFilter> > filters_;
     scoped_refptr<base::SingleThreadTaskRunner> ipc_task_runner_;
 
     // Note, channel_ may be set on the Listener thread or the IPC thread.
     // But once it has been set, it must only be read or cleared on the IPC
     // thread.
+    // Here is one exception, which is thread-safe send. See the class comment.
     scoped_ptr<Channel> channel_;
     std::string channel_id_;
     bool channel_connected_called_;
 
     // Routes a given message to a proper subset of |filters_|, depending
     // on which message classes a filter might support.
     scoped_ptr<MessageFilterRouter> message_filter_router_;
 
     // Holds filters between the AddFilter call on the listerner thread and the
     // IPC thread when they're added to filters_.
     std::vector<scoped_refptr<MessageFilter> > pending_filters_;
     // Lock for pending_filters_.
     base::Lock pending_filters_lock_;
 
+    // Lock for |channel_| value. This is only relevant in the context of
+    // thread-safe send.
+    base::Lock channel_lifetime_lock_;
+    // Indicates the thread-safe send availability. This is constant once
+    // |channel_| is set.
+    bool channel_send_thread_safe_;
+
     // 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(); }
 
  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_;
 };
 
 }  // namespace IPC
 
 #endif  // IPC_IPC_CHANNEL_PROXY_H_