Makes HandleWatcher block until no longer waiting on pipe

mojo/public/cpp/bindings/lib/connector.cc

 // Copyright 2013 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 "mojo/public/cpp/bindings/lib/connector.h"
 
 #include <stddef.h>
 
 #include "mojo/public/cpp/bindings/error_handler.h"
 #include "mojo/public/cpp/environment/logging.h"
@@ skipping 16 matching lines @@
       destroyed_flag_(NULL) {
   // Even though we don't have an incoming receiver, we still want to monitor
   // the message pipe to know if is closed or encounters an error.
   WaitToReadMore();
 }
 
 Connector::~Connector() {
   if (destroyed_flag_)
     *destroyed_flag_ = true;
 
-  if (async_wait_id_)
-    waiter_->CancelWait(async_wait_id_);
+  CancelWait();
 }
 
 void Connector::CloseMessagePipe() {
+  CancelWait();
   Close(message_pipe_.Pass());
 }
 
 ScopedMessagePipeHandle Connector::PassMessagePipe() {
-  if (async_wait_id_) {
-    waiter_->CancelWait(async_wait_id_);
-    async_wait_id_ = 0;
-  }
+  CancelWait();
   return message_pipe_.Pass();
 }
 
 bool Connector::WaitForIncomingMessage() {
   if (error_)
     return false;
 
   MojoResult rv = Wait(message_pipe_.get(),
                        MOJO_HANDLE_SIGNAL_READABLE,
                        MOJO_DEADLINE_INDEFINITE);
@@ skipping 69 matching lines @@
   async_wait_id_ = 0;
   if (result != MOJO_RESULT_OK) {
     NotifyError();
     return;
   }
   ReadAllAvailableMessages();
   // At this point, this object might have been deleted. Return.
 }
 
 void Connector::WaitToReadMore() {
+  MOJO_DCHECK(!async_wait_id_);
   async_wait_id_ = waiter_->AsyncWait(message_pipe_.get().value(),
                                       MOJO_HANDLE_SIGNAL_READABLE,
                                       MOJO_DEADLINE_INDEFINITE,
                                       &Connector::CallOnHandleReady,
                                       this);
 }
 
 bool Connector::ReadSingleMessage(MojoResult* read_result) {
   bool receiver_result = false;
 
@@ skipping 34 matching lines @@
     if (!ReadSingleMessage(&rv))
       return;
 
     if (rv == MOJO_RESULT_SHOULD_WAIT) {
       WaitToReadMore();
       break;
     }
   }
 }
 
+void Connector::CancelWait() {
+  if (!async_wait_id_)
+    return;
+
+  waiter_->CancelWait(async_wait_id_);
+  async_wait_id_ = 0;
+}
+
 void Connector::NotifyError() {
   error_ = true;
   // The error handler might destroyed |this|. Also, after an error, all method
   // should end early.
   if (destroyed_flag_) {
     *destroyed_flag_ = true;  // Propagate flag.
   }
   if (error_handler_)
     error_handler_->OnConnectionError();
 }
 
 }  // namespace internal
 }  // namespace mojo