Improve error type with RpcError & internal code sync

README.md

@@ -271,7 +271,7 @@ const request = new EchoRequest();
 request.setMessage('Hello World!');
 
 const call = echoService.echo(request, {'custom-header-1': 'value1'},
-  (err: grpcWeb.Error, response: EchoResponse) => {
+  (err: grpcWeb.RpcError, response: EchoResponse) => {
     console.log(response.getMessage());
   });
 call.on('status', (status: grpcWeb.Status) => {

javascript/net/grpc/web/abstractclientbase.js

@@ -28,9 +28,8 @@ goog.module.declareLegacyNamespace();
 
 
 const ClientReadableStream = goog.require('grpc.web.ClientReadableStream');
-const GrpcWebError = goog.require('grpc.web.Error');
 const MethodDescriptor = goog.require('grpc.web.MethodDescriptor');
-const MethodType = goog.require('grpc.web.MethodType');
+const RpcError = goog.require('grpc.web.RpcError');
 
 
 /**
@@ -46,10 +45,9 @@ const AbstractClientBase = class {
    * @param {string} method The method to invoke
    * @param {REQUEST} requestMessage The request proto
    * @param {!Object<string, string>} metadata User defined call metadata
-   * @param {!MethodDescriptor<REQUEST, RESPONSE>|
-   *     !AbstractClientBase.MethodInfo<REQUEST, RESPONSE>}
+   * @param {!MethodDescriptor<REQUEST, RESPONSE>}
    *   methodDescriptor Information of this RPC method
-   * @param {function(?GrpcWebError, ?)}
+   * @param {function(?RpcError, ?)}
    *   callback A callback function which takes (error, RESPONSE or null)
    * @return {!ClientReadableStream<RESPONSE>}
    */
@@ -62,8 +60,7 @@ const AbstractClientBase = class {
    * @param {string} method The method to invoke
    * @param {REQUEST} requestMessage The request proto
    * @param {!Object<string, string>} metadata User defined call metadata
-   * @param {!MethodDescriptor<REQUEST, RESPONSE>|
-   *     !AbstractClientBase.MethodInfo<REQUEST,RESPONSE>}
+   * @param {!MethodDescriptor<REQUEST, RESPONSE>}
    *   methodDescriptor Information of this RPC method
    * @return {!IThenable<RESPONSE>}
    *   A promise that resolves to the response message
@@ -76,36 +73,12 @@ const AbstractClientBase = class {
    * @param {string} method The method to invoke
    * @param {REQUEST} requestMessage The request proto
    * @param {!Object<string, string>} metadata User defined call metadata
-   * @param {!MethodDescriptor<REQUEST, RESPONSE>|
-   *     !AbstractClientBase.MethodInfo<REQUEST,RESPONSE>}
+   * @param {!MethodDescriptor<REQUEST, RESPONSE>}
    *   methodDescriptor Information of this RPC method
    * @return {!ClientReadableStream<RESPONSE>} The Client Readable Stream
    */
   serverStreaming(method, requestMessage, metadata, methodDescriptor) {}
 
-  /**
-   * As MethodType is being deprecated, for now we need to convert MethodType to
-   * MethodDescriptor.
-   * @static
-   * @template REQUEST, RESPONSE
-   * @param {string} method
-   * @param {REQUEST} requestMessage
-   * @param {!MethodType} methodType
-   * @param {!AbstractClientBase.MethodInfo<REQUEST,RESPONSE>|!MethodDescriptor<REQUEST,RESPONSE>}
-   *     methodInfo
-   * @return {!MethodDescriptor<REQUEST,RESPONSE>}
-   */
-  static ensureMethodDescriptor(
-      method, requestMessage, methodType, methodInfo) {
-    if (methodInfo instanceof MethodDescriptor) {
-      return methodInfo;
-    }
-    const requestType = methodInfo.requestType || requestMessage.constructor;
-    return new MethodDescriptor(
-        method, methodType, requestType, methodInfo.responseType,
-        methodInfo.requestSerializeFn, methodInfo.responseDeserializeFn);
-  }
-
   /**
    * Get the hostname of the current request.
    * @static
@@ -121,31 +94,5 @@ const AbstractClientBase = class {
 };
 
 
-/** @template REQUEST, RESPONSE */
-AbstractClientBase.MethodInfo = class {
-  /**
-   * @param {function(new: RESPONSE, ...)} responseType
-   * @param {function(REQUEST): ?} requestSerializeFn
-   * @param {function(?): RESPONSE} responseDeserializeFn
-   * @param {string=} name
-   * @param {function(new: REQUEST, ...)=} requestType
-   */
-  constructor(
-      responseType, requestSerializeFn, responseDeserializeFn, name,
-      requestType) {
-    /** @const */
-    this.name = name;
-    /** @const */
-    this.requestType = requestType;
-    /** @const */
-    this.responseType = responseType;
-    /** @const */
-    this.requestSerializeFn = requestSerializeFn;
-    /** @const */
-    this.responseDeserializeFn = responseDeserializeFn;
-  }
-};
-
-
 
 exports = AbstractClientBase;

javascript/net/grpc/web/clientoptions.js

@@ -1,7 +1,6 @@
 goog.module('grpc.web.ClientOptions');
 goog.module.declareLegacyNamespace();
 
-const XmlHttpFactory = goog.requireType('goog.net.XmlHttpFactory');
 const {StreamInterceptor, UnaryInterceptor} = goog.require('grpc.web.Interceptor');
 
 
@@ -47,18 +46,20 @@ class ClientOptions {
     this.format;
 
     /**
-     * The XmlHttpFactory for server-streaming calls.
-     * Example: use 'goog.net.FetchXmlHttpFactory' to reduce memory consumption
-     * during high throughput server-streaming calls.
-     * <pre>
-     * ...
-     *
-     * const xmlHttpFactory =
-     *   new FetchXmlHttpFactory({streamBinaryChunks: true});
-     * </pre>
-     * @type {!XmlHttpFactory|undefined}
+     * The Worker global scope. Once this option is specified, gRPC-Web will
+     * also use 'fetch' API as the underlying transport instead of native
+     * XmlHttpRequest.
+     * @type {!WorkerGlobalScope|undefined}
      */
-    this.streamingXmlHttpFactory;
+    this.workerScope;
+
+    /**
+     * This is an experimental feature to reduce memory consumption
+     * during high throughput server-streaming calls by using
+     * 'streamBinaryChunks' mode FetchXmlHttpFactory.
+     * @type {boolean|undefined}
+     */
+    this.useFetchDownloadStreams;
   }
 }
 

javascript/net/grpc/web/clientreadablestream.js

@@ -45,6 +45,21 @@ const ClientReadableStream = function() {};
 /**
  * Register a callback to handle different stream events.
  *
+ * Available event types for gRPC-Web:
+ * 'data': The 'data' event is emitted when a new response message chunk is
+ * received and successfully handled by gRPC-Web client.
+ * 'status': the google RPC status of the response stream.
+ * 'end': The 'end' event is emitted when all the data have been successfully
+ * consumed from the stream.
+ * 'error': typically, this may occur when an  underlying internal failure
+ * happens, or a stream implementation attempts to push an invalid chunk of
+ * data.
+ * 'metadata': the response metadata. Response headers should be read via
+ * 'metadata' callbacks.
+ *
+ * For server-streaming calls. the 'data' and 'status' callbacks (if exist)
+ * will always precede 'metadata', 'error', or 'end' callbacks.
+ *
  * @param {string} eventType The event type
  * @param {function(?)} callback The callback to handle the event with
  * an optional input object