[Streams] UnderlyingSourceBase should be kept alive only when locked

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 readableStreamController = v8.createPrivateSymbol('[[controller]]');
   const readableStreamQueue = v8.createPrivateSymbol('[[queue]]');
   const readableStreamQueueSize =
@@ skipping 258 matching lines @@
 
   class ReadableStreamReader {
     constructor(stream) {
       if (IsReadableStream(stream) === false) {
         throw new TypeError(errReaderConstructorBadArgument);
       }
       if (IsReadableStreamLocked(stream) === true) {
         throw new TypeError(errReaderConstructorStreamAlreadyLocked);
       }
 
+      // TODO(yhirano): Remove this when we don't need hasPendingActivity in
+      // blink::UnderlyingSourceBase.
+      if (stream[readableStreamController] === null) {
+        // The stream is created with an external controller (i.e. made in
+        // Blink).
+        CallOrNoop(

[domenic, 2016/04/20 20:38:04]

Should be `const underlyingSource = stream[readableStreamUnderlyingSource];
callFunction(underlyingSource.notifyLockAcquired, underlyingSource)`. No need
for the extra checks/fallback CallOrNoop does. (Same below.)

[yhirano, 2016/04/21 01:50:50]

Done.

+            stream[readableStreamUnderlyingSource],
+            'notifyLockAcquired',
+            'underlyingSource.notifyLockAcquired');
+      }
+
       this[readableStreamReaderOwnerReadableStream] = stream;
       stream[readableStreamReader] = this;
 
       this[readableStreamReaderReadRequests] = new v8.InternalPackedArray();
 
       switch (stream[readableStreamState]) {
         case STATE_READABLE:
           this[readableStreamReaderClosedPromise] = v8.createPromise();
           break;
         case STATE_CLOSED:
@@ skipping 46 matching lines @@
 
       const stream = this[readableStreamReaderOwnerReadableStream];
       if (stream === undefined) {
         return undefined;
       }
 
       if (this[readableStreamReaderReadRequests].length > 0) {
         throw new TypeError(errReleaseReaderWithPendingRead);
       }
 
+      // TODO(yhirano): Remove this when we don't need hasPendingActivity in
+      // blink::UnderlyingSourceBase.
+      if (stream[readableStreamController] === null) {
+        // The stream is created with an external controller (i.e. made in
+        // Blink).
+        CallOrNoop(
+            stream[readableStreamUnderlyingSource],
+            'notifyLockReleased',
+            'underlyingSource.notifyLockReleased');
+      }
+
       if (stream[readableStreamState] === STATE_READABLE) {
         v8.rejectPromise(this[readableStreamReaderClosedPromise],
             new TypeError(errReleasedReaderClosedPromise));
       } else {
         this[readableStreamReaderClosedPromise] =
             Promise_reject(new TypeError(errReleasedReaderClosedPromise));
       }
 
       this[readableStreamReaderOwnerReadableStream][readableStreamReader] =
           undefined;
@@ skipping 457 matching lines @@
   binding.GetReadableStreamDesiredSize = GetReadableStreamDesiredSize;
   binding.EnqueueInReadableStream = EnqueueInReadableStream;
   binding.ErrorReadableStream = ErrorReadableStream;
 
   binding.createReadableStreamWithExternalController =
       (underlyingSource, strategy) => {
         return new ReadableStream(
             underlyingSource, strategy, createWithExternalControllerSentinel);
       };
 });