Handle error in connector and close handle and swap with dummy handle.

mojo/public/js/router.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/router", [
   "mojo/public/js/connector",
   "mojo/public/js/core",
   "mojo/public/js/interface_types",
   "mojo/public/js/lib/interface_endpoint_handle",
   "mojo/public/js/lib/pipe_control_message_handler",
@@ skipping 135 matching lines @@
             this.cachedMessageData.message.getInterfaceId());
         // Check that the target endpoint's client still exists.
         if (targetEndpoint && targetEndpoint.client) {
           var message = this.cachedMessageData.message;
           var messageValidator = this.cachedMessageData.messageValidator;
           this.cachedMessageData = null;
           this.connector_.resumeIncomingMethodCallProcessing();
           var ok = endpoint.client.handleIncomingMessage(message,
               messageValidator);
 
-          if (!ok) {
-            this.handleInvalidIncomingMessage_();
+          // Handle invalid cached incoming message.
+          if (!validator.isTestingMode() && !ok) {
+            this.connector_.handleError(true, true);
           }
         }
       }).bind(this));
     }
 
     return endpoint;
   };
 
   Router.prototype.detachEndpointClient = function(
       interfaceEndpointHandle) {
@@ skipping 60 matching lines @@
           // We need to wait until a client is attached in order to dispatch
           // further messages.
           this.cachedMessageData = {message: message,
               messageValidator: messageValidator};
           this.connector_.pauseIncomingMethodCallProcessing();
           return true;
         }
         ok = endpoint.client.handleIncomingMessage(message, messageValidator);
       }
     }
-
-    if (!ok) {
-      this.handleInvalidIncomingMessage_();
-    }
     return ok;
   };
 
   Router.prototype.close = function() {
     this.connector_.close();
     // Closing the message pipe won't trigger connection error handler.
     // Explicitly call onPipeConnectionError() so that associated endpoints
     // will get notified.
     this.onPipeConnectionError();
   };
 
   Router.prototype.waitForNextMessageForTesting = function() {
     this.connector_.waitForNextMessageForTesting();
   };
 
-  Router.prototype.handleInvalidIncomingMessage_ = function(message) {
-    if (!validator.isTestingMode()) {
-      // TODO(yzshen): Consider notifying the embedder.
-      // TODO(yzshen): This should also trigger connection error handler.
-      // Consider making accept() return a boolean and let the connector deal
-      // with this, as the C++ code does.
-      this.close();
-      return;
-    }
-  };
-
   Router.prototype.onPeerAssociatedEndpointClosed = function(interfaceId,
       reason) {
     check(!types.isMasterInterfaceId(interfaceId) || reason);
 
     var endpoint = this.endpoints_.get(interfaceId);
     if (!endpoint) {
       endpoint = new InterfaceEndpoint(this, interfaceId);
       this.endpoints_.set(interfaceId, endpoint);
     }
 
@@ skipping 58 matching lines @@
     }
     if (endpoint.closed && endpoint.peerClosed) {
       this.endpoints_.delete(endpoint.id);
     }
   };
 
   var exports = {};
   exports.Router = Router;
   return exports;
 });