Mojo: Add BindingsSupportImpl on top of HandleWatcher

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 {
 
 // ----------------------------------------------------------------------------
 
 Connector::Connector(Handle message_pipe)
     : message_pipe_(message_pipe),
       incoming_receiver_(NULL),
       error_(false) {
 }
 
 Connector::~Connector() {
-  if (read_callback_.IsPending())
-    read_callback_.Cancel();
-  if (write_callback_.IsPending())
-    write_callback_.Cancel();
 }
 
 void Connector::SetIncomingReceiver(MessageReceiver* receiver) {
   assert(!incoming_receiver_);
   incoming_receiver_ = receiver;
   if (incoming_receiver_)
     WaitToReadMore();
 }
 
 bool Connector::Accept(Message* message) {
@@ skipping 14 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);
-
-  bool ok = BindingsSupport::Get()->AsyncWait(message_pipe_,
-                                              MOJO_WAIT_FLAG_READABLE,
-                                              MOJO_DEADLINE_INDEFINITE,
-                                              &read_callback_);
-  if (!ok)
-    error_ = true;
+  read_callback_.SetAsyncWaitID(
+      BindingsSupport::Get()->AsyncWait(message_pipe_,
+                                        MOJO_WAIT_FLAG_READABLE,
+                                        &read_callback_));
 }
 
 void Connector::WaitToWriteMore() {
   write_callback_.SetOwnerToNotify(this);
-
-  bool ok = BindingsSupport::Get()->AsyncWait(message_pipe_,
-                                              MOJO_WAIT_FLAG_WRITABLE,
-                                              MOJO_DEADLINE_INDEFINITE,
-                                              &write_callback_);
-  if (!ok)
-    error_ = true;
+  write_callback_.SetAsyncWaitID(
+      BindingsSupport::Get()->AsyncWait(message_pipe_,
+                                        MOJO_WAIT_FLAG_WRITABLE,
+                                        &write_callback_));
 }
 
 void Connector::ReadMore() {
   for (;;) {
     MojoResult rv;
 
     uint32_t num_bytes = 0, num_handles = 0;
     rv = ReadMessage(message_pipe_,
                      NULL,
                      &num_bytes,
@@ skipping 44 matching lines @@
 void Connector::WriteOne(Message* message, bool* wait_to_write) {
   // TODO(darin): WriteMessage will eventually start generating an error that
   // it cannot accept more data. In that case, we'll need to wait on the pipe
   // to determine when we can try writing again. This flag will be set to true
   // in that case.
   *wait_to_write = false;
 
   MojoResult rv = WriteMessage(message_pipe_,
                                message->data,
                                message->data->header.num_bytes,
-                               message->handles.data(),
+                               &message->handles[0],
                                static_cast<uint32_t>(message->handles.size()),
                                MOJO_WRITE_MESSAGE_FLAG_NONE);
   if (rv == MOJO_RESULT_OK) {
     // The handles were successfully transferred, so we don't need the message
     // to track their lifetime any longer.
     message->handles.clear();
   } else {
     error_ = true;
   }
 }
 
 // ----------------------------------------------------------------------------
 
 Connector::Callback::Callback()
-    : owner_(NULL) {
+    : owner_(NULL),
+      async_wait_id_(0) {
 }
 
-void Connector::Callback::Cancel() {
-  owner_ = NULL;
-  BindingsSupport::Get()->CancelWait(this);
+Connector::Callback::~Callback() {
+  if (owner_)
+    BindingsSupport::Get()->CancelWait(async_wait_id_);
 }
 
 void Connector::Callback::SetOwnerToNotify(Connector* owner) {
   assert(!owner_);
   owner_ = owner;
 }
 
-bool Connector::Callback::IsPending() const {
-  return owner_ != NULL;
+void Connector::Callback::SetAsyncWaitID(BindingsSupport::AsyncWaitID id) {
+  async_wait_id_ = id;
 }
 
 void Connector::Callback::OnHandleReady(MojoResult result) {
   assert(owner_);
   Connector* owner = NULL;
   std::swap(owner, owner_);
   owner->OnHandleReady(this, result);
 }
 
 }  // namespace mojo