Mark readable stream closed promise as handled

third_party/WebKit/Source/core/streams/ReadableStream.js

 // Copyright 2015 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.
 
 (function(global, binding, v8) {
   'use strict';
 
   const _reader = v8.createPrivateSymbol('[[reader]]');
   const _storedError = v8.createPrivateSymbol('[[storedError]]');
   const _controller = v8.createPrivateSymbol('[[controller]]');
@@ skipping 488 matching lines @@
 
     if (IsReadableStreamDefaultReader(reader) === true) {
       const readRequests = reader[_readRequests];
       for (let i = 0; i < readRequests.length; i++) {
         v8.rejectPromise(readRequests[i], e);
       }
       reader[_readRequests] = new v8.InternalPackedArray();
     }
 
     v8.rejectPromise(reader[_closedPromise], e);
+    v8.markPromiseAsHandled(reader[_closedPromise]);
   }
 
   function ReadableStreamClose(stream) {
     ReadableStreamSetState(stream, STATE_CLOSED);
 
     const reader = stream[_reader];
     if (reader === undefined) {
       return undefined;
     }
 
@@ skipping 62 matching lines @@
 
     switch (ReadableStreamGetState(stream)) {
       case STATE_READABLE:
         reader[_closedPromise] = v8.createPromise();
         break;
       case STATE_CLOSED:
         reader[_closedPromise] = Promise_resolve(undefined);
         break;
       case STATE_ERRORED:
         reader[_closedPromise] = Promise_reject(stream[_storedError]);
-      break;
+        v8.markPromiseAsHandled(reader[_closedPromise]);
+        break;
     }
   }
 
   function ReadableStreamReaderGenericRelease(reader) {
     // TODO(yhirano): Remove this when we don't need hasPendingActivity in
     // blink::UnderlyingSourceBase.
     const controller = reader[_ownerReadableStream][_controller];
     if (controller[_readableStreamDefaultControllerBits] & EXTERNALLY_CONTROLLED) {
       // The stream is created with an external controller (i.e. made in
       // Blink).
       const underlyingSource = controller[_underlyingSource];
       callFunction(underlyingSource.notifyLockReleased, underlyingSource);
     }
 
     if (ReadableStreamGetState(reader[_ownerReadableStream]) === STATE_READABLE) {
       v8.rejectPromise(reader[_closedPromise], new TypeError(errReleasedReaderClosedPromise));
     } else {
       reader[_closedPromise] = Promise_reject(new TypeError(errReleasedReaderClosedPromise));
     }
+    v8.markPromiseAsHandled(reader[_closedPromise]);
 
     reader[_ownerReadableStream][_reader] = undefined;
     reader[_ownerReadableStream] = undefined;
   }
 
   function ReadableStreamDefaultReaderRead(reader) {
     const stream = reader[_ownerReadableStream];
     stream[_readableStreamBits] |= DISTURBED;
 
     if (ReadableStreamGetState(stream) === STATE_CLOSED) {
@@ skipping 281 matching lines @@
   binding.ReadableStreamDefaultControllerGetDesiredSize = ReadableStreamDefaultControllerGetDesiredSize;
   binding.ReadableStreamDefaultControllerEnqueue = ReadableStreamDefaultControllerEnqueue;
   binding.ReadableStreamDefaultControllerError = ReadableStreamDefaultControllerError;
 
   binding.createReadableStreamWithExternalController =
       (underlyingSource, strategy) => {
         return new ReadableStream(
             underlyingSource, strategy, createWithExternalControllerSentinel);
       };
 });