create DOMClock, abstraction of clock functionalities for DOM

src/matrix/error.js

@@ -12,8 +12,7 @@ export class HomeServerError extends Error {
     }
 }
 
-export class RequestAbortError extends Error {
-}
+export {AbortError} from "../utils/error.js";
 
 export class NetworkError extends Error { 
 }

src/matrix/net/fetch.js

@@ -1,5 +1,5 @@
 import {
-    RequestAbortError,
+    AbortError,
     NetworkError
 } from "../error.js";
 
@@ -50,7 +50,7 @@ export default function fetchRequest(url, options) {
         return {status, body};
     }, err => {
         if (err.name === "AbortError") {
-            throw new RequestAbortError();
+            throw new AbortError();
         } else if (err instanceof TypeError) {
             // Network errors are reported as TypeErrors, see
             // https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API/Using_Fetch#Checking_that_the_fetch_was_successful

src/matrix/net/replay.js

@@ -1,5 +1,5 @@
 import {
-    RequestAbortError,
+    AbortError,
     NetworkError
 } from "../error.js";
 
@@ -23,7 +23,7 @@ class RequestLogItem {
     handleError(err) {
         this.end = performance.now();
         this.error = {
-            aborted: err instanceof RequestAbortError,
+            aborted: err instanceof AbortError,
             network: err instanceof NetworkError,
             message: err.message,
         };
@@ -96,7 +96,7 @@ class ReplayRequestResult {
         if (this._item.error || this._aborted) {
             const error = this._item.error;
             if (error.aborted || this._aborted) {
-                throw new RequestAbortError(error.message);
+                throw new AbortError(error.message);
             } else if (error.network) {
                 throw new NetworkError(error.message);
             } else {

src/matrix/sync.js

@@ -1,4 +1,4 @@
-import {RequestAbortError} from "./error.js";
+import {AbortError} from "./error.js";
 import EventEmitter from "../EventEmitter.js";
 
 const INCREMENTAL_TIMEOUT = 30000;
@@ -57,7 +57,7 @@ export default class Sync extends EventEmitter {
                 syncToken = await this._syncRequest(syncToken, INCREMENTAL_TIMEOUT);
             } catch (err) {
                 this._isSyncing = false;
-                if (!(err instanceof RequestAbortError)) {
+                if (!(err instanceof AbortError)) {
                     console.error("stopping sync because of error");
                     console.error(err);
                     this.emit("status", "error", err);

src/utils/DOMClock.js

@@ -0,0 +1,49 @@
+import {AbortError} from "./error.js";
+
+class DOMTimeout {
+    constructor(ms) {
+        this._reject = null;
+        this._promise = new Promise((resolve, reject) => {
+            this._reject = reject;
+            setTimeout(() => {
+                this._reject = null;
+                resolve();
+            }, ms);
+        });
+    }
+
+    get elapsed() {
+        return this._promise;
+    }
+
+    abort() {
+        if (this._reject) {
+            this._reject(new AbortError());
+            this._reject = null;
+        }
+    }
+}
+
+class DOMTimeMeasure {
+    constructor() {
+        this._start = window.performance.now();
+    }
+
+    measure() {
+        return window.performance.now() - this._start;
+    }
+}
+
+export class DOMClock {
+    createMeasure() {
+        return new DOMTimeMeasure();
+    }
+
+    createTimeout(ms) {
+        return new DOMTimeout(ms);
+    }
+
+    now() {
+        return Date.now();
+    }
+}

src/utils/error.js

@@ -0,0 +1,2 @@
+export class AbortError extends Error {
+}