// https://source.chromium.org/chromium/chromium/src/+/main:third_party/blink/renderer/core/fetch/readable_stream_bytes_consumer.cc;l=27
class ReadableStreamBytesConsumer::BytesConsumerReadRequest final
    : public ReadRequest {
 public:
  explicit BytesConsumerReadRequest(ReadableStreamBytesConsumer* consumer)
      : consumer_(consumer) {}

  void ChunkSteps(ScriptState* script_state,
                  v8::Local<v8::Value> chunk,
                  ExceptionState& exception_state) const override {
    if (!chunk->IsUint8Array()) {                                                   // [!] SAB-backed Uint8Array allowed
      consumer_->OnRejected();
      return;
    }
    ScriptState::Scope scope(script_state);
    consumer_->OnRead(
        NativeValueTraits<MaybeShared<DOMUint8Array>>::NativeValue(
            script_state->GetIsolate(), chunk, exception_state)
            .Get());
    DCHECK(!exception_state.HadException());
  }
  // ...
}

// https://source.chromium.org/chromium/chromium/src/+/main:third_party/blink/renderer/core/fetch/readable_stream_bytes_consumer.cc;drc=7df382b48e30a3d6193403397c5efe24e4341cd9;l=179
void ReadableStreamBytesConsumer::OnRead(DOMUint8Array* buffer) {
  // ...
  is_reading_ = false;
  if (state_ == PublicState::kClosed)
    return;
  DCHECK_EQ(state_, PublicState::kReadableOrWaiting);
  pending_buffer_ = buffer;                                                         // [!] buffer directly stored as pending_buffer_
  if (client_)
    client_->OnStateChange();
}

// https://source.chromium.org/chromium/chromium/src/+/main:third_party/blink/renderer/core/fetch/readable_stream_bytes_consumer.cc;drc=7df382b48e30a3d6193403397c5efe24e4341cd9;l=79
BytesConsumer::Result ReadableStreamBytesConsumer::BeginRead(
    base::span<const char>& buffer) {
  buffer = {};
  if (state_ == PublicState::kErrored)
    return Result::kError;
  if (state_ == PublicState::kClosed)
    return Result::kDone;

  if (pending_buffer_) {
    // The UInt8Array has become detached due to, for example, the site
    // transferring it away via postMessage().  Since we were in the middle
    // of reading the array we must error out.
    if (pending_buffer_->IsDetached()) {
      SetErrored();
      return Result::kError;
    }

    DCHECK_LE(pending_offset_, pending_buffer_->length());
    buffer =
        base::as_chars(pending_buffer_->ByteSpan().subspan(pending_offset_));       // [!] slice taken directly from pending_buffer_
    return Result::kOk;
  }
  if (!is_reading_) {
    // ...
  }
  return Result::kShouldWait;
}

// https://source.chromium.org/chromium/chromium/src/+/main:third_party/blink/renderer/bindings/core/v8/v8_wasm_response_extensions.cc;drc=26eb194ec1259c0436ac792393ea7bca97df8f7f;l=196
  void OnStateChange() override {
    TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"),
                 "v8.wasm.compileConsume");
    // Continue reading until we either finished, aborted, or no data is
    // available any more (handled below).
    while (streaming_) {
      // |buffer| is owned by |consumer_|.
      base::span<const char> buffer;
      BytesConsumer::Result result = consumer_->BeginRead(buffer);                  // [!] acquires racy buffer

      if (result == BytesConsumer::Result::kShouldWait)
        return;
      if (result == BytesConsumer::Result::kOk) {
        // Ignore more bytes after an abort (streaming == nullptr).
        if (!buffer.empty()) {
          // ...
          streaming_->OnBytesReceived(bytes.data(), bytes.size());                  // [!] supplies it down to AsyncStreamingDecoder
        }
        result = consumer_->EndRead(buffer.size());
      }
      // ...
    }
    // ...
  }

// https://source.chromium.org/chromium/chromium/src/+/main:v8/src/wasm/streaming-decoder.cc;drc=10cf92abc256d6f918accc819b3468a04724a287;l=232
void AsyncStreamingDecoder::OnBytesReceived(base::Vector<const uint8_t> bytes) {
  DCHECK(!full_wire_bytes_.empty());
  // Fill the previous vector, growing up to 16kB. After that, allocate new
  // vectors on overflow.
  size_t remaining_capacity =
      std::max(full_wire_bytes_.back().capacity(), size_t{16} * KB) -
      full_wire_bytes_.back().size();
  size_t bytes_for_existing_vector = std::min(remaining_capacity, bytes.size());
  full_wire_bytes_.back().insert(full_wire_bytes_.back().end(), bytes.data(),      // [!] (Read #1) fills up full_wire_bytes_ from bytes (read #1), later concatenated into ModuleWireBytes
                                 bytes.data() + bytes_for_existing_vector);
  if (bytes.size() > bytes_for_existing_vector) {
    // ... copy remaining buffer
  }
  // ...
  size_t current = 0;
  while (ok() && current < bytes.size()) {
    size_t num_bytes =
        state_->ReadBytes(this, bytes.SubVector(current, bytes.size()));           // [!] (Read #2) fills up DecodingState -> SectionBuffer when reading sections
    current += num_bytes;
    module_offset_ += num_bytes;
    if (state_->offset() == state_->buffer().size()) {
      state_ = state_->Next(this);
    }
  }
  if (ok()) {
    processor_->OnFinishedChunk();
  }
}