src/mojo/public/js/router.js

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 define("mojo/public/js/router", [
   6   "mojo/public/js/codec",
   7   "mojo/public/js/connector",
   8   "mojo/public/js/validator",
   9 ], function(codec, connector, validator) {
  10
  11   function Router(handle, connectorFactory) {
  12     if (connectorFactory === undefined)
  13       connectorFactory = connector.Connector;
  14     this.connector_ = new connectorFactory(handle);
  15     this.incomingReceiver_ = null;
  16     this.nextRequestID_ = 0;
  17     this.completers_ = new Map();
  18     this.payloadValidators_ = [];
  19
  20     this.connector_.setIncomingReceiver({
  21         accept: this.handleIncomingMessage_.bind(this),
  22     });
  23     this.connector_.setErrorHandler({
  24         onError: this.handleConnectionError_.bind(this),
  25     });
  26   }
  27
  28   Router.prototype.close = function() {
  29     this.completers_.clear();  // Drop any responders.
  30     this.connector_.close();
  31   };
  32
  33   Router.prototype.accept = function(message) {
  34     this.connector_.accept(message);
  35   };
  36
  37   Router.prototype.reject = function(message) {
  38     // TODO(mpcomplete): no way to trasmit errors over a Connection.
  39   };
  40
  41   Router.prototype.acceptAndExpectResponse = function(message) {
  42     // Reserve 0 in case we want it to convey special meaning in the future.
  43     var requestID = this.nextRequestID_++;
  44     if (requestID == 0)
  45       requestID = this.nextRequestID_++;
  46
  47     message.setRequestID(requestID);
  48     var result = this.connector_.accept(message);
  49     if (!result)
  50       return Promise.reject(Error("Connection error"));
  51
  52     var completer = {};
  53     this.completers_.set(requestID, completer);
  54     return new Promise(function(resolve, reject) {
  55       completer.resolve = resolve;
  56       completer.reject = reject;
  57     });
  58   };
  59
  60   Router.prototype.setIncomingReceiver = function(receiver) {
  61     this.incomingReceiver_ = receiver;
  62   };
  63
  64   Router.prototype.setPayloadValidators = function(payloadValidators) {
  65     this.payloadValidators_ = payloadValidators;
  66   };
  67
  68   Router.prototype.encounteredError = function() {
  69     return this.connector_.encounteredError();
  70   };
  71
  72   Router.prototype.handleIncomingMessage_ = function(message) {
  73     var noError = validator.validationError.NONE;
  74     var messageValidator = new validator.Validator(message);
  75     var err = messageValidator.validateMessageHeader();
  76     for (var i = 0; err === noError && i < this.payloadValidators_.length; ++i)
  77       err = this.payloadValidators_[i](messageValidator);
  78
  79     if (err == noError)
  80       this.handleValidIncomingMessage_(message);
  81     else
  82       this.handleInvalidIncomingMessage_(message, err);
  83   };
  84
  85   Router.prototype.handleValidIncomingMessage_ = function(message) {
  86     if (message.expectsResponse()) {
  87       if (this.incomingReceiver_) {
  88         this.incomingReceiver_.acceptWithResponder(message, this);
  89       } else {
  90         // If we receive a request expecting a response when the client is not
  91         // listening, then we have no choice but to tear down the pipe.
  92         this.close();
  93       }
  94     } else if (message.isResponse()) {
  95       var reader = new codec.MessageReader(message);
  96       var requestID = reader.requestID;
  97       var completer = this.completers_.get(requestID);
  98       this.completers_.delete(requestID);
  99       completer.resolve(message);
 100     } else {
 101       if (this.incomingReceiver_)
 102         this.incomingReceiver_.accept(message);
 103     }
 104   }
 105
 106   Router.prototype.handleInvalidIncomingMessage_ = function(message, error) {
 107     this.close();
 108   }
 109
 110   Router.prototype.handleConnectionError_ = function(result) {
 111     this.completers_.forEach(function(value) {
 112       value.reject(result);
 113     });
 114     this.close();
 115   };
 116
 117   // The TestRouter subclass is only intended to be used in unit tests.
 118   // It defeats valid message handling and delgates invalid message handling.
 119
 120   function TestRouter(handle, connectorFactory) {
 121     Router.call(this, handle, connectorFactory);
 122   }
 123
 124   TestRouter.prototype = Object.create(Router.prototype);
 125
 126   TestRouter.prototype.handleValidIncomingMessage_ = function() {
 127   };
 128
 129   TestRouter.prototype.handleInvalidIncomingMessage_ =
 130       function(message, error) {
 131         this.validationErrorHandler(error);
 132       };
 133
 134   var exports = {};
 135   exports.Router = Router;
 136   exports.TestRouter = TestRouter;
 137   return exports;
 138 });