Reworks Channel pausing behavior

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 95 matching lines @@
   // 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
   // true, the pipe is created synchronously. Otherwise it's created on the IO
-  // thread. If |create_paused| is true, outgoing messages will continue to be
-  // queued until Unpause() is called.
+  // thread.
   void Init(const IPC::ChannelHandle& channel_handle,
             Channel::Mode mode,
-            bool create_pipe_now,
-            bool create_paused = false);
+            bool create_pipe_now);
   void Init(std::unique_ptr<ChannelFactory> factory,
-            bool create_pipe_now,
-            bool create_paused = false);
+            bool create_pipe_now);
 
-  // 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.
+  // Pause the channel. Subsequent calls to Send() will be internally queued
+  // until Unpause() is called. Queued messages will not be sent until the
+  // channel is flushed.
+  void Pause();
+
+  // Unpause the channel. If |flush| is true the channel will be flushed as soon
+  // as it's unpaused (see Flush() below.) 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.
   //
@@ skipping 141 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 PauseChannel();
     void UnpauseChannel(bool flush);
     void FlushChannel();
 
     // Like Open and Close, but called on the IPC thread.
-    virtual void OnChannelOpened(bool pause);
+    virtual void OnChannelOpened();
     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_