Mojo Channel: Fix deferred proxy dispatch; support paused channels

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 <map>
@@ skipping 93 matching lines @@
       const scoped_refptr<base::SingleThreadTaskRunner>& ipc_task_runner);
 
   // Constructs a ChannelProxy without initializing it.
   ChannelProxy(
       Listener* listener,
       const scoped_refptr<base::SingleThreadTaskRunner>& ipc_task_runner);
 
   ~ChannelProxy() override;
 
   // Initializes the channel proxy. Only call this once to initialize a channel
-  // proxy that was not initialized in its constructor. If create_pipe_now is
+  // proxy that was not initialized in its constructor. If |create_pipe_now| is
   // true, the pipe is created synchronously. Otherwise it's created on the IO
-  // thread.
+  // thread. If |create_paused| is true, outgoing messages will continue to be
+  // queued until Unpause() is called.
   void Init(const IPC::ChannelHandle& channel_handle,
             Channel::Mode mode,
-            bool create_pipe_now);
-  void Init(std::unique_ptr<ChannelFactory> factory, bool create_pipe_now);
+            bool create_pipe_now,
+            bool create_paused = false);
+  void Init(std::unique_ptr<ChannelFactory> factory,
+            bool create_pipe_now,
+            bool create_paused = false);
+
+  // Unpause the channel. Only useful if Init was called with |create_paused|.
+  // If |flush| is true the channel will be flushed as soon as it's unpaused.
+  // Otherwise you must explicitly call Flush() to flush messages which were
+  // queued while the channel was paused.
+  void Unpause(bool flush);
+
+  // Flush the channel. This sends any messages which were queued before calling
+  // Connect. Only useful if Unpause(false) was called previously.
+  void Flush();
 
   // 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();
@@ skipping 136 matching lines @@
     void OnChannelConnected(int32_t peer_pid) override;
     void OnChannelError() override;
 
     // Like OnMessageReceived but doesn't try the filters.
     bool OnMessageReceivedNoFilter(const Message& message);
 
     // Gives the filters a chance at processing |message|.
     // Returns true if the message was processed, false otherwise.
     bool TryFilters(const Message& message);
 
+    void UnpauseChannel(bool flush);
+    void FlushChannel();
+
     // Like Open and Close, but called on the IPC thread.
-    virtual void OnChannelOpened();
+    virtual void OnChannelOpened(bool pause);
     virtual void OnChannelClosed();
 
     // Called on the consumers thread when the ChannelProxy is closed.  At that
     // point the consumer is telling us that they don't want to receive any
     // more messages, so we honor that wish by forgetting them!
     virtual void Clear();
 
    private:
     friend class ChannelProxy;
     friend class IpcSecurityTestUtil;
@@ skipping 116 matching lines @@
   bool did_init_;
 
 #if defined(ENABLE_IPC_FUZZER)
   OutgoingMessageFilter* outgoing_message_filter_;
 #endif
 };
 
 }  // namespace IPC
 
 #endif  // IPC_IPC_CHANNEL_PROXY_H_