[pull] master from xtermjs:master

src/browser/TimeBasedDebouncer.ts

@@ -45,7 +45,7 @@ export class TimeBasedDebouncer implements IRenderDebouncer {
 
     // Only refresh if the time since last refresh is above a threshold, otherwise wait for
     // enough time to pass before refreshing again.
-    const refreshRequestTime: number = Date.now();
+    const refreshRequestTime: number = performance.now();
     if (refreshRequestTime - this._lastRefreshMs >= this._debounceThresholdMS) {
       // Enough time has lapsed since the last refresh; refresh immediately
       this._lastRefreshMs = refreshRequestTime;
@@ -57,7 +57,7 @@ export class TimeBasedDebouncer implements IRenderDebouncer {
       this._additionalRefreshRequested = true;
 
       this._refreshTimeoutID = window.setTimeout(() => {
-        this._lastRefreshMs = Date.now();
+        this._lastRefreshMs = performance.now();
         this._innerRefresh();
         this._additionalRefreshRequested = false;
         this._refreshTimeoutID = undefined; // No longer need to clear the timeout

src/common/TaskQueue.ts

@@ -74,14 +74,14 @@ abstract class TaskQueue implements ITaskQueue {
     let lastDeadlineRemaining = deadline.timeRemaining();
     let deadlineRemaining = 0;
     while (this._i < this._tasks.length) {
-      taskDuration = Date.now();
+      taskDuration = performance.now();
       if (!this._tasks[this._i]()) {
         this._i++;
       }
-      // other than performance.now, Date.now might not be stable (changes on wall clock changes),
-      // this is not an issue here as a clock change during a short running task is very unlikely
-      // in case it still happened and leads to negative duration, simply assume 1 msec
-      taskDuration = Math.max(1, Date.now() - taskDuration);
+      // other than performance.now, performance.now might not be stable (changes on wall clock
+      // changes), this is not an issue here as a clock change during a short running task is very
+      // unlikely in case it still happened and leads to negative duration, simply assume 1 msec
+      taskDuration = Math.max(1, performance.now() - taskDuration);
       longestTask = Math.max(taskDuration, longestTask);
       // Guess the following task will take a similar time to the longest task in this batch, allow
       // additional room to try avoid exceeding the deadline
@@ -116,9 +116,9 @@ export class PriorityTaskQueue extends TaskQueue {
   }
 
   private _createDeadline(duration: number): ITaskDeadline {
-    const end = Date.now() + duration;
+    const end = performance.now() + duration;
     return {
-      timeRemaining: () => Math.max(0, end - Date.now())
+      timeRemaining: () => Math.max(0, end - performance.now())
     };
   }
 }

src/common/input/WriteBuffer.ts

@@ -137,7 +137,7 @@ export class WriteBuffer extends Disposable {
    * effectively lowering the redrawing needs, schematically:
    *
    *   macroTask _innerWrite:
-   *     if (Date.now() - (lastTime | 0) < WRITE_TIMEOUT_MS):
+   *     if (performance.now() - (lastTime | 0) < WRITE_TIMEOUT_MS):
    *        schedule microTask _innerWrite(lastTime)
    *     else:
    *        schedule macroTask _innerWrite(0)
@@ -158,7 +158,7 @@ export class WriteBuffer extends Disposable {
    * Note, for pure sync code `lastTime` and `promiseResult` have no meaning.
    */
   protected _innerWrite(lastTime: number = 0, promiseResult: boolean = true): void {
-    const startTime = lastTime || Date.now();
+    const startTime = lastTime || performance.now();
     while (this._writeBuffer.length > this._bufferOffset) {
       const data = this._writeBuffer[this._bufferOffset];
       const result = this._action(data, promiseResult);
@@ -186,7 +186,7 @@ export class WriteBuffer extends Disposable {
          * responsibility to slice hard work), but we can at least schedule a screen update as we
          * gain control.
          */
-        const continuation: (r: boolean) => void = (r: boolean) => Date.now() - startTime >= WRITE_TIMEOUT_MS
+        const continuation: (r: boolean) => void = (r: boolean) => performance.now() - startTime >= WRITE_TIMEOUT_MS
           ? setTimeout(() => this._innerWrite(0, r))
           : this._innerWrite(startTime, r);
 
@@ -202,7 +202,8 @@ export class WriteBuffer extends Disposable {
          * throughput by eval'ing `startTime` upfront pulling at least one more chunk into the
          * current microtask queue (executed before setTimeout).
          */
-        // const continuation: (r: boolean) => void = Date.now() - startTime >= WRITE_TIMEOUT_MS
+        // const continuation: (r: boolean) => void = performance.now() - startTime >=
+        //     WRITE_TIMEOUT_MS
         //   ? r => setTimeout(() => this._innerWrite(0, r))
         //   : r => this._innerWrite(startTime, r);
 
@@ -222,7 +223,7 @@ export class WriteBuffer extends Disposable {
       this._bufferOffset++;
       this._pendingData -= data.length;
 
-      if (Date.now() - startTime >= WRITE_TIMEOUT_MS) {
+      if (performance.now() - startTime >= WRITE_TIMEOUT_MS) {
         break;
       }
     }