Reworks Channel pausing behavior

ipc/ipc_mojo_bootstrap.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_mojo_bootstrap.h"
 
 #include <stdint.h>
 
 #include <map>
 #include <memory>
@@ skipping 54 matching lines @@
 
     connector_.reset(new mojo::Connector(
         std::move(handle), mojo::Connector::SINGLE_THREADED_SEND,
         task_runner_));
     connector_->set_incoming_receiver(&filters_);
     connector_->set_connection_error_handler(
         base::Bind(&ChannelAssociatedGroupController::OnPipeError,
                    base::Unretained(this)));
   }
 
-  void Start() {
-    DCHECK(!started_);
-    started_ = true;
+  void Pause() {
+    DCHECK(!paused_);
+    paused_ = true;
+  }
+
+  void Unpause() {
+    DCHECK(paused_);
+    paused_ = false;
   }
 
   void FlushOutgoingMessages() {
     std::vector<mojo::Message> outgoing_messages;
     std::swap(outgoing_messages, outgoing_messages_);
     for (auto& message : outgoing_messages)
       SendMessage(&message);
   }
 
   void CreateChannelEndpoints(mojom::ChannelAssociatedPtr* sender,
@@ skipping 378 matching lines @@
       DCHECK(endpoint->closed());
       MarkPeerClosedAndMaybeRemove(endpoint);
     }
 
     DCHECK(endpoints_.empty());
   }
 
   bool SendMessage(mojo::Message* message) {
     if (task_runner_->BelongsToCurrentThread()) {
       DCHECK(thread_checker_.CalledOnValidThread());
-      if (!connector_ || !started_) {
-        // Pipe may not be bound yet or the channel may still be paused, so we
-        // queue the message.
+      if (!connector_ || paused_) {
         outgoing_messages_.emplace_back(std::move(*message));
         return true;
       }
       return connector_->Accept(message);
     } else {
       // We always post tasks to the master endpoint thread when called from the
       // proxy thread in order to simulate IPC::ChannelProxy::Send behavior.
       DCHECK(proxy_task_runner_->BelongsToCurrentThread());
       task_runner_->PostTask(
           FROM_HERE,
@@ skipping 264 matching lines @@
     return true;
   }
 
   // Checked in places which must be run on the master endpoint's thread.
   base::ThreadChecker thread_checker_;
 
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 
   scoped_refptr<base::SingleThreadTaskRunner> proxy_task_runner_;
   const bool set_interface_id_namespace_bit_;
-  bool started_ = false;
+  bool paused_ = false;
   std::unique_ptr<mojo::Connector> connector_;
   mojo::FilterChain filters_;
   mojo::PipeControlMessageHandler control_message_handler_;
   ControlMessageProxyThunk control_message_proxy_thunk_;
   mojo::PipeControlMessageProxy control_message_proxy_;
 
   // Outgoing messages that were sent before this controller was bound to a
   // real message pipe.
   std::vector<mojo::Message> outgoing_messages_;
 
@@ skipping 31 matching lines @@
   void Connect() override {
     controller_->Bind(std::move(handle_));
 
     IPC::mojom::ChannelAssociatedPtr sender;
     IPC::mojom::ChannelAssociatedRequest receiver;
     controller_->CreateChannelEndpoints(&sender, &receiver);
 
     delegate_->OnPipesAvailable(std::move(sender), std::move(receiver));
   }
 
-  void Start() override {
-    controller_->Start();
+  void Pause() override {
+    controller_->Pause();
+  }
+
+  void Unpause() override {
+    controller_->Unpause();
   }
 
   void Flush() override {
     controller_->FlushOutgoingMessages();
   }
 
   mojo::AssociatedGroup* GetAssociatedGroup() override {
     return associated_group_.get();
   }
 
@@ skipping 14 matching lines @@
     Channel::Mode mode,
     Delegate* delegate,
     const scoped_refptr<base::SingleThreadTaskRunner>& ipc_task_runner) {
   return base::MakeUnique<MojoBootstrapImpl>(
       std::move(handle), delegate,
       new ChannelAssociatedGroupController(mode == Channel::MODE_SERVER,
                                            ipc_task_runner));
 }
 
 }  // namespace IPC