Feedback

Author: schmidt-sebastian

packages/storage/exp/index.ts

@@ -28,7 +28,7 @@ import {
   // eslint-disable-next-line import/no-extraneous-dependencies
 } from '@firebase/app-exp';
 
-import { XhrIoPool } from '../src/implementation/xhriopool';
+import { ConnectionPool } from '../src/implementation/connectionPool';
 import {
   StorageService as StorageServiceInternal,
   useStorageEmulator as useEmulatorInternal
@@ -76,7 +76,7 @@ function factory(
     app,
     authProvider,
     appCheckProvider,
-    new XhrIoPool(),
+    new ConnectionPool(),
     url,
     SDK_VERSION
   );

packages/storage/index.ts

@@ -20,7 +20,7 @@ import { _FirebaseNamespace } from '@firebase/app-types/private';
 import { StringFormat } from './src/implementation/string';
 import { TaskEvent, TaskState } from './src/implementation/taskenums';
 
-import { XhrIoPool } from './src/implementation/xhriopool';
+import { ConnectionPool } from './src/implementation/connectionPool';
 import { ReferenceCompat } from './compat/reference';
 import { StorageServiceCompat } from './compat/service';
 import { StorageService } from './src/service';
@@ -59,7 +59,7 @@ function factory(
       app,
       authProvider,
       appCheckProvider,
-      new XhrIoPool(),
+      new ConnectionPool(),
       url,
       firebase.SDK_VERSION
     )

packages/storage/karma.conf.js

@@ -31,6 +31,7 @@ module.exports = function (config) {
 };
 
 function getTestFiles(argv) {
+  process.env.TEST_PLATFORM = 'browser';
   let unitTestFiles = ['test/unit/*'];
   let integrationTestFiles = [];
   if (argv.exp) {

packages/storage/src/implementation/xhrio.ts renamed to packages/storage/src/implementation/connection.ts

@@ -16,7 +16,7 @@
  */
 
 /**
- * XHR headers
+ * Network headers
  */
 export interface Headers {
   [name: string]: string;
@@ -26,12 +26,12 @@ export interface Headers {
  * A lightweight wrapper around XMLHttpRequest with a
  * goog.net.XhrIo-like interface.
  */
-export interface XhrIo {
+export interface Connection {
   send(
     url: string,
     method: string,
     body?: ArrayBufferView | Blob | string | null,
-    headers?: Record<string, string>
+    headers?: Headers
   ): Promise<void>;
 
   getErrorCode(): ErrorCode;

packages/storage/src/implementation/xhriopool.ts renamed to packages/storage/src/implementation/connectionPool.ts

@@ -18,14 +18,14 @@
 /**
  * @fileoverview Replacement for goog.net.XhrIoPool that works with fbs.XhrIo.
  */
-import { XhrIo } from './xhrio';
+import { Connection } from './connection';
 import { newConnection } from '../platform/connection';
 
 /**
  * Factory-like class for creating XhrIo instances.
  */
-export class XhrIoPool {
-  createXhrIo(): XhrIo {
+export class ConnectionPool {
+  createConnection(): Connection {
     return newConnection();
   }
 }

packages/storage/src/implementation/request.ts

@@ -31,8 +31,8 @@ import {
 import { RequestInfo } from './requestinfo';
 import { isJustDef } from './type';
 import { makeQueryString } from './url';
-import { Headers, XhrIo, ErrorCode } from './xhrio';
-import { XhrIoPool } from './xhriopool';
+import { Headers, Connection, ErrorCode } from './connection';
+import { ConnectionPool } from './connectionPool';
 
 export interface Request<T> {
   getPromise(): Promise<T>;
@@ -54,20 +54,20 @@ class NetworkRequest<T> implements Request<T> {
   private body_: string | Blob | Uint8Array | null;
   private successCodes_: number[];
   private additionalRetryCodes_: number[];
-  private pendingXhr_: XhrIo | null = null;
+  private pendingConnection_: Connection | null = null;
   private backoffId_: backoffId | null = null;
   private resolve_!: (value?: T | PromiseLike<T>) => void;
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   private reject_!: (reason?: any) => void;
   private canceled_: boolean = false;
   private appDelete_: boolean = false;
-  private callback_: (p1: XhrIo, p2: string) => T;
+  private callback_: (p1: Connection, p2: string) => T;
   private errorCallback_:
-    | ((p1: XhrIo, p2: FirebaseStorageError) => FirebaseStorageError)
+    | ((p1: Connection, p2: FirebaseStorageError) => FirebaseStorageError)
     | null;
   private progressCallback_: ((p1: number, p2: number) => void) | null;
   private timeout_: number;
-  private pool_: XhrIoPool;
+  private pool_: ConnectionPool;
   promise_: Promise<T>;
 
   constructor(
@@ -77,13 +77,13 @@ class NetworkRequest<T> implements Request<T> {
     body: string | Blob | Uint8Array | null,
     successCodes: number[],
     additionalRetryCodes: number[],
-    callback: (p1: XhrIo, p2: string) => T,
+    callback: (p1: Connection, p2: string) => T,
     errorCallback:
-      | ((p1: XhrIo, p2: FirebaseStorageError) => FirebaseStorageError)
+      | ((p1: Connection, p2: FirebaseStorageError) => FirebaseStorageError)
       | null,
     timeout: number,
     progressCallback: ((p1: number, p2: number) => void) | null,
-    pool: XhrIoPool
+    pool: ConnectionPool
   ) {
     this.url_ = url;
     this.method_ = method;
@@ -117,8 +117,8 @@ class NetworkRequest<T> implements Request<T> {
         backoffCallback(false, new RequestEndStatus(false, null, true));
         return;
       }
-      const xhr = self.pool_.createXhrIo();
-      self.pendingXhr_ = xhr;
+      const connection = self.pool_.createConnection();
+      self.pendingConnection_ = connection;
 
       function progressListener(progressEvent: ProgressEvent): void {
         const loaded = progressEvent.loaded;
@@ -128,28 +128,30 @@ class NetworkRequest<T> implements Request<T> {
         }
       }
       if (self.progressCallback_ !== null) {
-        xhr.addUploadProgressListener(progressListener);
+        connection.addUploadProgressListener(progressListener);
       }
 
       // eslint-disable-next-line @typescript-eslint/no-floating-promises
-      xhr.send(self.url_, self.method_, self.body_, self.headers_).then(() => {
-        if (self.progressCallback_ !== null) {
-          xhr.removeUploadProgressListener(progressListener);
-        }
-        self.pendingXhr_ = null;
-        const hitServer = xhr.getErrorCode() === ErrorCode.NO_ERROR;
-        const status = xhr.getStatus();
-        if (!hitServer || self.isRetryStatusCode_(status)) {
-          const wasCanceled = xhr.getErrorCode() === ErrorCode.ABORT;
-          backoffCallback(
-            false,
-            new RequestEndStatus(false, null, wasCanceled)
-          );
-          return;
-        }
-        const successCode = self.successCodes_.indexOf(status) !== -1;
-        backoffCallback(true, new RequestEndStatus(successCode, xhr));
-      });
+      connection
+        .send(self.url_, self.method_, self.body_, self.headers_)
+        .then(() => {
+          if (self.progressCallback_ !== null) {
+            connection.removeUploadProgressListener(progressListener);
+          }
+          self.pendingConnection_ = null;
+          const hitServer = connection.getErrorCode() === ErrorCode.NO_ERROR;
+          const status = connection.getStatus();
+          if (!hitServer || self.isRetryStatusCode_(status)) {
+            const wasCanceled = connection.getErrorCode() === ErrorCode.ABORT;
+            backoffCallback(
+              false,
+              new RequestEndStatus(false, null, wasCanceled)
+            );
+            return;
+          }
+          const successCode = self.successCodes_.indexOf(status) !== -1;
+          backoffCallback(true, new RequestEndStatus(successCode, connection));
+        });
     }
 
     /**
@@ -162,10 +164,13 @@ class NetworkRequest<T> implements Request<T> {
     ): void {
       const resolve = self.resolve_;
       const reject = self.reject_;
-      const xhr = status.xhr as XhrIo;
+      const connection = status.connection as Connection;
       if (status.wasSuccessCode) {
         try {
-          const result = self.callback_(xhr, xhr.getResponseText());
+          const result = self.callback_(
+            connection,
+            connection.getResponseText()
+          );
           if (isJustDef(result)) {
             resolve(result);
           } else {
@@ -175,11 +180,11 @@ class NetworkRequest<T> implements Request<T> {
           reject(e);
         }
       } else {
-        if (xhr !== null) {
+        if (connection !== null) {
           const err = unknown();
-          err.serverResponse = xhr.getResponseText();
+          err.serverResponse = connection.getResponseText();
           if (self.errorCallback_) {
-            reject(self.errorCallback_(xhr, err));
+            reject(self.errorCallback_(connection, err));
           } else {
             reject(err);
           }
@@ -213,8 +218,8 @@ class NetworkRequest<T> implements Request<T> {
     if (this.backoffId_ !== null) {
       stop(this.backoffId_);
     }
-    if (this.pendingXhr_ !== null) {
-      this.pendingXhr_.abort();
+    if (this.pendingConnection_ !== null) {
+      this.pendingConnection_.abort();
     }
   }
 
@@ -247,7 +252,7 @@ export class RequestEndStatus {
 
   constructor(
     public wasSuccessCode: boolean,
-    public xhr: XhrIo | null,
+    public connection: Connection | null,
     canceled?: boolean
   ) {
     this.canceled = !!canceled;
@@ -291,7 +296,7 @@ export function makeRequest<T>(
   appId: string | null,
   authToken: string | null,
   appCheckToken: string | null,
-  pool: XhrIoPool,
+  pool: ConnectionPool,
   firebaseVersion?: string
 ): Request<T> {
   const queryPart = makeQueryString(requestInfo.urlParams);

packages/storage/src/implementation/requestinfo.ts

@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 import { FirebaseStorageError } from './error';
-import { Headers, XhrIo } from './xhrio';
+import { Headers, Connection } from './connection';
 
 /**
  * Type for url params stored in RequestInfo.
@@ -30,7 +30,7 @@ export class RequestInfo<T> {
   body: Blob | string | Uint8Array | null = null;
 
   errorHandler:
-    | ((p1: XhrIo, p2: FirebaseStorageError) => FirebaseStorageError)
+    | ((p1: Connection, p2: FirebaseStorageError) => FirebaseStorageError)
     | null = null;
 
   /**
@@ -51,7 +51,7 @@ export class RequestInfo<T> {
      * Note: The XhrIo passed to this function may be reused after this callback
      * returns. Do not keep a reference to it in any way.
      */
-    public handler: (p1: XhrIo, p2: string) => T,
+    public handler: (p1: Connection, p2: string) => T,
     public timeout: number
   ) {}
 }

packages/storage/src/implementation/requestmaker.ts

@@ -16,13 +16,13 @@
  */
 import { Request } from './request';
 import { RequestInfo } from './requestinfo';
-import { XhrIoPool } from './xhriopool';
+import { ConnectionPool } from './connectionPool';
 
 type requestMaker = <T>(
   requestInfo: RequestInfo<T>,
   appId: string | null,
   authToken: string | null,
-  pool: XhrIoPool
+  pool: ConnectionPool
 ) => Request<T>;
 
 export { requestMaker };