Send input event IPCs directly from the UI thread

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 <stdint.h>
 
 #include <memory>
@@ skipping 105 matching lines @@
   // Close the IPC::Channel.  This operation completes asynchronously, once the
   // background thread processes the command to close the channel.  It is ok to
   // call this method multiple times.  Redundant calls are ignored.
   //
   // WARNING: MessageFilter objects held by the ChannelProxy is also
   // released asynchronously, and it may in fact have its final reference
   // released on the background thread.  The caller should be careful to deal
   // with / allow for this possibility.
   void Close();
 
-  // Send a message asynchronously.  The message is routed to the background
-  // thread where it is passed to the IPC::Channel's Send method.
+  // DEPRECATED: Please use either SendNow or SendOnIPCThread to make ordering
+  // expectations explicit.
+  //
+  // This is an alias for for SendOnIPCThread.
   bool Send(Message* message) override;
 
+  // Send a message as soon as possible. This method may send the message
+  // immediately, or it may defer and send on the IPC thread. Use this when you
+  // you don't care about strict ordering of the send operation with respect to
+  // tasks on the IPC thread. This is most commonly what you want.
+  bool SendNow(Message* message);

[piman, 2016/05/20 00:35:41]

drive-by: it would be nice to take this occasion to fix this interface to take a
std::unique_ptr<Message>, since it takes ownership. It's hard to do at the
IPC::Sender level today because of the sheer amount of implementations, but if
we're going to progressively migrate callers, I think it would be a great
occasion to do this at the same time. thoughts?

+
+  // Send a message from the IPC thread. This immediately posts a task to the
+  // IPC thread task runner to send the message. Use this when you're posting
+  // other related tasks to the IPC thread and you need to guarantee that the
+  // send operation is ordered with respect to those tasks.
+  bool SendOnIPCThread(Message* message);
+
   // Used to intercept messages as they are received on the background thread.
   //
   // 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);
@@ skipping 34 matching lines @@
     void ClearIPCTaskRunner();
     base::SingleThreadTaskRunner* ipc_task_runner() const {
       return ipc_task_runner_.get();
     }
     const std::string& channel_id() const { return channel_id_; }
 
     // Dispatches a message on the listener thread.
     void OnDispatchMessage(const Message& message);
 
     // Sends |message| from appropriate thread.
-    void Send(Message* message);
+    bool Send(Message* message, bool force_io_thread);
 
     // Indicates if the underlying channel's Send is thread-safe.
     bool IsChannelSendThreadSafe() const;
 
    protected:
     friend class base::RefCountedThreadSafe<Context>;
     ~Context() override;
 
     // IPC::Listener methods:
     bool OnMessageReceived(const Message& message) override;
@@ skipping 33 matching lines @@
     void OnSendMessage(std::unique_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);
 
-    void SendFromThisThread(Message* message);
+    bool 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.
@@ skipping 40 matching lines @@
 
  protected:
   bool did_init() const { return did_init_; }
 
  private:
   friend class IpcSecurityTestUtil;
 
   // Always called once immediately after Init.
   virtual void OnChannelInit();
 
+  bool SendImpl(Message* message, bool force_io_thread);
+
   // 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_;
 
 #if defined(ENABLE_IPC_FUZZER)
   OutgoingMessageFilter* outgoing_message_filter_;
 #endif
 };
 
 }  // namespace IPC
 
 #endif  // IPC_IPC_CHANNEL_PROXY_H_