Reworks Channel pausing behavior

ipc/ipc_channel_mojo_unittest.cc

 // Copyright 2014 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.
 
 #include "ipc/ipc_channel_mojo.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 721 matching lines @@
                         base::WaitableEvent::InitialState::NOT_SIGNALED) {
   }
 
   void CreateProxy(IPC::Listener* listener) {
     io_thread_.StartWithOptions(
         base::Thread::Options(base::MessageLoop::TYPE_IO, 0));
     proxy_ = IPC::SyncChannel::Create(
         listener, io_thread_.task_runner(), &never_signaled_);
   }
 
-  void RunProxy(bool create_paused) {
+  void RunProxy() {
     std::unique_ptr<IPC::ChannelFactory> factory;
     if (for_server_) {
       factory = IPC::ChannelMojo::CreateServerFactory(
           std::move(handle_), io_thread_.task_runner());
     } else {
       factory = IPC::ChannelMojo::CreateClientFactory(
           std::move(handle_), io_thread_.task_runner());
     }
-    proxy_->Init(std::move(factory), true, create_paused);
+    proxy_->Init(std::move(factory), true);
   }
 
   IPC::ChannelProxy* proxy() { return proxy_.get(); }
 
  private:
   const bool for_server_;
 
   mojo::ScopedMessagePipeHandle handle_;
   base::Thread io_thread_;
   std::unique_ptr<IPC::ChannelProxy> proxy_;
   base::WaitableEvent never_signaled_;
 
   DISALLOW_COPY_AND_ASSIGN(ChannelProxyRunner);
 };
 
 class IPCChannelProxyMojoTest : public IPCChannelMojoTestBase {
  public:
   void InitWithMojo(const std::string& client_name) {
     IPCChannelMojoTestBase::InitWithMojo(client_name);
     runner_.reset(new ChannelProxyRunner(TakeHandle(), true));
   }
   void CreateProxy(IPC::Listener* listener) { runner_->CreateProxy(listener); }
-  void RunProxy(bool create_paused = false) {
-    runner_->RunProxy(create_paused);
+  void RunProxy() {
+    runner_->RunProxy();
   }
   void DestroyProxy() {
     runner_.reset();
     base::RunLoop().RunUntilIdle();
   }
 
   IPC::ChannelProxy* proxy() { return runner_->proxy(); }
 
  private:
   base::MessageLoop message_loop_;
@@ skipping 85 matching lines @@
 }
 
 class ChannelProxyClient {
  public:
   void Init(mojo::ScopedMessagePipeHandle handle) {
     runner_.reset(new ChannelProxyRunner(std::move(handle), false));
   }
 
   void CreateProxy(IPC::Listener* listener) { runner_->CreateProxy(listener); }
 
-  void RunProxy() { runner_->RunProxy(false); }
+  void RunProxy() { runner_->RunProxy(); }
 
   void DestroyProxy() {
     runner_.reset();
     base::RunLoop().RunUntilIdle();
   }
 
   void RequestQuitAndWaitForAck(IPC::mojom::SimpleTestDriver* driver) {
     base::RunLoop loop;
     driver->RequestQuit(loop.QuitClosure());
     loop.Run();
@@ skipping 353 matching lines @@
   client_impl.WaitForValueRequest();
 
   // Wait for the test driver to perform a classical sync IPC request, with our
   // own sync associated interface message nested inside.
   client_impl.UseSyncSenderForRequest(false);
   client_impl.WaitForValueRequest();
 
   DestroyProxy();
 }
 
-TEST_F(IPCChannelProxyMojoTest, CreatePaused) {
-  // Ensures that creating a paused channel elicits the expected behavior when
-  // sending messages, unpausing, sending more messages, and then manually
-  // flushing. Specifically a sequence like:
+TEST_F(IPCChannelProxyMojoTest, Pause) {
+  // Ensures that pausing a channel elicits the expected behavior when sending
+  // messages, unpausing, sending more messages, and then manually flushing.
+  // Specifically a sequence like:
   //
   //   Connect()
   //   Send(A)
+  //   Pause()
   //   Send(B)
+  //   Send(C)
   //   Unpause(false)
-  //   Send(C)
+  //   Send(D)
+  //   Send(E)
   //   Flush()
   //
-  // must result in the other end receiving messages C, A, and then B, in that
+  // must result in the other end receiving messages A, D, E, B, D; in that
   // order.
   //
   // This behavior is required by some consumers of IPC::Channel, and it is not
   // sufficient to leave this up to the consumer to implement since associated
   // interface requests and messages also need to be queued according to the
   // same policy.
   InitWithMojo("CreatePausedClient");
 
   DummyListener listener;
   CreateProxy(&listener);
-  RunProxy(true /* create_paused */);
+  RunProxy();
+
+  // This message must be sent immediately since the channel is unpaused.
+  SendValue(proxy(), 1);
+
+  proxy()->Pause();
 
   // These messages must be queued internally since the channel is paused.
-  SendValue(proxy(), 1);
   SendValue(proxy(), 2);
+  SendValue(proxy(), 3);
 
   proxy()->Unpause(false /* flush */);
 
   // These messages must be sent immediately since the channel is unpaused.
-  SendValue(proxy(), 3);
   SendValue(proxy(), 4);
+  SendValue(proxy(), 5);
 
   // Now we flush the previously queued messages.
   proxy()->Flush();
 
   EXPECT_TRUE(WaitForClientShutdown());
   DestroyProxy();
 }
 
 class ExpectValueSequenceListener : public IPC::Listener {
  public:
@@ skipping 17 matching lines @@
  private:
   std::queue<int32_t>* expected_values_;
 
   DISALLOW_COPY_AND_ASSIGN(ExpectValueSequenceListener);
 };
 
 DEFINE_IPC_CHANNEL_MOJO_TEST_CLIENT(CreatePausedClient, ChannelProxyClient) {
   std::queue<int32_t> expected_values;
   ExpectValueSequenceListener listener(&expected_values);
   CreateProxy(&listener);
+  expected_values.push(1);
+  expected_values.push(4);
+  expected_values.push(5);
+  expected_values.push(2);
   expected_values.push(3);
-  expected_values.push(4);
-  expected_values.push(1);
-  expected_values.push(2);
   RunProxy();
   base::RunLoop().Run();
   EXPECT_TRUE(expected_values.empty());
   DestroyProxy();
 }
 
 #if defined(OS_POSIX)
 
 class ListenerThatExpectsFile : public IPC::Listener {
  public:
@@ skipping 148 matching lines @@
   Connect(&listener);
 
   base::RunLoop().Run();
 
   Close();
 }
 
 #endif  // OS_LINUX
 
 }  // namespace