[mojo-bindings] Use Watcher API for JS bindings

mojo/public/js/connector.js

 // 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.
 
 define("mojo/public/js/connector", [
   "mojo/public/js/buffer",
   "mojo/public/js/codec",
   "mojo/public/js/core",
   "mojo/public/js/support",
 ], function(buffer, codec, core, support) {
 
   function Connector(handle) {
     if (!core.isHandle(handle))
       throw new Error("Connector: not a handle " + handle);
     this.handle_ = handle;
     this.dropWrites_ = false;
     this.error_ = false;
     this.incomingReceiver_ = null;
-    this.readWaitCookie_ = null;
+    this.readWatcher_ = null;
     this.errorHandler_ = null;
 
-    if (handle)
-      this.waitToReadMore_();
+    if (handle) {
+      this.readWatcher_ = support.watch(handle,
+                                        core.HANDLE_SIGNAL_READABLE,
+                                        this.readMore_.bind(this));
+    }
   }
 
   Connector.prototype.close = function() {
-    if (this.readWaitCookie_) {
-      support.cancelWait(this.readWaitCookie_);
-      this.readWaitCookie_ = null;
+    if (this.readWatcher_) {
+      support.cancelWatch(this.readWatcher_);
+      this.readWatcher_ = null;
     }
     if (this.handle_ != null) {
       core.close(this.handle_);
       this.handle_ = null;
     }
   };
 
   Connector.prototype.accept = function(message) {
     if (this.error_)
       return false;
@@ skipping 32 matching lines @@
   };
 
   Connector.prototype.setErrorHandler = function(handler) {
     this.errorHandler_ = handler;
   };
 
   Connector.prototype.encounteredError = function() {
     return this.error_;
   };
 
-  Connector.prototype.waitToReadMore_ = function() {
-    this.readWaitCookie_ = support.asyncWait(this.handle_,
-                                             core.HANDLE_SIGNAL_READABLE,
-                                             this.readMore_.bind(this));
-  };
-
   Connector.prototype.readMore_ = function(result) {
     for (;;) {
       var read = core.readMessage(this.handle_,
                                   core.READ_MESSAGE_FLAG_NONE);
       if (this.handle_ == null) // The connector has been closed.
         return;
-      if (read.result == core.RESULT_SHOULD_WAIT) {
-        this.waitToReadMore_();
+      if (read.result == core.RESULT_SHOULD_WAIT)
         return;
-      }
       if (read.result != core.RESULT_OK) {
         this.error_ = true;
         if (this.errorHandler_)
           this.errorHandler_.onError(read.result);
         return;
       }
       var messageBuffer = new buffer.Buffer(read.buffer);
       var message = new codec.Message(messageBuffer, read.handles);
       if (this.incomingReceiver_) {
           this.incomingReceiver_.accept(message);
       }
     }
   };
 
   // The TestConnector subclass is only intended to be used in unit tests. It
   // doesn't automatically listen for input messages. Instead, you need to
   // call waitForNextMessage to block and wait for the next incoming message.
   function TestConnector(handle) {
     Connector.call(this, handle);
   }
 
   TestConnector.prototype = Object.create(Connector.prototype);
 
-  TestConnector.prototype.waitToReadMore_ = function() {
-  }
-
   TestConnector.prototype.waitForNextMessage = function() {
     var wait = core.wait(this.handle_, core.HANDLE_SIGNAL_READABLE,
                          core.DEADLINE_INDEFINITE);
     this.readMore_(wait.result);
   }
 
   var exports = {};
   exports.Connector = Connector;
   exports.TestConnector = TestConnector;
   return exports;
 });