Mojo: AsyncWaiter and mojo/public/environment

mojo/public/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/bindings/lib/connector.h"
 
 #include <assert.h>
 #include <stdlib.h>
 
 #include <algorithm>
 
 namespace mojo {
 namespace internal {
 
 // ----------------------------------------------------------------------------
 
-Connector::Connector(ScopedMessagePipeHandle message_pipe)
-    : message_pipe_(message_pipe.Pass()),
+Connector::Connector(ScopedMessagePipeHandle message_pipe,
+                     MojoAsyncWaiter* waiter)
+    : waiter_(waiter),
+      message_pipe_(message_pipe.Pass()),
       incoming_receiver_(NULL),
       error_(false) {
 }
 
 Connector::~Connector() {
 }
 
 void Connector::SetIncomingReceiver(MessageReceiver* receiver) {
   assert(!incoming_receiver_);
   incoming_receiver_ = receiver;
@@ skipping 18 matching lines @@
 }
 
 void Connector::OnHandleReady(Callback* callback, MojoResult result) {
   if (callback == &read_callback_)
     ReadMore();
   if (callback == &write_callback_)
     WriteMore();
 }
 
 void Connector::WaitToReadMore() {
-  read_callback_.SetOwnerToNotify(this);
-  read_callback_.SetAsyncWaitID(
-      BindingsSupport::Get()->AsyncWait(message_pipe_.get(),
-                                        MOJO_WAIT_FLAG_READABLE,
-                                        &read_callback_));
+  CallAsyncWait(MOJO_WAIT_FLAG_READABLE, &read_callback_);
 }
 
 void Connector::WaitToWriteMore() {
-  write_callback_.SetOwnerToNotify(this);
-  write_callback_.SetAsyncWaitID(
-      BindingsSupport::Get()->AsyncWait(message_pipe_.get(),
-                                        MOJO_WAIT_FLAG_WRITABLE,
-                                        &write_callback_));
+  CallAsyncWait(MOJO_WAIT_FLAG_WRITABLE, &write_callback_);
+}
+
+void Connector::CallAsyncWait(MojoWaitFlags flags, Callback* callback) {
+  callback->SetOwnerToNotify(this);
+  callback->SetAsyncWaitID(
+      waiter_->AsyncWait(waiter_,
+                         message_pipe_.get().value(),
+                         MOJO_WAIT_FLAG_READABLE,
+                         MOJO_DEADLINE_INDEFINITE,
+                         &Callback::OnHandleReady,
+                         callback));
+}
+
+void Connector::CallCancelWait(MojoAsyncWaitID async_wait_id) {
+  waiter_->CancelWait(waiter_, async_wait_id);
 }
 
 void Connector::ReadMore() {
   for (;;) {
     MojoResult rv;
 
     uint32_t num_bytes = 0, num_handles = 0;
     rv = ReadMessageRaw(message_pipe_.get(),
                         NULL,
                         &num_bytes,
@@ skipping 68 matching lines @@
 
 // ----------------------------------------------------------------------------
 
 Connector::Callback::Callback()
     : owner_(NULL),
       async_wait_id_(0) {
 }
 
 Connector::Callback::~Callback() {
   if (owner_)
-    BindingsSupport::Get()->CancelWait(async_wait_id_);
+    owner_->CallCancelWait(async_wait_id_);
 }
 
 void Connector::Callback::SetOwnerToNotify(Connector* owner) {
   assert(!owner_);
   owner_ = owner;
 }
 
-void Connector::Callback::SetAsyncWaitID(BindingsSupport::AsyncWaitID id) {
+void Connector::Callback::SetAsyncWaitID(MojoAsyncWaitID id) {
   async_wait_id_ = id;
 }
 
-void Connector::Callback::OnHandleReady(MojoResult result) {
-  assert(owner_);
+// static
+void Connector::Callback::OnHandleReady(void* closure, MojoResult result) {
+  Callback* self = static_cast<Callback*>(closure);
+
+  // Reset |owner_| to indicate that we are no longer in the waiting state.
+
+  assert(self->owner_);
   Connector* owner = NULL;
-  std::swap(owner, owner_);
-  owner->OnHandleReady(this, result);
+  std::swap(owner, self->owner_);
+  owner->OnHandleReady(self, result);
 }
 
 }  // namespace internal
 }  // namespace mojo