Add encounteredError() to AssociatedInterfacePtrController.

mojo/public/js/lib/interface_endpoint_client.js

 // Copyright 2017 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/lib/interface_endpoint_client", [
   "console",
   "mojo/public/js/codec",
   "mojo/public/js/lib/control_message_handler",
   "mojo/public/js/lib/control_message_proxy",
   "mojo/public/js/lib/interface_endpoint_handle",
   "mojo/public/js/validator",
   "timer",
 ], function(console,
             codec,
             controlMessageHandler,
             controlMessageProxy,
             interfaceEndpointHandle,
             validator,
             timer) {
 
   var ControlMessageHandler = controlMessageHandler.ControlMessageHandler;
   var ControlMessageProxy = controlMessageProxy.ControlMessageProxy;
   var MessageReader = codec.MessageReader;
   var InterfaceEndpointHandle = interfaceEndpointHandle.InterfaceEndpointHandle;
   var AssociationEvent = interfaceEndpointHandle.AssociationEvent;
 
   function InterfaceEndpointClient(interfaceEndpointHandle, receiver,
       interfaceVersion) {
     this.controller_ = null;
-    this.encounteredError_ = false;
+    this.encounteredError = false;

[Ken Rockot(use gerrit already), 2017/04/27 15:03:27]

I would prefer that we keep this value "private".

You could either add an encounteredError() function to access it, or add a
public getter property:

var getProperty = function(client) { return client.encounteredError_; };
Object.defineProperty(this, "encounteredError", getProperty.bind(this));

which would then be accessible like any other object property (i.e.,
fooClient.encounteredError), but read-only.

     this.handle_ = interfaceEndpointHandle;
     this.incomingReceiver_ = receiver;
 
     if (interfaceVersion !== undefined) {
       this.controlMessageHandler_ = new ControlMessageHandler(
           interfaceVersion);
     } else {
       this.controlMessageProxy_ = new ControlMessageProxy(this);
     }
 
@@ skipping 51 matching lines @@
     var handle = this.passHandle();
     handle.reset(reason);
   };
 
   InterfaceEndpointClient.prototype.accept = function(message) {
     if (message.associatedEndpointHandles.length > 0) {
       message.serializeAssociatedEndpointHandles(
           this.handle_.groupController());
     }
 
-    if (this.encounteredError_) {
+    if (this.encounteredError) {
       return false;
     }
 
     this.initControllerIfNecessary_();
     return this.controller_.sendMessage(message);
   };
 
   InterfaceEndpointClient.prototype.acceptAndExpectResponse = function(
       message) {
     if (message.associatedEndpointHandles.length > 0) {
       message.serializeAssociatedEndpointHandles(
           this.handle_.groupController());
     }
 
-    if (this.encounteredError_) {
+    if (this.encounteredError) {
       return Promise.reject();
     }
 
     this.initControllerIfNecessary_();
 
     // Reserve 0 in case we want it to convey special meaning in the future.
     var requestID = this.nextRequestID_++;
     if (requestID === 0)
       requestID = this.nextRequestID_++;
 
@@ skipping 38 matching lines @@
       return false;
     }
   };
 
   InterfaceEndpointClient.prototype.handleValidIncomingMessage_ = function(
       message) {
     if (validator.isTestingMode()) {
       return true;
     }
 
-    if (this.encounteredError_) {
+    if (this.encounteredError) {
       return false;
     }
 
     var ok = false;
 
     if (message.expectsResponse()) {
       if (controlMessageHandler.isControlMessage(message) &&
           this.controlMessageHandler_) {
         ok = this.controlMessageHandler_.acceptWithResponder(message, this);
       } else if (this.incomingReceiver_) {
@@ skipping 15 matching lines @@
           this.controlMessageHandler_) {
         ok = this.controlMessageHandler_.accept(message);
       } else if (this.incomingReceiver_) {
         ok = this.incomingReceiver_.accept(message);
       }
     }
     return ok;
   };
 
   InterfaceEndpointClient.prototype.notifyError = function(reason) {
-    if (this.encounteredError_) {
+    if (this.encounteredError) {
       return;
     }
-    this.encounteredError_ = true;
+    this.encounteredError = true;
 
     this.completers_.forEach(function(value) {
       value.reject();
     });
     this.completers_.clear();  // Drop any responders.
 
     if (this.connectionErrorHandler_) {
       this.connectionErrorHandler_(reason);
     }
   };
 
   InterfaceEndpointClient.prototype.queryVersion = function() {
     return this.controlMessageProxy_.queryVersion();
   };
 
   InterfaceEndpointClient.prototype.requireVersion = function(version) {
     this.controlMessageProxy_.requireVersion(version);
   };
 
   var exports = {};
   exports.InterfaceEndpointClient = InterfaceEndpointClient;
 
   return exports;
 });