Add methods for creating V8 extras-based ReadableStreams from C++

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 =
       v8.createPrivateSymbol('[[queue]] total size');
   const readableStreamReader = v8.createPrivateSymbol('[[reader]]');
   const readableStreamState = v8.createPrivateSymbol('[[state]]');
   const readableStreamStoredError = v8.createPrivateSymbol('[[storedError]]');
   const readableStreamStrategySize = v8.createPrivateSymbol('[[strategySize]]');
   const readableStreamStrategyHWM = v8.createPrivateSymbol('[[strategyHWM]]');
   const readableStreamUnderlyingSource =
       v8.createPrivateSymbol('[[underlyingSource]]');
 
   const readableStreamControllerControlledReadableStream =
       v8.createPrivateSymbol('[[controlledReadableStream]]');
 
   const readableStreamReaderClosedPromise =
       v8.createPrivateSymbol('[[closedPromise]]');
   const readableStreamReaderOwnerReadableStream =
       v8.createPrivateSymbol('[[ownerReadableStream]]');
   const readableStreamReaderReadRequests =
       v8.createPrivateSymbol('[[readRequests]]');
 
+  const createWithExternalControllerSentinel =
+      v8.createPrivateSymbol('flag for UA-created ReadableStream to pass');
+
   const STATE_READABLE = 0;
   const STATE_CLOSED = 1;
   const STATE_ERRORED = 2;
 
   const readableStreamBits = v8.createPrivateSymbol(
       'bit field for [[started]], [[closeRequested]], [[pulling]], [[pullAgain]], [[disturbed]]');
   const STARTED = 0b1;
   const CLOSE_REQUESTED = 0b10;
   const PULLING = 0b100;
   const PULL_AGAIN = 0b1000;
@@ skipping 72 matching lines @@
       this[readableStreamQueueSize] = 0;
 
       this[readableStreamState] = STATE_READABLE;
       this[readableStreamBits] = 0b0;
       this[readableStreamReader] = undefined;
       this[readableStreamStoredError] = undefined;
 
       this[readableStreamStrategySize] = normalizedStrategy.size;
       this[readableStreamStrategyHWM] = normalizedStrategy.highWaterMark;
 
-      const controller = new ReadableStreamController(this);
+      // Avoid allocating the controller if the stream is going to be controlled
+      // externally (i.e. from C++) anyway. All calls to underlyingSource
+      // methods will disregard their controller argument in such situations
+      // (but see below).
+
+      const isControlledExternally =
+          arguments[2] === createWithExternalControllerSentinel;
+      const controller =
+          isControlledExternally ? null : new ReadableStreamController(this);
       this[readableStreamController] = controller;
 
+      // We need to pass ourself to the underlyingSource start method for
+      // externally-controlled streams. We use the now-useless controller
+      // argument to do so.
+      const argToStart = isControlledExternally ? this : controller;
+
       const startResult = CallOrNoop(
-          underlyingSource, 'start', controller, 'underlyingSource.start');
+          underlyingSource, 'start', argToStart, 'underlyingSource.start');
       thenPromise(Promise_resolve(startResult),
           () => {
             this[readableStreamBits] |= STARTED;
             RequestReadableStreamPull(this);
           },
           r => {
             if (this[readableStreamState] === STATE_READABLE) {
               return ErrorReadableStream(this, r);
             }
           });
@@ skipping 186 matching lines @@
       }
 
       if (this[readableStreamReaderReadRequests].length > 0) {
         throw new TypeError(errReleaseReaderWithPendingRead);
       }
 
       if (stream[readableStreamState] === STATE_READABLE) {
         v8.rejectPromise(this[readableStreamReaderClosedPromise],
             new TypeError(errReleasedReaderClosedPromise));
       } else {
-        this[readableStreamReaderClosedPromise] = Promise_reject(new TypeError(
-            errReleasedReaderClosedPromise));
+        this[readableStreamReaderClosedPromise] =
+            Promise_reject(new TypeError(errReleasedReaderClosedPromise));
       }
 
       this[readableStreamReaderOwnerReadableStream][readableStreamReader] =
           undefined;
       this[readableStreamReaderOwnerReadableStream] = undefined;
     }
   }
 
   //
   // Readable stream abstract operations
@@ skipping 419 matching lines @@
   //
   // Exports to Blink
   //
 
   binding.AcquireReadableStreamReader = AcquireReadableStreamReader;
   binding.IsReadableStream = IsReadableStream;
   binding.IsReadableStreamDisturbed = IsReadableStreamDisturbed;
   binding.IsReadableStreamLocked = IsReadableStreamLocked;
   binding.IsReadableStreamReader = IsReadableStreamReader;
   binding.ReadFromReadableStreamReader = ReadFromReadableStreamReader;
+
+  binding.CloseReadableStream = CloseReadableStream;
+  binding.GetReadableStreamDesiredSize = GetReadableStreamDesiredSize;
+  binding.EnqueueInReadableStream = EnqueueInReadableStream;
+  binding.ErrorReadableStream = ErrorReadableStream;
+
+  binding.createReadableStreamWithExternalController =
+      (underlyingSource, strategy) => {
+        return new ReadableStream(
+            underlyingSource, strategy, createWithExternalControllerSentinel);
+      };
 });