diff options
Diffstat (limited to 'chromium/third_party/blink/renderer/platform/loader/fetch')
61 files changed, 965 insertions, 237 deletions
diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/OWNERS b/chromium/third_party/blink/renderer/platform/loader/fetch/OWNERS new file mode 100644 index 00000000000..a3060033221 --- /dev/null +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/OWNERS @@ -0,0 +1,5 @@ +per-file *_mojom_traits*.*=set noparent +per-file *_mojom_traits*.*=file://ipc/SECURITY_OWNERS +per-file *.typemap=set noparent +per-file *.typemap=file://ipc/SECURITY_OWNERS + diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/buffering_bytes_consumer.cc b/chromium/third_party/blink/renderer/platform/loader/fetch/buffering_bytes_consumer.cc index e8411eddd6c..b33a8bc2cf0 100644 --- a/chromium/third_party/blink/renderer/platform/loader/fetch/buffering_bytes_consumer.cc +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/buffering_bytes_consumer.cc @@ -162,7 +162,7 @@ BytesConsumer::Error BufferingBytesConsumer::GetError() const { return bytes_consumer_->GetError(); } -void BufferingBytesConsumer::Trace(Visitor* visitor) { +void BufferingBytesConsumer::Trace(Visitor* visitor) const { visitor->Trace(bytes_consumer_); visitor->Trace(client_); BytesConsumer::Trace(visitor); diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/buffering_bytes_consumer.h b/chromium/third_party/blink/renderer/platform/loader/fetch/buffering_bytes_consumer.h index 49155275231..78e916784b1 100644 --- a/chromium/third_party/blink/renderer/platform/loader/fetch/buffering_bytes_consumer.h +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/buffering_bytes_consumer.h @@ -79,7 +79,7 @@ class PLATFORM_EXPORT BufferingBytesConsumer final Error GetError() const override; String DebugName() const override { return "BufferingBytesConsumer"; } - void Trace(Visitor*) override; + void Trace(Visitor*) const override; private: void OnTimerFired(TimerBase*); diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/bytes_consumer.cc b/chromium/third_party/blink/renderer/platform/loader/fetch/bytes_consumer.cc index 1351b8de938..eb8d2dbe8d7 100644 --- a/chromium/third_party/blink/renderer/platform/loader/fetch/bytes_consumer.cc +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/bytes_consumer.cc @@ -66,4 +66,32 @@ BytesConsumer* BytesConsumer::CreateClosed() { return MakeGarbageCollected<ClosedBytesConsumer>(); } +std::ostream& operator<<(std::ostream& out, + const BytesConsumer::PublicState& state) { + switch (state) { + case BytesConsumer::PublicState::kReadableOrWaiting: + return out << "kReadableOrWaiting"; + case BytesConsumer::PublicState::kClosed: + return out << "kClosed"; + case BytesConsumer::PublicState::kErrored: + return out << "kErrored"; + } + NOTREACHED(); +} + +std::ostream& operator<<(std::ostream& out, + const BytesConsumer::Result& result) { + switch (result) { + case BytesConsumer::Result::kOk: + return out << "kOk"; + case BytesConsumer::Result::kShouldWait: + return out << "kShouldWait"; + case BytesConsumer::Result::kDone: + return out << "kDone"; + case BytesConsumer::Result::kError: + return out << "kError"; + } + NOTREACHED(); +} + } // namespace blink diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/bytes_consumer.h b/chromium/third_party/blink/renderer/platform/loader/fetch/bytes_consumer.h index 5ec8bba5dd9..8b348381da8 100644 --- a/chromium/third_party/blink/renderer/platform/loader/fetch/bytes_consumer.h +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/bytes_consumer.h @@ -5,6 +5,8 @@ #ifndef THIRD_PARTY_BLINK_RENDERER_PLATFORM_LOADER_FETCH_BYTES_CONSUMER_H_ #define THIRD_PARTY_BLINK_RENDERER_PLATFORM_LOADER_FETCH_BYTES_CONSUMER_H_ +#include <ostream> + #include "base/memory/scoped_refptr.h" #include "third_party/blink/renderer/platform/blob/blob_data.h" #include "third_party/blink/renderer/platform/heap/handle.h" @@ -177,7 +179,7 @@ class PLATFORM_EXPORT BytesConsumer : public GarbageCollected<BytesConsumer> { // Returns a BytesConsumer whose state is Errored. static BytesConsumer* CreateErrored(const Error&); - virtual void Trace(Visitor* visitor) {} + virtual void Trace(Visitor* visitor) const {} protected: // This InternalState directly corresponds to the states in the class @@ -204,6 +206,12 @@ class PLATFORM_EXPORT BytesConsumer : public GarbageCollected<BytesConsumer> { } }; +PLATFORM_EXPORT std::ostream& operator<<( + std::ostream& out, + const BytesConsumer::PublicState& state); +PLATFORM_EXPORT std::ostream& operator<<(std::ostream& out, + const BytesConsumer::Result& result); + } // namespace blink #endif // THIRD_PARTY_BLINK_RENDERER_PLATFORM_LOADER_FETCH_BYTES_CONSUMER_H_ diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/cached_metadata_handler.h b/chromium/third_party/blink/renderer/platform/loader/fetch/cached_metadata_handler.h index c0a819c63b0..00d990487d2 100644 --- a/chromium/third_party/blink/renderer/platform/loader/fetch/cached_metadata_handler.h +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/cached_metadata_handler.h @@ -71,7 +71,7 @@ class CachedMetadataHandler : public GarbageCollected<CachedMetadataHandler> { }; virtual ~CachedMetadataHandler() = default; - virtual void Trace(Visitor* visitor) {} + virtual void Trace(Visitor* visitor) const {} // Reset existing metadata. Subclasses can ignore setting new metadata after // clearing with |kDiscardLocally| to save memory. diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/console_logger.h b/chromium/third_party/blink/renderer/platform/loader/fetch/console_logger.h index dc811ba901e..163b03c090f 100644 --- a/chromium/third_party/blink/renderer/platform/loader/fetch/console_logger.h +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/console_logger.h @@ -51,7 +51,7 @@ class PLATFORM_EXPORT DetachableConsoleLogger final // be no-op. void Detach() { logger_ = nullptr; } - void Trace(Visitor* visitor) override { + void Trace(Visitor* visitor) const override { visitor->Trace(logger_); ConsoleLogger::Trace(visitor); } diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/data_pipe_bytes_consumer.cc b/chromium/third_party/blink/renderer/platform/loader/fetch/data_pipe_bytes_consumer.cc index c36b32b18fc..4a825ae4c58 100644 --- a/chromium/third_party/blink/renderer/platform/loader/fetch/data_pipe_bytes_consumer.cc +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/data_pipe_bytes_consumer.cc @@ -20,13 +20,18 @@ void DataPipeBytesConsumer::CompletionNotifier::SignalComplete() { bytes_consumer_->SignalComplete(); } +void DataPipeBytesConsumer::CompletionNotifier::SignalSize(uint64_t size) { + if (bytes_consumer_) + bytes_consumer_->SignalSize(size); +} + void DataPipeBytesConsumer::CompletionNotifier::SignalError( const BytesConsumer::Error& error) { if (bytes_consumer_) bytes_consumer_->SignalError(error); } -void DataPipeBytesConsumer::CompletionNotifier::Trace(Visitor* visitor) { +void DataPipeBytesConsumer::CompletionNotifier::Trace(Visitor* visitor) const { visitor->Trace(bytes_consumer_); } @@ -79,6 +84,10 @@ BytesConsumer::Result DataPipeBytesConsumer::BeginRead(const char** buffer, return Result::kShouldWait; case MOJO_RESULT_FAILED_PRECONDITION: ClearDataPipe(); + if (total_size_ && num_read_bytes_ < *total_size_) { + SetError(Error("error")); + return Result::kError; + } MaybeClose(); // We hit the end of the pipe, but we may still need to wait for // SignalComplete() or SignalError() to be called. @@ -102,6 +111,7 @@ BytesConsumer::Result DataPipeBytesConsumer::EndRead(size_t read) { SetError(Error("error")); return Result::kError; } + num_read_bytes_ += read; if (has_pending_complete_) { has_pending_complete_ = false; SignalComplete(); @@ -112,6 +122,13 @@ BytesConsumer::Result DataPipeBytesConsumer::EndRead(size_t read) { SignalError(Error("error")); return Result::kError; } + if (total_size_ == num_read_bytes_) { + ClearDataPipe(); + ClearClient(); + SignalComplete(); + return Result::kDone; + } + if (has_pending_notification_) { has_pending_notification_ = false; task_runner_->PostTask(FROM_HERE, @@ -153,7 +170,7 @@ BytesConsumer::PublicState DataPipeBytesConsumer::GetPublicState() const { return GetPublicStateFromInternalState(state_); } -void DataPipeBytesConsumer::Trace(Visitor* visitor) { +void DataPipeBytesConsumer::Trace(Visitor* visitor) const { visitor->Trace(client_); BytesConsumer::Trace(visitor); } @@ -193,6 +210,22 @@ void DataPipeBytesConsumer::SignalComplete() { watcher_.ArmOrNotify(); } +void DataPipeBytesConsumer::SignalSize(uint64_t size) { + if (!IsReadableOrWaiting() || has_pending_complete_ || has_pending_error_) + return; + total_size_ = base::make_optional(size); + DCHECK_LE(num_read_bytes_, *total_size_); + if (!data_pipe_.is_valid() && num_read_bytes_ < *total_size_) { + SignalError(Error()); + return; + } + + if (!is_in_two_phase_read_ && *total_size_ == num_read_bytes_) { + ClearDataPipe(); + SignalComplete(); + } +} + void DataPipeBytesConsumer::SignalError(const Error& error) { if (!IsReadableOrWaiting() || has_pending_complete_ || has_pending_error_) return; diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/data_pipe_bytes_consumer.h b/chromium/third_party/blink/renderer/platform/loader/fetch/data_pipe_bytes_consumer.h index 9bfc9775f21..7af43dd2b1a 100644 --- a/chromium/third_party/blink/renderer/platform/loader/fetch/data_pipe_bytes_consumer.h +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/data_pipe_bytes_consumer.h @@ -35,12 +35,14 @@ class PLATFORM_EXPORT DataPipeBytesConsumer final : public BytesConsumer { : bytes_consumer_(bytes_consumer) {} // One of these methods must be called to signal the end of the data - // stream. We cannot assume that the end of the pipe completes the - // stream successfully since errors can occur after the last byte is - // written into the pipe. + // stream. (SignalSize notifies the total size. That information can + // be used to detect the end-of-stream). We cannot assume that the end + // of the pipe completes the stream successfully since errors can + // occur after the last byte is written into the pipe. void SignalComplete(); + void SignalSize(uint64_t size); void SignalError(const BytesConsumer::Error& error); - void Trace(Visitor*); + void Trace(Visitor*) const; private: const WeakMember<DataPipeBytesConsumer> bytes_consumer_; @@ -65,7 +67,7 @@ class PLATFORM_EXPORT DataPipeBytesConsumer final : public BytesConsumer { } String DebugName() const override { return "DataPipeBytesConsumer"; } - void Trace(Visitor*) override; + void Trace(Visitor*) const override; private: bool IsReadableOrWaiting() const; @@ -74,6 +76,7 @@ class PLATFORM_EXPORT DataPipeBytesConsumer final : public BytesConsumer { void Notify(MojoResult); void ClearDataPipe(); void SignalComplete(); + void SignalSize(uint64_t); void SignalError(const Error& error); void Dispose(); @@ -83,6 +86,8 @@ class PLATFORM_EXPORT DataPipeBytesConsumer final : public BytesConsumer { Member<BytesConsumer::Client> client_; InternalState state_ = InternalState::kWaiting; Error error_; + uint64_t num_read_bytes_ = 0; + base::Optional<uint64_t> total_size_; bool is_in_two_phase_read_ = false; bool has_pending_notification_ = false; bool has_pending_complete_ = false; diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/data_pipe_bytes_consumer_test.cc b/chromium/third_party/blink/renderer/platform/loader/fetch/data_pipe_bytes_consumer_test.cc index 21bd571a15c..ec03ab4e89b 100644 --- a/chromium/third_party/blink/renderer/platform/loader/fetch/data_pipe_bytes_consumer_test.cc +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/data_pipe_bytes_consumer_test.cc @@ -165,6 +165,140 @@ TEST_F(DataPipeBytesConsumerTest, EndOfPipeBeforeError) { EXPECT_EQ(Result::kError, rv); } +TEST_F(DataPipeBytesConsumerTest, SignalSizeBeforeRead) { + mojo::ScopedDataPipeConsumerHandle readable; + mojo::ScopedDataPipeProducerHandle writable; + const MojoCreateDataPipeOptions options{ + sizeof(MojoCreateDataPipeOptions), MOJO_CREATE_DATA_PIPE_FLAG_NONE, 1, 0}; + ASSERT_EQ(MOJO_RESULT_OK, + mojo::CreateDataPipe(&options, &writable, &readable)); + DataPipeBytesConsumer::CompletionNotifier* notifier = nullptr; + DataPipeBytesConsumer* consumer = MakeGarbageCollected<DataPipeBytesConsumer>( + task_runner_, std::move(readable), ¬ifier); + + constexpr char kData[] = "hello"; + uint32_t write_size = 5; + MojoResult write_result = + writable->WriteData(kData, &write_size, MOJO_WRITE_DATA_FLAG_NONE); + ASSERT_EQ(MOJO_RESULT_OK, write_result); + ASSERT_EQ(5u, write_size); + + EXPECT_EQ(PublicState::kReadableOrWaiting, consumer->GetPublicState()); + + const char* buffer = nullptr; + size_t available = 0; + + notifier->SignalSize(5); + + Result rv = consumer->BeginRead(&buffer, &available); + ASSERT_EQ(Result::kOk, rv); + EXPECT_EQ(available, 5u); + + rv = consumer->EndRead(2); + ASSERT_EQ(Result::kOk, rv); + + rv = consumer->BeginRead(&buffer, &available); + ASSERT_EQ(Result::kOk, rv); + EXPECT_EQ(available, 3u); + + EXPECT_EQ(PublicState::kReadableOrWaiting, consumer->GetPublicState()); + rv = consumer->EndRead(3); + ASSERT_EQ(Result::kDone, rv); + EXPECT_EQ(PublicState::kClosed, consumer->GetPublicState()); +} + +TEST_F(DataPipeBytesConsumerTest, SignalExcessSizeBeforeEndOfData) { + mojo::ScopedDataPipeConsumerHandle readable; + mojo::ScopedDataPipeProducerHandle writable; + const MojoCreateDataPipeOptions options{ + sizeof(MojoCreateDataPipeOptions), MOJO_CREATE_DATA_PIPE_FLAG_NONE, 1, 0}; + ASSERT_EQ(MOJO_RESULT_OK, + mojo::CreateDataPipe(&options, &writable, &readable)); + DataPipeBytesConsumer::CompletionNotifier* notifier = nullptr; + DataPipeBytesConsumer* consumer = MakeGarbageCollected<DataPipeBytesConsumer>( + task_runner_, std::move(readable), ¬ifier); + + EXPECT_EQ(PublicState::kReadableOrWaiting, consumer->GetPublicState()); + + notifier->SignalSize(1); + + const char* buffer = nullptr; + size_t available = 0; + Result rv = consumer->BeginRead(&buffer, &available); + ASSERT_EQ(Result::kShouldWait, rv); + + writable.reset(); + + rv = consumer->BeginRead(&buffer, &available); + ASSERT_EQ(Result::kError, rv); + + EXPECT_EQ(PublicState::kErrored, consumer->GetPublicState()); +} + +TEST_F(DataPipeBytesConsumerTest, SignalExcessSizeAfterEndOfData) { + mojo::ScopedDataPipeConsumerHandle readable; + mojo::ScopedDataPipeProducerHandle writable; + const MojoCreateDataPipeOptions options{ + sizeof(MojoCreateDataPipeOptions), MOJO_CREATE_DATA_PIPE_FLAG_NONE, 1, 0}; + ASSERT_EQ(MOJO_RESULT_OK, + mojo::CreateDataPipe(&options, &writable, &readable)); + DataPipeBytesConsumer::CompletionNotifier* notifier = nullptr; + DataPipeBytesConsumer* consumer = MakeGarbageCollected<DataPipeBytesConsumer>( + task_runner_, std::move(readable), ¬ifier); + + EXPECT_EQ(PublicState::kReadableOrWaiting, consumer->GetPublicState()); + + writable.reset(); + + const char* buffer = nullptr; + size_t available = 0; + Result rv = consumer->BeginRead(&buffer, &available); + ASSERT_EQ(Result::kShouldWait, rv); + + notifier->SignalSize(1); + + rv = consumer->BeginRead(&buffer, &available); + ASSERT_EQ(Result::kError, rv); + + EXPECT_EQ(PublicState::kErrored, consumer->GetPublicState()); +} + +TEST_F(DataPipeBytesConsumerTest, SignalSizeAfterRead) { + mojo::ScopedDataPipeConsumerHandle readable; + mojo::ScopedDataPipeProducerHandle writable; + const MojoCreateDataPipeOptions options{ + sizeof(MojoCreateDataPipeOptions), MOJO_CREATE_DATA_PIPE_FLAG_NONE, 1, 0}; + ASSERT_EQ(MOJO_RESULT_OK, + mojo::CreateDataPipe(&options, &writable, &readable)); + + DataPipeBytesConsumer::CompletionNotifier* notifier = nullptr; + DataPipeBytesConsumer* consumer = MakeGarbageCollected<DataPipeBytesConsumer>( + task_runner_, std::move(readable), ¬ifier); + + constexpr char kData[] = "hello"; + uint32_t write_size = 5; + MojoResult write_result = + writable->WriteData(kData, &write_size, MOJO_WRITE_DATA_FLAG_NONE); + ASSERT_EQ(MOJO_RESULT_OK, write_result); + ASSERT_EQ(5u, write_size); + + EXPECT_EQ(PublicState::kReadableOrWaiting, consumer->GetPublicState()); + + const char* buffer = nullptr; + size_t available = 0; + + Result rv = consumer->BeginRead(&buffer, &available); + ASSERT_EQ(Result::kOk, rv); + EXPECT_EQ(available, 5u); + + rv = consumer->EndRead(5); + ASSERT_EQ(Result::kOk, rv); + + EXPECT_EQ(PublicState::kReadableOrWaiting, consumer->GetPublicState()); + notifier->SignalSize(5); + EXPECT_EQ(PublicState::kClosed, consumer->GetPublicState()); +} + TEST_F(DataPipeBytesConsumerTest, ErrorBeforeEndOfPipe) { mojo::DataPipe pipe; ASSERT_TRUE(pipe.producer_handle.is_valid()); diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/detachable_use_counter.h b/chromium/third_party/blink/renderer/platform/loader/fetch/detachable_use_counter.h index 353f792e369..89d6781f2f1 100644 --- a/chromium/third_party/blink/renderer/platform/loader/fetch/detachable_use_counter.h +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/detachable_use_counter.h @@ -31,7 +31,7 @@ class DetachableUseCounter final use_counter_->CountDeprecation(feature); } } - void Trace(Visitor* visitor) override { visitor->Trace(use_counter_); } + void Trace(Visitor* visitor) const override { visitor->Trace(use_counter_); } void Detach() { use_counter_ = nullptr; } diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/fetch_api_request_body.typemap b/chromium/third_party/blink/renderer/platform/loader/fetch/fetch_api_request_body.typemap new file mode 100644 index 00000000000..86c785a2151 --- /dev/null +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/fetch_api_request_body.typemap @@ -0,0 +1,10 @@ +# Copyright 2020 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. + +mojom = "//third_party/blink/public/mojom/fetch/fetch_api_request.mojom" +public_headers = + [ "//third_party/blink/renderer/platform/loader/fetch/resource_request.h" ] +traits_headers = [ "//third_party/blink/renderer/platform/loader/fetch/fetch_api_request_body_mojom_traits.h" ] + +type_mappings = [ "blink.mojom.FetchAPIRequestBody=::blink::ResourceRequestBody[nullable_is_same_type,move_only]" ] diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/fetch_api_request_body_mojom_traits.cc b/chromium/third_party/blink/renderer/platform/loader/fetch/fetch_api_request_body_mojom_traits.cc new file mode 100644 index 00000000000..eb6cdc34a34 --- /dev/null +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/fetch_api_request_body_mojom_traits.cc @@ -0,0 +1,179 @@ +// Copyright 2020 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. + +#include "third_party/blink/renderer/platform/loader/fetch/fetch_api_request_body_mojom_traits.h" + +#include "mojo/public/cpp/base/file_mojom_traits.h" +#include "mojo/public/cpp/base/file_path_mojom_traits.h" +#include "mojo/public/cpp/bindings/array_traits_wtf_vector.h" +#include "third_party/blink/public/mojom/fetch/fetch_api_request.mojom-blink.h" +#include "third_party/blink/public/platform/file_path_conversion.h" +#include "third_party/blink/renderer/platform/blob/blob_data.h" +#include "third_party/blink/renderer/platform/network/form_data_encoder.h" +#include "third_party/blink/renderer/platform/network/wrapped_data_pipe_getter.h" + +namespace mojo { + +// static +WTF::Vector<blink::mojom::blink::FetchAPIDataElementPtr> +StructTraits<blink::mojom::FetchAPIRequestBodyDataView, + blink::ResourceRequestBody>::elements(blink::ResourceRequestBody& + mutable_body) { + WTF::Vector<blink::mojom::blink::FetchAPIDataElementPtr> out_elements; + const auto& body = mutable_body; + if (body.IsEmpty()) { + return out_elements; + } + + if (mutable_body.StreamBody()) { + auto out = blink::mojom::blink::FetchAPIDataElement::New(); + out->type = network::mojom::DataElementType::kChunkedDataPipe; + out->chunked_data_pipe_getter = mutable_body.TakeStreamBody(); + out_elements.push_back(std::move(out)); + return out_elements; + } + + DCHECK(body.FormBody()); + for (const auto& element : body.FormBody()->elements_) { + auto out = blink::mojom::blink::FetchAPIDataElement::New(); + switch (element.type_) { + case blink::FormDataElement::kData: + out->type = network::mojom::DataElementType::kBytes; + out->buf.ReserveCapacity(element.data_.size()); + for (const char c : element.data_) { + out->buf.push_back(static_cast<uint8_t>(c)); + } + break; + case blink::FormDataElement::kEncodedFile: + out->type = network::mojom::DataElementType::kFile; + out->path = base::FilePath::FromUTF8Unsafe(element.filename_.Utf8()); + out->offset = element.file_start_; + out->length = element.file_length_; + out->expected_modification_time = + element.expected_file_modification_time_.value_or(base::Time()); + break; + case blink::FormDataElement::kEncodedBlob: + if (element.optional_blob_data_handle_) { + out->type = network::mojom::DataElementType::kDataPipe; + out->length = element.optional_blob_data_handle_->size(); + + mojo::Remote<blink::mojom::blink::Blob> blob_remote( + mojo::PendingRemote<blink::mojom::blink::Blob>( + element.optional_blob_data_handle_->CloneBlobRemote() + .PassPipe(), + blink::mojom::blink::Blob::Version_)); + mojo::PendingRemote<network::mojom::blink::DataPipeGetter> + data_pipe_getter_remote; + blob_remote->AsDataPipeGetter( + out->data_pipe_getter.InitWithNewPipeAndPassReceiver()); + } else { + out->type = network::mojom::DataElementType::kBlob; + out->blob_uuid = element.blob_uuid_; + } + break; + case blink::FormDataElement::kDataPipe: + out->type = network::mojom::DataElementType::kDataPipe; + if (element.data_pipe_getter_) { + element.data_pipe_getter_->GetDataPipeGetter()->Clone( + out->data_pipe_getter.InitWithNewPipeAndPassReceiver()); + } + break; + } + out_elements.push_back(std::move(out)); + } + return out_elements; +} + +// static +bool StructTraits<blink::mojom::FetchAPIRequestBodyDataView, + blink::ResourceRequestBody>:: + Read(blink::mojom::FetchAPIRequestBodyDataView in, + blink::ResourceRequestBody* out) { + if (in.is_null()) { + *out = blink::ResourceRequestBody(); + return true; + } + + mojo::ArrayDataView<blink::mojom::FetchAPIDataElementDataView> elements_view; + in.GetElementsDataView(&elements_view); + if (elements_view.size() == 1) { + blink::mojom::FetchAPIDataElementDataView view; + elements_view.GetDataView(0, &view); + + network::mojom::DataElementType type; + if (!view.ReadType(&type)) { + return false; + } + if (type == network::mojom::DataElementType::kChunkedDataPipe) { + auto chunked_data_pipe_getter = view.TakeChunkedDataPipeGetter< + mojo::PendingRemote<network::mojom::blink::ChunkedDataPipeGetter>>(); + *out = blink::ResourceRequestBody(std::move(chunked_data_pipe_getter)); + return true; + } + } + auto form_data = blink::EncodedFormData::Create(); + for (size_t i = 0; i < elements_view.size(); ++i) { + blink::mojom::FetchAPIDataElementDataView view; + elements_view.GetDataView(i, &view); + + network::mojom::DataElementType type; + if (!view.ReadType(&type)) { + return false; + } + switch (type) { + case network::mojom::DataElementType::kBytes: { + // TODO(richard.li): Delete this workaround when type of + // blink::FormDataElement::data_ is changed to WTF::Vector<uint8_t> + WTF::Vector<uint8_t> buf; + if (!view.ReadBuf(&buf)) { + return false; + } + form_data->AppendData(buf.data(), buf.size()); + break; + } + case network::mojom::DataElementType::kFile: { + base::FilePath file_path; + base::Time expected_time; + if (!view.ReadPath(&file_path) || + !view.ReadExpectedModificationTime(&expected_time)) { + return false; + } + base::Optional<base::Time> expected_file_modification_time; + if (!expected_time.is_null()) { + expected_file_modification_time = expected_time; + } + form_data->AppendFileRange(blink::FilePathToString(file_path), + view.offset(), view.length(), + expected_file_modification_time); + break; + } + case network::mojom::DataElementType::kDataPipe: { + auto data_pipe_ptr_remote = view.TakeDataPipeGetter< + mojo::PendingRemote<network::mojom::blink::DataPipeGetter>>(); + DCHECK(data_pipe_ptr_remote.is_valid()); + + form_data->AppendDataPipe( + base::MakeRefCounted<blink::WrappedDataPipeGetter>( + std::move(data_pipe_ptr_remote))); + + break; + } + case network::mojom::DataElementType::kBlob: + case network::mojom::DataElementType::kUnknown: + case network::mojom::DataElementType::kChunkedDataPipe: + case network::mojom::DataElementType::kRawFile: + NOTREACHED(); + return false; + } + } + + form_data->identifier_ = in.identifier(); + form_data->contains_password_data_ = in.contains_sensitive_info(); + form_data->SetBoundary( + blink::FormDataEncoder::GenerateUniqueBoundaryString()); + *out = blink::ResourceRequestBody(std::move(form_data)); + return true; +} + +} // namespace mojo diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/fetch_api_request_body_mojom_traits.h b/chromium/third_party/blink/renderer/platform/loader/fetch/fetch_api_request_body_mojom_traits.h new file mode 100644 index 00000000000..f85aee270a8 --- /dev/null +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/fetch_api_request_body_mojom_traits.h @@ -0,0 +1,39 @@ +// Copyright 2020 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. + +#ifndef THIRD_PARTY_BLINK_RENDERER_PLATFORM_LOADER_FETCH_FETCH_API_REQUEST_BODY_MOJOM_TRAITS_H_ +#define THIRD_PARTY_BLINK_RENDERER_PLATFORM_LOADER_FETCH_FETCH_API_REQUEST_BODY_MOJOM_TRAITS_H_ + +#include "third_party/blink/public/mojom/fetch/fetch_api_request.mojom-blink-forward.h" +#include "third_party/blink/renderer/platform/loader/fetch/resource_request.h" +#include "third_party/blink/renderer/platform/network/encoded_form_data.h" +#include "third_party/blink/renderer/platform/wtf/vector.h" + +namespace mojo { + +template <> +struct PLATFORM_EXPORT StructTraits<blink::mojom::FetchAPIRequestBodyDataView, + blink::ResourceRequestBody> { + static bool IsNull(const blink::ResourceRequestBody& body) { + return body.IsEmpty(); + } + static void SetToNull(blink::ResourceRequestBody* out) { + *out = blink::ResourceRequestBody(); + } + static WTF::Vector<blink::mojom::blink::FetchAPIDataElementPtr> elements( + blink::ResourceRequestBody& mutable_body); + static int64_t identifier(const blink::ResourceRequestBody& body) { + return body.FormBody() ? body.FormBody()->Identifier() : 0; + } + static bool contains_sensitive_info(const blink::ResourceRequestBody& body) { + return body.FormBody() ? body.FormBody()->ContainsPasswordData() : false; + } + + static bool Read(blink::mojom::FetchAPIRequestBodyDataView in, + blink::ResourceRequestBody* out); +}; + +} // namespace mojo + +#endif // THIRD_PARTY_BLINK_RENDERER_PLATFORM_LOADER_FETCH_FETCH_API_REQUEST_BODY_MOJOM_TRAITS_H_ diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/fetch_api_request_body_mojom_traits_test.cc b/chromium/third_party/blink/renderer/platform/loader/fetch/fetch_api_request_body_mojom_traits_test.cc new file mode 100644 index 00000000000..7f96b51c38f --- /dev/null +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/fetch_api_request_body_mojom_traits_test.cc @@ -0,0 +1,149 @@ +// Copyright 2020 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. + +#include "third_party/blink/renderer/platform/loader/fetch/fetch_api_request_body_mojom_traits.h" + +#include "base/test/task_environment.h" +#include "mojo/public/cpp/base/file_mojom_traits.h" +#include "mojo/public/cpp/base/file_path_mojom_traits.h" +#include "mojo/public/cpp/bindings/array_traits_wtf_vector.h" +#include "mojo/public/cpp/test_support/test_utils.h" +#include "testing/gtest/include/gtest/gtest.h" +#include "third_party/blink/public/mojom/fetch/fetch_api_request.mojom-blink.h" +#include "third_party/blink/public/platform/file_path_conversion.h" +#include "third_party/blink/renderer/platform/blob/blob_data.h" +#include "third_party/blink/renderer/platform/loader/fetch/resource_request.h" +#include "third_party/blink/renderer/platform/network/form_data_encoder.h" +#include "third_party/blink/renderer/platform/network/wrapped_data_pipe_getter.h" + +namespace blink { +namespace { + +class FetchApiRequestBodyMojomTraitsTest : public testing::Test { + protected: + base::test::TaskEnvironment task_environment_; +}; + +TEST_F(FetchApiRequestBodyMojomTraitsTest, RoundTripEmpty) { + ResourceRequestBody src; + + ResourceRequestBody dest; + EXPECT_TRUE(mojo::test::SerializeAndDeserialize< + blink::mojom::blink::FetchAPIRequestBody>(&src, &dest)); + + EXPECT_TRUE(dest.IsEmpty()); +} + +TEST_F(FetchApiRequestBodyMojomTraitsTest, RoundTripBytes) { + ResourceRequestBody src(EncodedFormData::Create()); + src.FormBody()->AppendData("hello", 5); + src.FormBody()->SetIdentifier(29); + src.FormBody()->SetContainsPasswordData(true); + + ResourceRequestBody dest; + EXPECT_TRUE(mojo::test::SerializeAndDeserialize< + blink::mojom::blink::FetchAPIRequestBody>(&src, &dest)); + + ASSERT_TRUE(dest.FormBody()); + EXPECT_EQ(dest.FormBody()->Identifier(), 29); + EXPECT_TRUE(dest.FormBody()->ContainsPasswordData()); + ASSERT_EQ(1u, dest.FormBody()->Elements().size()); + const FormDataElement& e = dest.FormBody()->Elements()[0]; + EXPECT_EQ(e.type_, FormDataElement::kData); + EXPECT_EQ("hello", String(e.data_.data(), e.data_.size())); +} + +TEST_F(FetchApiRequestBodyMojomTraitsTest, RoundTripFile) { + ResourceRequestBody src(EncodedFormData::Create()); + const base::Time now = base::Time::Now(); + src.FormBody()->AppendFile("file.name", now); + + ResourceRequestBody dest; + EXPECT_TRUE(mojo::test::SerializeAndDeserialize< + blink::mojom::blink::FetchAPIRequestBody>(&src, &dest)); + + ASSERT_TRUE(dest.FormBody()); + ASSERT_EQ(1u, dest.FormBody()->Elements().size()); + const FormDataElement& e = dest.FormBody()->Elements()[0]; + EXPECT_EQ(e.type_, FormDataElement::kEncodedFile); + EXPECT_EQ(e.filename_, "file.name"); + EXPECT_EQ(e.file_start_, 0); + EXPECT_EQ(e.file_length_, BlobData::kToEndOfFile); + EXPECT_EQ(e.expected_file_modification_time_, now); +} + +TEST_F(FetchApiRequestBodyMojomTraitsTest, RoundTripFileRange) { + ResourceRequestBody src(EncodedFormData::Create()); + src.FormBody()->AppendFileRange("abc", 4, 8, base::nullopt); + + ResourceRequestBody dest; + EXPECT_TRUE(mojo::test::SerializeAndDeserialize< + blink::mojom::blink::FetchAPIRequestBody>(&src, &dest)); + + ASSERT_TRUE(dest.FormBody()); + ASSERT_EQ(1u, dest.FormBody()->Elements().size()); + const FormDataElement& e = dest.FormBody()->Elements()[0]; + EXPECT_EQ(e.type_, FormDataElement::kEncodedFile); + EXPECT_EQ(e.filename_, "abc"); + EXPECT_EQ(e.file_start_, 4); + EXPECT_EQ(e.file_length_, 8); + EXPECT_EQ(e.expected_file_modification_time_, base::nullopt); +} + +TEST_F(FetchApiRequestBodyMojomTraitsTest, RoundTripBlobWithOpionalHandle) { + ResourceRequestBody src(EncodedFormData::Create()); + mojo::MessagePipe pipe; + String uuid = "test_uuid"; + auto blob_data_handle = BlobDataHandle::Create( + uuid, "type-test", 100, + mojo::PendingRemote<mojom::blink::Blob>(std::move(pipe.handle0), 0)); + src.FormBody()->AppendBlob(uuid, blob_data_handle); + + ResourceRequestBody dest; + EXPECT_TRUE(mojo::test::SerializeAndDeserialize< + blink::mojom::blink::FetchAPIRequestBody>(&src, &dest)); + + ASSERT_TRUE(dest.FormBody()); + ASSERT_EQ(1u, dest.FormBody()->Elements().size()); + const FormDataElement& e = dest.FormBody()->Elements()[0]; + EXPECT_EQ(e.type_, FormDataElement::kDataPipe); + EXPECT_EQ(e.blob_uuid_, String()); + EXPECT_TRUE(e.data_pipe_getter_); +} + +TEST_F(FetchApiRequestBodyMojomTraitsTest, RoundTripDataPipeGetter) { + ResourceRequestBody src(EncodedFormData::Create()); + mojo::PendingRemote<network::mojom::blink::DataPipeGetter> data_pipe_getter; + ignore_result(data_pipe_getter.InitWithNewPipeAndPassReceiver()); + src.FormBody()->AppendDataPipe( + base::MakeRefCounted<blink::WrappedDataPipeGetter>( + std::move(data_pipe_getter))); + + ResourceRequestBody dest; + EXPECT_TRUE(mojo::test::SerializeAndDeserialize< + blink::mojom::blink::FetchAPIRequestBody>(&src, &dest)); + + ASSERT_TRUE(dest.FormBody()); + ASSERT_EQ(1u, dest.FormBody()->Elements().size()); + const FormDataElement& e = dest.FormBody()->Elements()[0]; + EXPECT_EQ(e.type_, FormDataElement::kDataPipe); + EXPECT_TRUE(e.data_pipe_getter_); +} + +TEST_F(FetchApiRequestBodyMojomTraitsTest, RoundTripStreamBody) { + mojo::PendingRemote<network::mojom::blink::ChunkedDataPipeGetter> + chunked_data_pipe_getter; + ignore_result(chunked_data_pipe_getter.InitWithNewPipeAndPassReceiver()); + ResourceRequestBody src(std::move(chunked_data_pipe_getter)); + + ResourceRequestBody dest; + EXPECT_TRUE(mojo::test::SerializeAndDeserialize< + blink::mojom::blink::FetchAPIRequestBody>(&src, &dest)); + + EXPECT_FALSE(dest.FormBody()); + ASSERT_TRUE(dest.StreamBody()); +} + +} // namespace +} // namespace blink diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/fetch_client_settings_object.h b/chromium/third_party/blink/renderer/platform/loader/fetch/fetch_client_settings_object.h index 9f5f505218e..f3af4183d5c 100644 --- a/chromium/third_party/blink/renderer/platform/loader/fetch/fetch_client_settings_object.h +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/fetch_client_settings_object.h @@ -89,7 +89,7 @@ class PLATFORM_EXPORT FetchClientSettingsObject virtual const InsecureNavigationsSet& GetUpgradeInsecureNavigationsSet() const = 0; - virtual void Trace(Visitor*) {} + virtual void Trace(Visitor*) const {} }; } // namespace blink diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/fetch_context.cc b/chromium/third_party/blink/renderer/platform/loader/fetch/fetch_context.cc index 2b44f836099..01135cbc9d3 100644 --- a/chromium/third_party/blink/renderer/platform/loader/fetch/fetch_context.cc +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/fetch_context.cc @@ -55,7 +55,8 @@ void FetchContext::PopulateResourceRequest( ResourceType, const ClientHintsPreferences&, const FetchParameters::ResourceWidth&, - ResourceRequest&) {} + ResourceRequest&, + const FetchInitiatorInfo&) {} mojo::PendingReceiver<mojom::blink::WorkerTimingContainer> FetchContext::TakePendingWorkerTimingReceiver(int request_id) { diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/fetch_context.h b/chromium/third_party/blink/renderer/platform/loader/fetch/fetch_context.h index 1be8c54a4f6..87cf4fd2c4c 100644 --- a/chromium/third_party/blink/renderer/platform/loader/fetch/fetch_context.h +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/fetch_context.h @@ -76,7 +76,7 @@ class PLATFORM_EXPORT FetchContext : public GarbageCollected<FetchContext> { virtual ~FetchContext() = default; - virtual void Trace(Visitor*) {} + virtual void Trace(Visitor*) const {} virtual void AddAdditionalRequestHeaders(ResourceRequest&); @@ -114,7 +114,8 @@ class PLATFORM_EXPORT FetchContext : public GarbageCollected<FetchContext> { const KURL&, const ResourceLoaderOptions&, ReportingDisposition, - ResourceRequest::RedirectStatus) const { + const base::Optional<ResourceRequest::RedirectInfo>& redirect_info) + const { return ResourceRequestBlockedReason::kOther; } virtual base::Optional<ResourceRequestBlockedReason> CheckCSPForRequest( @@ -123,6 +124,7 @@ class PLATFORM_EXPORT FetchContext : public GarbageCollected<FetchContext> { const KURL&, const ResourceLoaderOptions&, ReportingDisposition, + const KURL& url_before_redirects, ResourceRequest::RedirectStatus) const { return ResourceRequestBlockedReason::kOther; } @@ -133,7 +135,8 @@ class PLATFORM_EXPORT FetchContext : public GarbageCollected<FetchContext> { virtual void PopulateResourceRequest(ResourceType, const ClientHintsPreferences&, const FetchParameters::ResourceWidth&, - ResourceRequest&); + ResourceRequest&, + const FetchInitiatorInfo&); // Called when the underlying context is detached. Note that some // FetchContexts continue working after detached (e.g., for fetch() operations diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/memory_cache.cc b/chromium/third_party/blink/renderer/platform/loader/fetch/memory_cache.cc index 90f489445b7..5b5a5363894 100644 --- a/chromium/third_party/blink/renderer/platform/loader/fetch/memory_cache.cc +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/memory_cache.cc @@ -66,7 +66,7 @@ MemoryCache* ReplaceMemoryCacheForTesting(MemoryCache* cache) { return old_cache; } -void MemoryCacheEntry::Trace(Visitor* visitor) { +void MemoryCacheEntry::Trace(Visitor* visitor) const { visitor->template RegisterWeakCallbackMethod< MemoryCacheEntry, &MemoryCacheEntry::ClearResourceWeak>(this); } @@ -93,7 +93,7 @@ MemoryCache::MemoryCache( MemoryCache::~MemoryCache() = default; -void MemoryCache::Trace(Visitor* visitor) { +void MemoryCache::Trace(Visitor* visitor) const { visitor->Trace(resource_maps_); MemoryCacheDumpClient::Trace(visitor); MemoryPressureListener::Trace(visitor); diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/memory_cache.h b/chromium/third_party/blink/renderer/platform/loader/fetch/memory_cache.h index 9ade4a0c74a..422f7c62006 100644 --- a/chromium/third_party/blink/renderer/platform/loader/fetch/memory_cache.h +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/memory_cache.h @@ -51,7 +51,7 @@ class MemoryCacheEntry final : public GarbageCollected<MemoryCacheEntry> { public: explicit MemoryCacheEntry(Resource* resource) : resource_(resource) {} - void Trace(Visitor*); + void Trace(Visitor*) const; Resource* GetResource() const { return resource_; } private: @@ -72,7 +72,7 @@ class PLATFORM_EXPORT MemoryCache final : public GarbageCollected<MemoryCache>, explicit MemoryCache(scoped_refptr<base::SingleThreadTaskRunner> task_runner); ~MemoryCache() override; - void Trace(Visitor*) override; + void Trace(Visitor*) const override; struct TypeStatistic { STACK_ALLOCATED(); diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/null_resource_fetcher_properties.cc b/chromium/third_party/blink/renderer/platform/loader/fetch/null_resource_fetcher_properties.cc index 3a93692ce8b..5ee3444f91f 100644 --- a/chromium/third_party/blink/renderer/platform/loader/fetch/null_resource_fetcher_properties.cc +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/null_resource_fetcher_properties.cc @@ -29,7 +29,7 @@ NullResourceFetcherProperties::NullResourceFetcherProperties() mojom::blink::InsecureRequestPolicy::kLeaveInsecureRequestsAlone, FetchClientSettingsObject::InsecureNavigationsSet())) {} -void NullResourceFetcherProperties::Trace(Visitor* visitor) { +void NullResourceFetcherProperties::Trace(Visitor* visitor) const { visitor->Trace(fetch_client_settings_object_); ResourceFetcherProperties::Trace(visitor); } diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/null_resource_fetcher_properties.h b/chromium/third_party/blink/renderer/platform/loader/fetch/null_resource_fetcher_properties.h index 0a2433b1e0f..893e4b2c0b7 100644 --- a/chromium/third_party/blink/renderer/platform/loader/fetch/null_resource_fetcher_properties.h +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/null_resource_fetcher_properties.h @@ -20,7 +20,7 @@ class PLATFORM_EXPORT NullResourceFetcherProperties final NullResourceFetcherProperties(); ~NullResourceFetcherProperties() override = default; - void Trace(Visitor*) override; + void Trace(Visitor*) const override; // ResourceFetcherProperties implementation const FetchClientSettingsObject& GetFetchClientSettingsObject() diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/raw_resource.cc b/chromium/third_party/blink/renderer/platform/loader/fetch/raw_resource.cc index e4725807ea0..a713c39c685 100644 --- a/chromium/third_party/blink/renderer/platform/loader/fetch/raw_resource.cc +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/raw_resource.cc @@ -148,7 +148,7 @@ class RawResource::PreloadBytesConsumerClient final String DebugName() const override { return "PreloadBytesConsumerClient"; } - void Trace(Visitor* visitor) override { + void Trace(Visitor* visitor) const override { visitor->Trace(bytes_consumer_); visitor->Trace(resource_); visitor->Trace(client_); @@ -242,7 +242,7 @@ scoped_refptr<BlobDataHandle> RawResource::DownloadedBlob() const { return downloaded_blob_; } -void RawResource::Trace(Visitor* visitor) { +void RawResource::Trace(Visitor* visitor) const { visitor->Trace(bytes_consumer_for_preload_); Resource::Trace(visitor); } diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/raw_resource.h b/chromium/third_party/blink/renderer/platform/loader/fetch/raw_resource.h index f6d5e482e33..760b6f9704a 100644 --- a/chromium/third_party/blink/renderer/platform/loader/fetch/raw_resource.h +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/raw_resource.h @@ -94,7 +94,7 @@ class PLATFORM_EXPORT RawResource final : public Resource { scoped_refptr<BlobDataHandle> DownloadedBlob() const; - void Trace(Visitor* visitor) override; + void Trace(Visitor* visitor) const override; protected: CachedMetadataHandler* CreateCachedMetadataHandler( diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/raw_resource_test.cc b/chromium/third_party/blink/renderer/platform/loader/fetch/raw_resource_test.cc index f4085622ad2..af378f81f7c 100644 --- a/chromium/third_party/blink/renderer/platform/loader/fetch/raw_resource_test.cc +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/raw_resource_test.cc @@ -124,7 +124,9 @@ class DummyClient final : public GarbageCollected<DummyClient>, return number_of_redirects_received_; } const Vector<char>& Data() { return data_; } - void Trace(Visitor* visitor) override { RawResourceClient::Trace(visitor); } + void Trace(Visitor* visitor) const override { + RawResourceClient::Trace(visitor); + } private: bool called_; @@ -160,7 +162,7 @@ class AddingClient final : public GarbageCollected<AddingClient>, void RemoveClient() { resource_->RemoveClient(dummy_client_); } - void Trace(Visitor* visitor) override { + void Trace(Visitor* visitor) const override { visitor->Trace(dummy_client_); visitor->Trace(resource_); RawResourceClient::Trace(visitor); @@ -205,7 +207,7 @@ class RemovingClient : public GarbageCollected<RemovingClient>, resource->RemoveClient(this); } String DebugName() const override { return "RemovingClient"; } - void Trace(Visitor* visitor) override { + void Trace(Visitor* visitor) const override { visitor->Trace(dummy_client_); RawResourceClient::Trace(visitor); } diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/resource.cc b/chromium/third_party/blink/renderer/platform/loader/fetch/resource.cc index 08c2b41d79e..d5290152785 100644 --- a/chromium/third_party/blink/renderer/platform/loader/fetch/resource.cc +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/resource.cc @@ -173,7 +173,7 @@ Resource::~Resource() { InstanceCounters::DecrementCounter(InstanceCounters::kResourceCounter); } -void Resource::Trace(Visitor* visitor) { +void Resource::Trace(Visitor* visitor) const { visitor->Trace(loader_); visitor->Trace(cache_handler_); visitor->Trace(clients_); @@ -233,7 +233,7 @@ void Resource::CheckResourceIntegrity() { } void Resource::NotifyFinished() { - CHECK(IsFinishedInternal()); + CHECK(IsLoaded()); ResourceClientWalker<ResourceClient> w(clients_); while (ResourceClient* c = w.Next()) { @@ -577,7 +577,7 @@ void Resource::DidAddClient(ResourceClient* client) { } if (!HasClient(client)) return; - if (IsFinishedInternal()) { + if (IsLoaded()) { client->SetHasFinishedFromMemoryCache(); client->NotifyFinished(this); if (clients_.Contains(client)) { @@ -650,12 +650,6 @@ void Resource::AddFinishObserver(ResourceFinishObserver* client, WillAddClientOrObserver(); finish_observers_.insert(client); - // Despite these being "Finish" observers, what they actually care about is - // whether the resource is "Loaded", not "Finished" (e.g. link onload). Hence - // we check IsLoaded directly here, rather than IsFinishedInternal. - // - // TODO(leszeks): Either rename FinishObservers to LoadedObservers, or the - // NotifyFinished method of ResourceClient to NotifyProcessed (or similar). if (IsLoaded()) TriggerNotificationForFinishObservers(task_runner); } diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/resource.h b/chromium/third_party/blink/renderer/platform/loader/fetch/resource.h index 70f2b412cb8..aef9af9c8cf 100644 --- a/chromium/third_party/blink/renderer/platform/loader/fetch/resource.h +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/resource.h @@ -62,6 +62,7 @@ class Clock; namespace blink { +class BlobDataHandle; class CachedMetadataHandler; class CachedMetadataSender; class FetchParameters; @@ -147,7 +148,7 @@ class PLATFORM_EXPORT Resource : public GarbageCollected<Resource>, ~Resource() override; - void Trace(Visitor*) override; + void Trace(Visitor*) const override; virtual WTF::TextEncoding Encoding() const { return WTF::TextEncoding(); } virtual void AppendData(const char*, size_t); @@ -411,18 +412,6 @@ class PLATFORM_EXPORT Resource : public GarbageCollected<Resource>, ResourceType, const ResourceLoaderOptions&); - // Returns true if the resource has finished any processing it wanted to do - // after loading. Should only be used to decide whether to call - // NotifyFinished. - // - // By default this is the same as being loaded (i.e. no processing), but it is - // used by ScriptResource to signal that streaming JavaScript compilation - // completed. Note that classes overloading this method should also overload - // NotifyFinished to not call Resource::NotifyFinished until this value - // becomes true. - // TODO(hiroshige): Remove this when ScriptResourceContent is introduced. - virtual bool IsFinishedInternal() const { return IsLoaded(); } - virtual void NotifyDataReceived(const char* data, size_t size); virtual void NotifyFinished(); diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/resource_client.cc b/chromium/third_party/blink/renderer/platform/loader/fetch/resource_client.cc index cc5b402427a..b33bb8fc1c3 100644 --- a/chromium/third_party/blink/renderer/platform/loader/fetch/resource_client.cc +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/resource_client.cc @@ -29,7 +29,7 @@ namespace blink { -void ResourceClient::Trace(Visitor* visitor) { +void ResourceClient::Trace(Visitor* visitor) const { visitor->Trace(resource_); } diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/resource_client.h b/chromium/third_party/blink/renderer/platform/loader/fetch/resource_client.h index a4ea28e5e0f..026754807d8 100644 --- a/chromium/third_party/blink/renderer/platform/loader/fetch/resource_client.h +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/resource_client.h @@ -70,7 +70,7 @@ class PLATFORM_EXPORT ResourceClient : public GarbageCollectedMixin { // Name for debugging, e.g. shown in memory-infra. virtual String DebugName() const = 0; - void Trace(Visitor* visitor) override; + void Trace(Visitor* visitor) const override; protected: void ClearResource() { SetResource(nullptr, nullptr); } diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/resource_error.cc b/chromium/third_party/blink/renderer/platform/loader/fetch/resource_error.cc index efee303d37e..899a9d8db19 100644 --- a/chromium/third_party/blink/renderer/platform/loader/fetch/resource_error.cc +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/resource_error.cc @@ -110,18 +110,6 @@ ResourceError::ResourceError(const WebURLError& error) InitializeDescription(); } -ResourceError ResourceError::Copy() const { - ResourceError error_copy(error_code_, failing_url_.Copy(), - cors_error_status_); - error_copy.extended_error_code_ = extended_error_code_; - error_copy.resolve_error_info_ = resolve_error_info_; - error_copy.has_copy_in_cache_ = has_copy_in_cache_; - error_copy.localized_description_ = localized_description_.IsolatedCopy(); - error_copy.is_access_check_ = is_access_check_; - error_copy.trust_token_operation_error_ = trust_token_operation_error_; - return error_copy; -} - ResourceError::operator WebURLError() const { WebURLError::HasCopyInCache has_copy_in_cache = has_copy_in_cache_ ? WebURLError::HasCopyInCache::kTrue @@ -202,7 +190,6 @@ bool ResourceError::ShouldCollapseInitiator() const { } namespace { - blink::ResourceRequestBlockedReason BlockedByResponseReasonToResourceRequestBlockedReason( network::mojom::BlockedByResponseReason reason) { @@ -227,8 +214,8 @@ BlockedByResponseReasonToResourceRequestBlockedReason( NOTREACHED(); return blink::ResourceRequestBlockedReason::kOther; } - } // namespace + base::Optional<ResourceRequestBlockedReason> ResourceError::GetResourceRequestBlockedReason() const { if (error_code_ != net::ERR_BLOCKED_BY_CLIENT && @@ -242,6 +229,15 @@ ResourceError::GetResourceRequestBlockedReason() const { return static_cast<ResourceRequestBlockedReason>(extended_error_code_); } +base::Optional<network::mojom::BlockedByResponseReason> +ResourceError::GetBlockedByResponseReason() const { + if (error_code_ != net::ERR_BLOCKED_BY_CLIENT && + error_code_ != net::ERR_BLOCKED_BY_RESPONSE) { + return base::nullopt; + } + return blocked_by_response_reason_; +} + namespace { String DescriptionForBlockedByClientOrResponse(int error, int extended_error) { if (extended_error == 0) diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/resource_error.h b/chromium/third_party/blink/renderer/platform/loader/fetch/resource_error.h index b5e3030a4e1..238efe12f31 100644 --- a/chromium/third_party/blink/renderer/platform/loader/fetch/resource_error.h +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/resource_error.h @@ -71,10 +71,6 @@ class PLATFORM_EXPORT ResourceError final { const network::CorsErrorStatus& status); ResourceError(const WebURLError&); - // Makes a deep copy. Useful for when you need to use a ResourceError on - // another thread. - ResourceError Copy() const; - int ErrorCode() const { return error_code_; } const String& FailingURL() const { return failing_url_; } const String& LocalizedDescription() const { return localized_description_; } @@ -95,6 +91,8 @@ class PLATFORM_EXPORT ResourceError final { bool ShouldCollapseInitiator() const; base::Optional<ResourceRequestBlockedReason> GetResourceRequestBlockedReason() const; + base::Optional<network::mojom::BlockedByResponseReason> + GetBlockedByResponseReason() const; base::Optional<network::CorsErrorStatus> CorsErrorStatus() const { return cors_error_status_; diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/resource_fetcher.cc b/chromium/third_party/blink/renderer/platform/loader/fetch/resource_fetcher.cc index 73291aca6fa..6f014b84c7d 100644 --- a/chromium/third_party/blink/renderer/platform/loader/fetch/resource_fetcher.cc +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/resource_fetcher.cc @@ -98,6 +98,10 @@ namespace { constexpr base::TimeDelta kKeepaliveLoadersTimeout = base::TimeDelta::FromSeconds(30); +// Timeout for link preloads to be used after window.onload +static constexpr base::TimeDelta kUnusedPreloadTimeout = + base::TimeDelta::FromSeconds(3); + #define RESOURCE_HISTOGRAM_PREFIX "Blink.MemoryCache.RevalidationPolicy." #define DEFINE_SINGLE_RESOURCE_HISTOGRAM(prefix, name) \ @@ -315,9 +319,9 @@ void PopulateAndAddResourceTimingInfo(Resource* resource, base::TimeTicks response_end, int64_t encoded_data_length) { info->SetInitialURL( - resource->GetResourceRequest().GetInitialUrlForResourceTiming().IsNull() - ? resource->GetResourceRequest().Url() - : resource->GetResourceRequest().GetInitialUrlForResourceTiming()); + resource->GetResourceRequest().GetRedirectInfo().has_value() + ? resource->GetResourceRequest().GetRedirectInfo()->original_url + : resource->GetResourceRequest().Url()); info->SetFinalResponse(resource->GetResponse()); info->SetLoadResponseEnd(response_end); // encodedDataLength == -1 means "not available". @@ -647,12 +651,12 @@ void ResourceFetcher::DidLoadResourceFromMemoryCache( scoped_refptr<ResourceTimingInfo> info = ResourceTimingInfo::Create( resource->Options().initiator_info.name, base::TimeTicks::Now(), request.GetRequestContext(), request.GetRequestDestination()); - // TODO(yoav): GetInitialUrlForResourceTiming() is only needed until - // Out-of-Blink CORS lands: https://crbug.com/736308 + // TODO(yoav): Getting the original URL before redirects here is only needed + // until Out-of-Blink CORS lands: https://crbug.com/736308 info->SetInitialURL( - resource->GetResourceRequest().GetInitialUrlForResourceTiming().IsNull() - ? resource->GetResourceRequest().Url() - : resource->GetResourceRequest().GetInitialUrlForResourceTiming()); + resource->GetResourceRequest().GetRedirectInfo().has_value() + ? resource->GetResourceRequest().GetRedirectInfo()->original_url + : resource->GetResourceRequest().Url()); ResourceResponse final_response = resource->GetResponse(); final_response.SetResourceLoadTiming(nullptr); info->SetFinalResponse(final_response); @@ -837,24 +841,33 @@ base::Optional<ResourceRequestBlockedReason> ResourceFetcher::PrepareRequest( ? ReportingDisposition::kSuppressReporting : ReportingDisposition::kReport; - // Note that resource_request.GetRedirectStatus() may return kFollowedRedirect - // here since e.g. ThreadableLoader may create a new Resource from - // a ResourceRequest that originates from the ResourceRequest passed to - // the redirect handling callback. + // Note that resource_request.GetRedirectInfo() may be non-null here since + // e.g. ThreadableLoader may create a new Resource from a ResourceRequest that + // originates from the ResourceRequest passed to the redirect handling + // callback. // Before modifying the request for CSP, evaluate report-only headers. This // allows site owners to learn about requests that are being modified // (e.g. mixed content that is being upgraded by upgrade-insecure-requests). + const base::Optional<ResourceRequest::RedirectInfo>& redirect_info = + resource_request.GetRedirectInfo(); + const KURL& url_before_redirects = + redirect_info ? redirect_info->original_url : params.Url(); + const ResourceRequestHead::RedirectStatus redirect_status = + redirect_info ? ResourceRequestHead::RedirectStatus::kFollowedRedirect + : ResourceRequestHead::RedirectStatus::kNoRedirect; Context().CheckCSPForRequest( resource_request.GetRequestContext(), resource_request.GetRequestDestination(), MemoryCache::RemoveFragmentIdentifierIfNeeded(params.Url()), options, - reporting_disposition, resource_request.GetRedirectStatus()); + reporting_disposition, + MemoryCache::RemoveFragmentIdentifierIfNeeded(url_before_redirects), + redirect_status); // This may modify params.Url() (via the resource_request argument). Context().PopulateResourceRequest( resource_type, params.GetClientHintsPreferences(), - params.GetResourceWidth(), resource_request); + params.GetResourceWidth(), resource_request, options.initiator_info); if (!params.Url().IsValid()) return ResourceRequestBlockedReason::kOther; @@ -911,7 +924,7 @@ base::Optional<ResourceRequestBlockedReason> ResourceFetcher::PrepareRequest( base::Optional<ResourceRequestBlockedReason> blocked_reason = Context().CanRequest(resource_type, resource_request, url, options, reporting_disposition, - resource_request.GetRedirectStatus()); + resource_request.GetRedirectInfo()); if (Context().CalculateIfAdSubresource(resource_request, resource_type, options.initiator_info)) @@ -1547,7 +1560,7 @@ ResourceFetcher::DetermineRevalidationPolicyInternal( // Don't reuse resources with Cache-control: no-store. if (existing_resource.HasCacheControlNoStoreHeader()) { return {RevalidationPolicy::kReload, - "Reload due to cache-control: no-sotre."}; + "Reload due to cache-control: no-store."}; } // During the initial load, avoid loading the same resource multiple times for @@ -1705,6 +1718,8 @@ void ResourceFetcher::ClearContext() { console_logger_->Detach(); loader_factory_ = nullptr; + unused_preloads_timer_.Cancel(); + // Make sure the only requests still going are keepalive requests. // Callers of ClearContext() should be calling StopFetching() prior // to this, but it's possible for additional requests to start during @@ -1767,14 +1782,32 @@ void ResourceFetcher::ClearPreloads(ClearPreloadsPolicy policy) { matched_preloads_.clear(); } -Vector<KURL> ResourceFetcher::GetUrlsOfUnusedPreloads() { - Vector<KURL> urls; +void ResourceFetcher::ScheduleWarnUnusedPreloads() { + // If preloads_ is not empty here, it's full of link + // preloads, as speculative preloads should have already been cleared when + // parsing finished. + if (preloads_.IsEmpty()) + return; + unused_preloads_timer_ = PostDelayedCancellableTask( + *task_runner_, FROM_HERE, + WTF::Bind(&ResourceFetcher::WarnUnusedPreloads, WrapWeakPersistent(this)), + kUnusedPreloadTimeout); +} + +void ResourceFetcher::WarnUnusedPreloads() { for (const auto& pair : preloads_) { Resource* resource = pair.value; - if (resource && resource->IsLinkPreload() && resource->IsUnusedPreload()) - urls.push_back(resource->Url()); + if (!resource || !resource->IsLinkPreload() || !resource->IsUnusedPreload()) + continue; + String message = + "The resource " + resource->Url().GetString() + " was preloaded " + + "using link preload but not used within a few seconds from the " + + "window's load event. Please make sure it has an appropriate `as` " + + "value and it is preloaded intentionally."; + console_logger_->AddConsoleMessage( + mojom::blink::ConsoleMessageSource::kJavaScript, + mojom::blink::ConsoleMessageLevel::kWarning, message); } - return urls; } void ResourceFetcher::HandleLoaderFinish(Resource* resource, @@ -2082,7 +2115,7 @@ void ResourceFetcher::EmulateLoadStartedForInspector( Context().CanRequest(resource->GetType(), last_resource_request, last_resource_request.Url(), params.Options(), ReportingDisposition::kReport, - last_resource_request.GetRedirectStatus()); + last_resource_request.GetRedirectInfo()); DidLoadResourceFromMemoryCache(resource, params.GetResourceRequest(), false /* is_static_data */); } @@ -2162,7 +2195,7 @@ FrameOrWorkerScheduler* ResourceFetcher::GetFrameOrWorkerScheduler() { return frame_or_worker_scheduler_.get(); } -void ResourceFetcher::Trace(Visitor* visitor) { +void ResourceFetcher::Trace(Visitor* visitor) const { visitor->Trace(context_); visitor->Trace(properties_); visitor->Trace(resource_load_observer_); diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/resource_fetcher.h b/chromium/third_party/blink/renderer/platform/loader/fetch/resource_fetcher.h index 252c777bec6..1e52ae18bc8 100644 --- a/chromium/third_party/blink/renderer/platform/loader/fetch/resource_fetcher.h +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/resource_fetcher.h @@ -87,7 +87,7 @@ class PLATFORM_EXPORT ResourceFetcher public: virtual ~LoaderFactory() = default; - virtual void Trace(Visitor*) {} + virtual void Trace(Visitor*) const {} // Create a WebURLLoader for given the request information and task runner. virtual std::unique_ptr<WebURLLoader> CreateURLLoader( @@ -103,7 +103,7 @@ class PLATFORM_EXPORT ResourceFetcher // in ResourceFetcherInit to ensure correctness of this ResourceFetcher. explicit ResourceFetcher(const ResourceFetcherInit&); virtual ~ResourceFetcher(); - virtual void Trace(Visitor*); + virtual void Trace(Visitor*) const; // - This function returns the same object throughout this fetcher's // entire life. @@ -198,7 +198,7 @@ class PLATFORM_EXPORT ResourceFetcher int CountPreloads() const { return preloads_.size(); } void ClearPreloads(ClearPreloadsPolicy = kClearAllPreloads); - Vector<KURL> GetUrlsOfUnusedPreloads(); + void ScheduleWarnUnusedPreloads(); MHTMLArchive* Archive() const { return archive_.Get(); } @@ -385,6 +385,8 @@ class PLATFORM_EXPORT ResourceFetcher void ScheduleStaleRevalidate(Resource* stale_resource); void RevalidateStaleResource(Resource* stale_resource); + void WarnUnusedPreloads(); + Member<DetachableResourceFetcherProperties> properties_; Member<ResourceLoadObserver> resource_load_observer_; Member<FetchContext> context_; @@ -410,6 +412,8 @@ class PLATFORM_EXPORT ResourceFetcher TaskRunnerTimer<ResourceFetcher> resource_timing_report_timer_; + TaskHandle unused_preloads_timer_; + using ResourceTimingInfoMap = HeapHashMap<Member<Resource>, scoped_refptr<ResourceTimingInfo>>; ResourceTimingInfoMap resource_timing_info_map_; diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/resource_fetcher_properties.cc b/chromium/third_party/blink/renderer/platform/loader/fetch/resource_fetcher_properties.cc index 382d1de0c5b..6b4603a91dd 100644 --- a/chromium/third_party/blink/renderer/platform/loader/fetch/resource_fetcher_properties.cc +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/resource_fetcher_properties.cc @@ -29,7 +29,7 @@ void DetachableResourceFetcherProperties::Detach() { properties_ = nullptr; } -void DetachableResourceFetcherProperties::Trace(Visitor* visitor) { +void DetachableResourceFetcherProperties::Trace(Visitor* visitor) const { visitor->Trace(properties_); visitor->Trace(fetch_client_settings_object_); ResourceFetcherProperties::Trace(visitor); diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/resource_fetcher_properties.h b/chromium/third_party/blink/renderer/platform/loader/fetch/resource_fetcher_properties.h index 99ff28be578..cbb33a18d14 100644 --- a/chromium/third_party/blink/renderer/platform/loader/fetch/resource_fetcher_properties.h +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/resource_fetcher_properties.h @@ -40,7 +40,7 @@ class PLATFORM_EXPORT ResourceFetcherProperties ResourceFetcherProperties() = default; virtual ~ResourceFetcherProperties() = default; - virtual void Trace(Visitor*) {} + virtual void Trace(Visitor*) const {} // Returns the client settings object bound to this global context. virtual const FetchClientSettingsObject& GetFetchClientSettingsObject() @@ -103,7 +103,7 @@ class PLATFORM_EXPORT DetachableResourceFetcherProperties final void Detach(); - void Trace(Visitor* visitor) override; + void Trace(Visitor* visitor) const override; // ResourceFetcherProperties implementation // Add a test in resource_fetcher_test.cc when you change behaviors. diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/resource_fetcher_test.cc b/chromium/third_party/blink/renderer/platform/loader/fetch/resource_fetcher_test.cc index 980d15a3fd0..a75f632fef6 100644 --- a/chromium/third_party/blink/renderer/platform/loader/fetch/resource_fetcher_test.cc +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/resource_fetcher_test.cc @@ -83,19 +83,6 @@ constexpr char kTestResourceFilename[] = "white-1x1.png"; constexpr char kTestResourceMimeType[] = "image/png"; constexpr uint32_t kTestResourceSize = 103; // size of white-1x1.png -void RegisterMockedURLLoadWithCustomResponse(const WebURL& full_url, - const WebString& file_path, - WebURLResponse response) { - url_test_helpers::RegisterMockedURLLoadWithCustomResponse(full_url, file_path, - response); -} - -void RegisterMockedURLLoad(const KURL& url) { - url_test_helpers::RegisterMockedURLLoad( - url, test::PlatformTestDataPath(kTestResourceFilename), - kTestResourceMimeType); -} - const FetchClientSettingsObjectSnapshot& CreateFetchClientSettingsObject( network::mojom::IPAddressSpace address_space) { return *MakeGarbageCollected<FetchClientSettingsObjectSnapshot>( @@ -178,6 +165,7 @@ class ResourceFetcherTest : public testing::Test { scoped_refptr<scheduler::FakeTaskRunner> CreateTaskRunner() { return base::MakeRefCounted<scheduler::FakeTaskRunner>(); } + ResourceFetcher* CreateFetcher( const TestResourceFetcherProperties& properties, FetchContext* context) { @@ -185,18 +173,27 @@ class ResourceFetcherTest : public testing::Test { properties.MakeDetachable(), context, CreateTaskRunner(), MakeGarbageCollected<TestLoaderFactory>())); } + ResourceFetcher* CreateFetcher( const TestResourceFetcherProperties& properties) { return CreateFetcher(properties, MakeGarbageCollected<MockFetchContext>()); } + ResourceFetcher* CreateFetcher() { return CreateFetcher( *MakeGarbageCollected<TestResourceFetcherProperties>()); } + void AddResourceToMemoryCache(Resource* resource) { GetMemoryCache()->Add(resource); } + void RegisterMockedURLLoad(const KURL& url) { + url_test_helpers::RegisterMockedURLLoad( + url, test::PlatformTestDataPath(kTestResourceFilename), + kTestResourceMimeType, platform_->GetURLLoaderMockFactory()); + } + ScopedTestingPlatformSupport<FetchTestingPlatformSupport> platform_; private: @@ -231,9 +228,9 @@ TEST_F(ResourceFetcherTest, UseExistingResource) { ResourceResponse response(url); response.SetHttpStatusCode(200); response.SetHttpHeaderField(http_names::kCacheControl, "max-age=3600"); - RegisterMockedURLLoadWithCustomResponse( - url, test::PlatformTestDataPath(kTestResourceFilename), - WrappedResourceResponse(response)); + platform_->GetURLLoaderMockFactory()->RegisterURL( + url, WrappedResourceResponse(response), + test::PlatformTestDataPath(kTestResourceFilename)); FetchParameters fetch_params{ResourceRequest(url)}; Resource* resource = MockResource::Fetch(fetch_params, fetcher, nullptr); @@ -360,9 +357,9 @@ TEST_F(ResourceFetcherTest, VaryResource) { response.SetHttpStatusCode(200); response.SetHttpHeaderField(http_names::kCacheControl, "max-age=3600"); response.SetHttpHeaderField(http_names::kVary, "*"); - RegisterMockedURLLoadWithCustomResponse( - url, test::PlatformTestDataPath(kTestResourceFilename), - WrappedResourceResponse(response)); + platform_->GetURLLoaderMockFactory()->RegisterURL( + url, WrappedResourceResponse(response), + test::PlatformTestDataPath(kTestResourceFilename)); FetchParameters fetch_params_original{ResourceRequest(url)}; Resource* resource = @@ -410,7 +407,9 @@ class RequestSameResourceOnComplete } bool NotifyFinishedCalled() const { return notify_finished_called_; } - void Trace(Visitor* visitor) override { RawResourceClient::Trace(visitor); } + void Trace(Visitor* visitor) const override { + RawResourceClient::Trace(visitor); + } String DebugName() const override { return "RequestSameResourceOnComplete"; } @@ -428,9 +427,9 @@ TEST_F(ResourceFetcherTest, RevalidateWhileFinishingLoading) { response.SetHttpStatusCode(200); response.SetHttpHeaderField(http_names::kCacheControl, "max-age=3600"); response.SetHttpHeaderField(http_names::kETag, "1234567890"); - RegisterMockedURLLoadWithCustomResponse( - url, test::PlatformTestDataPath(kTestResourceFilename), - WrappedResourceResponse(response)); + platform_->GetURLLoaderMockFactory()->RegisterURL( + url, WrappedResourceResponse(response), + test::PlatformTestDataPath(kTestResourceFilename)); ResourceFetcher* fetcher1 = CreateFetcher( *MakeGarbageCollected<TestResourceFetcherProperties>(source_origin)); @@ -469,8 +468,11 @@ class ServeRequestsOnCompleteClient final USING_GARBAGE_COLLECTED_MIXIN(ServeRequestsOnCompleteClient); public: + explicit ServeRequestsOnCompleteClient(WebURLLoaderMockFactory* mock_factory) + : mock_factory_(mock_factory) {} + void NotifyFinished(Resource*) override { - url_test_helpers::ServeAsynchronousRequests(); + mock_factory_->ServeAsynchronousRequests(); ClearResource(); } @@ -494,9 +496,14 @@ class ServeRequestsOnCompleteClient final } void DataDownloaded(Resource*, uint64_t) override { ASSERT_TRUE(false); } - void Trace(Visitor* visitor) override { RawResourceClient::Trace(visitor); } + void Trace(Visitor* visitor) const override { + RawResourceClient::Trace(visitor); + } String DebugName() const override { return "ServeRequestsOnCompleteClient"; } + + private: + WebURLLoaderMockFactory* mock_factory_; }; // Regression test for http://crbug.com/594072. @@ -513,7 +520,8 @@ TEST_F(ResourceFetcherTest, ResponseOnCancel) { resource_request.SetRequestContext(mojom::RequestContextType::INTERNAL); FetchParameters fetch_params(std::move(resource_request)); Persistent<ServeRequestsOnCompleteClient> client = - MakeGarbageCollected<ServeRequestsOnCompleteClient>(); + MakeGarbageCollected<ServeRequestsOnCompleteClient>( + platform_->GetURLLoaderMockFactory()); Resource* resource = RawResource::Fetch(fetch_params, fetcher, client); resource->Loader()->Cancel(); } @@ -523,9 +531,12 @@ class ScopedMockRedirectRequester { public: ScopedMockRedirectRequester( + WebURLLoaderMockFactory* mock_factory, MockFetchContext* context, scoped_refptr<base::SingleThreadTaskRunner> task_runner) - : context_(context), task_runner_(std::move(task_runner)) {} + : mock_factory_(mock_factory), + context_(context), + task_runner_(std::move(task_runner)) {} void RegisterRedirect(const WebString& from_url, const WebString& to_url) { KURL redirect_url(from_url); @@ -535,13 +546,13 @@ class ScopedMockRedirectRequester { redirect_response.SetHttpHeaderField(http_names::kLocation, to_url); redirect_response.SetEncodedDataLength(kRedirectResponseOverheadBytes); - RegisterMockedURLLoadWithCustomResponse(redirect_url, "", - redirect_response); + mock_factory_->RegisterURL(redirect_url, redirect_response, ""); } void RegisterFinalResource(const WebString& url) { - KURL final_url(url); - RegisterMockedURLLoad(final_url); + url_test_helpers::RegisterMockedURLLoad( + KURL(url), test::PlatformTestDataPath(kTestResourceFilename), + kTestResourceMimeType, mock_factory_); } void Request(const WebString& url) { @@ -553,10 +564,11 @@ class ScopedMockRedirectRequester { resource_request.SetRequestContext(mojom::RequestContextType::INTERNAL); FetchParameters fetch_params(std::move(resource_request)); RawResource::Fetch(fetch_params, fetcher, nullptr); - url_test_helpers::ServeAsynchronousRequests(); + mock_factory_->ServeAsynchronousRequests(); } private: + WebURLLoaderMockFactory* mock_factory_; MockFetchContext* context_; const scoped_refptr<base::SingleThreadTaskRunner> task_runner_; @@ -567,7 +579,8 @@ TEST_F(ResourceFetcherTest, SameOriginRedirect) { const char kRedirectURL[] = "http://127.0.0.1:8000/redirect.html"; const char kFinalURL[] = "http://127.0.0.1:8000/final.html"; MockFetchContext* context = MakeGarbageCollected<MockFetchContext>(); - ScopedMockRedirectRequester requester(context, CreateTaskRunner()); + ScopedMockRedirectRequester requester(platform_->GetURLLoaderMockFactory(), + context, CreateTaskRunner()); requester.RegisterRedirect(kRedirectURL, kFinalURL); requester.RegisterFinalResource(kFinalURL); requester.Request(kRedirectURL); @@ -580,7 +593,8 @@ TEST_F(ResourceFetcherTest, CrossOriginRedirect) { const char kRedirectURL[] = "http://otherorigin.test/redirect.html"; const char kFinalURL[] = "http://127.0.0.1:8000/final.html"; MockFetchContext* context = MakeGarbageCollected<MockFetchContext>(); - ScopedMockRedirectRequester requester(context, CreateTaskRunner()); + ScopedMockRedirectRequester requester(platform_->GetURLLoaderMockFactory(), + context, CreateTaskRunner()); requester.RegisterRedirect(kRedirectURL, kFinalURL); requester.RegisterFinalResource(kFinalURL); requester.Request(kRedirectURL); @@ -594,7 +608,8 @@ TEST_F(ResourceFetcherTest, ComplexCrossOriginRedirect) { const char kRedirectURL3[] = "http://127.0.0.1:8000/redirect3.html"; const char kFinalURL[] = "http://127.0.0.1:8000/final.html"; MockFetchContext* context = MakeGarbageCollected<MockFetchContext>(); - ScopedMockRedirectRequester requester(context, CreateTaskRunner()); + ScopedMockRedirectRequester requester(platform_->GetURLLoaderMockFactory(), + context, CreateTaskRunner()); requester.RegisterRedirect(kRedirectURL1, kRedirectURL2); requester.RegisterRedirect(kRedirectURL2, kRedirectURL3); requester.RegisterRedirect(kRedirectURL3, kFinalURL); @@ -923,9 +938,9 @@ TEST_F(ResourceFetcherTest, ContentIdURL) { KURL url("cid:0123456789@example.com"); ResourceResponse response(url); response.SetHttpStatusCode(200); - RegisterMockedURLLoadWithCustomResponse( - url, test::PlatformTestDataPath(kTestResourceFilename), - WrappedResourceResponse(response)); + platform_->GetURLLoaderMockFactory()->RegisterURL( + url, WrappedResourceResponse(response), + test::PlatformTestDataPath(kTestResourceFilename)); auto* fetcher = CreateFetcher(); @@ -959,9 +974,9 @@ TEST_F(ResourceFetcherTest, StaleWhileRevalidate) { response.SetHttpHeaderField(http_names::kCacheControl, "max-age=0, stale-while-revalidate=40"); - RegisterMockedURLLoadWithCustomResponse( - url, test::PlatformTestDataPath(kTestResourceFilename), - WrappedResourceResponse(response)); + platform_->GetURLLoaderMockFactory()->RegisterURL( + url, WrappedResourceResponse(response), + test::PlatformTestDataPath(kTestResourceFilename)); Resource* resource = MockResource::Fetch(fetch_params, fetcher, nullptr); ASSERT_TRUE(resource); @@ -983,9 +998,9 @@ TEST_F(ResourceFetcherTest, StaleWhileRevalidate) { ResourceResponse revalidate_response(url); revalidate_response.SetHttpStatusCode(200); platform_->GetURLLoaderMockFactory()->UnregisterURL(url); - RegisterMockedURLLoadWithCustomResponse( - url, test::PlatformTestDataPath(kTestResourceFilename), - WrappedResourceResponse(revalidate_response)); + platform_->GetURLLoaderMockFactory()->RegisterURL( + url, WrappedResourceResponse(revalidate_response), + test::PlatformTestDataPath(kTestResourceFilename)); new_resource = MockResource::Fetch(fetch_params2, fetcher, nullptr); EXPECT_EQ(resource, new_resource); EXPECT_TRUE(GetMemoryCache()->Contains(resource)); @@ -1007,9 +1022,9 @@ TEST_F(ResourceFetcherTest, CachedResourceShouldNotCrashByNullURL) { KURL url("http://127.0.0.1:8000/foo.html"); ResourceResponse response(url); response.SetHttpStatusCode(200); - RegisterMockedURLLoadWithCustomResponse( - url, test::PlatformTestDataPath(kTestResourceFilename), - WrappedResourceResponse(response)); + platform_->GetURLLoaderMockFactory()->RegisterURL( + url, WrappedResourceResponse(response), + test::PlatformTestDataPath(kTestResourceFilename)); FetchParameters fetch_params{ResourceRequest(url)}; MockResource::Fetch(fetch_params, fetcher, nullptr); ASSERT_NE(fetcher->CachedResource(url), nullptr); diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/resource_finish_observer.h b/chromium/third_party/blink/renderer/platform/loader/fetch/resource_finish_observer.h index 376800c68cd..6de0a227fbf 100644 --- a/chromium/third_party/blink/renderer/platform/loader/fetch/resource_finish_observer.h +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/resource_finish_observer.h @@ -31,7 +31,7 @@ class PLATFORM_EXPORT ResourceFinishObserver // Name for debugging virtual String DebugName() const = 0; - virtual void Trace(Visitor* visitor) {} + virtual void Trace(Visitor* visitor) const {} }; } // namespace blink diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/resource_load_observer.h b/chromium/third_party/blink/renderer/platform/loader/fetch/resource_load_observer.h index 16104ff9310..698f8edd04d 100644 --- a/chromium/third_party/blink/renderer/platform/loader/fetch/resource_load_observer.h +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/resource_load_observer.h @@ -96,7 +96,7 @@ class PLATFORM_EXPORT ResourceLoadObserver int64_t encoded_data_length, IsInternalRequest) = 0; - virtual void Trace(Visitor*) {} + virtual void Trace(Visitor*) const {} }; } // namespace blink diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/resource_load_scheduler.cc b/chromium/third_party/blink/renderer/platform/loader/fetch/resource_load_scheduler.cc index b73ea743cc7..3c712242b3f 100644 --- a/chromium/third_party/blink/renderer/platform/loader/fetch/resource_load_scheduler.cc +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/resource_load_scheduler.cc @@ -105,7 +105,7 @@ ResourceLoadScheduler::ResourceLoadScheduler( ResourceLoadScheduler::~ResourceLoadScheduler() = default; -void ResourceLoadScheduler::Trace(Visitor* visitor) { +void ResourceLoadScheduler::Trace(Visitor* visitor) const { visitor->Trace(pending_request_map_); visitor->Trace(resource_fetcher_properties_); visitor->Trace(console_logger_); diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/resource_load_scheduler.h b/chromium/third_party/blink/renderer/platform/loader/fetch/resource_load_scheduler.h index 7663076d189..df37d766d50 100644 --- a/chromium/third_party/blink/renderer/platform/loader/fetch/resource_load_scheduler.h +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/resource_load_scheduler.h @@ -33,7 +33,7 @@ class PLATFORM_EXPORT ResourceLoadSchedulerClient // Called when the request is granted to run. virtual void Run() = 0; - void Trace(Visitor* visitor) override {} + void Trace(Visitor* visitor) const override {} }; // ResourceLoadScheduler provides a unified per-frame infrastructure to schedule @@ -170,7 +170,7 @@ class PLATFORM_EXPORT ResourceLoadScheduler final DetachableConsoleLogger& console_logger); ~ResourceLoadScheduler() override; - void Trace(Visitor*); + void Trace(Visitor*) const; // Changes the policy from |kTight| to |kNormal|. This function can be called // multiple times, and does nothing when the scheduler is already working with @@ -261,7 +261,7 @@ class PLATFORM_EXPORT ResourceLoadScheduler final priority(priority), intra_priority(intra_priority) {} - void Trace(Visitor* visitor) { visitor->Trace(client); } + void Trace(Visitor* visitor) const { visitor->Trace(client); } Member<ResourceLoadSchedulerClient> client; ThrottleOption option; diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/resource_load_scheduler_test.cc b/chromium/third_party/blink/renderer/platform/loader/fetch/resource_load_scheduler_test.cc index d5bfad70b7a..d87179dd0fe 100644 --- a/chromium/third_party/blink/renderer/platform/loader/fetch/resource_load_scheduler_test.cc +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/resource_load_scheduler_test.cc @@ -38,7 +38,7 @@ class MockClient final : public GarbageCollected<MockClient>, return client_order_; } - void Trace(Visitor* visitor) { visitor->Trace(client_order_); } + void Trace(Visitor* visitor) const { visitor->Trace(client_order_); } private: HeapVector<Member<MockClient>> client_order_; @@ -56,7 +56,7 @@ class MockClient final : public GarbageCollected<MockClient>, } bool WasRun() { return was_run_; } - void Trace(Visitor* visitor) override { + void Trace(Visitor* visitor) const override { ResourceLoadSchedulerClient::Trace(visitor); visitor->Trace(console_logger_); } diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/resource_load_timing.cc b/chromium/third_party/blink/renderer/platform/loader/fetch/resource_load_timing.cc index d09e6c051fb..e285beac7c2 100644 --- a/chromium/third_party/blink/renderer/platform/loader/fetch/resource_load_timing.cc +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/resource_load_timing.cc @@ -11,23 +11,26 @@ namespace blink { ResourceLoadTiming::ResourceLoadTiming() = default; -ResourceLoadTiming::ResourceLoadTiming(base::TimeTicks request_time, - base::TimeTicks proxy_start, - base::TimeTicks proxy_end, - base::TimeTicks dns_start, - base::TimeTicks dns_end, - base::TimeTicks connect_start, - base::TimeTicks connect_end, - base::TimeTicks worker_start, - base::TimeTicks worker_ready, - base::TimeTicks send_start, - base::TimeTicks send_end, - base::TimeTicks receive_headers_start, - base::TimeTicks receive_headers_end, - base::TimeTicks ssl_start, - base::TimeTicks ssl_end, - base::TimeTicks push_start, - base::TimeTicks push_end) +ResourceLoadTiming::ResourceLoadTiming( + base::TimeTicks request_time, + base::TimeTicks proxy_start, + base::TimeTicks proxy_end, + base::TimeTicks dns_start, + base::TimeTicks dns_end, + base::TimeTicks connect_start, + base::TimeTicks connect_end, + base::TimeTicks worker_start, + base::TimeTicks worker_ready, + base::TimeTicks worker_fetch_start, + base::TimeTicks worker_respond_with_settled, + base::TimeTicks send_start, + base::TimeTicks send_end, + base::TimeTicks receive_headers_start, + base::TimeTicks receive_headers_end, + base::TimeTicks ssl_start, + base::TimeTicks ssl_end, + base::TimeTicks push_start, + base::TimeTicks push_end) : request_time_(request_time), proxy_start_(proxy_start), proxy_end_(proxy_end), @@ -37,6 +40,8 @@ ResourceLoadTiming::ResourceLoadTiming(base::TimeTicks request_time, connect_end_(connect_end), worker_start_(worker_start), worker_ready_(worker_ready), + worker_fetch_start_(worker_fetch_start), + worker_respond_with_settled_(worker_respond_with_settled), send_start_(send_start), send_end_(send_end), receive_headers_start_(receive_headers_start), @@ -61,7 +66,9 @@ scoped_refptr<ResourceLoadTiming> ResourceLoadTiming::FromMojo( mojo_timing->connect_timing->connect_start, mojo_timing->connect_timing->connect_end, mojo_timing->service_worker_start_time, - mojo_timing->service_worker_ready_time, mojo_timing->send_start, + mojo_timing->service_worker_ready_time, + mojo_timing->service_worker_fetch_start, + mojo_timing->service_worker_respond_with_settled, mojo_timing->send_start, mojo_timing->send_end, mojo_timing->receive_headers_start, mojo_timing->receive_headers_end, mojo_timing->connect_timing->ssl_start, mojo_timing->connect_timing->ssl_end, mojo_timing->push_start, @@ -76,7 +83,9 @@ network::mojom::blink::LoadTimingInfoPtr ResourceLoadTiming::ToMojo() const { dns_start_, dns_end_, connect_start_, connect_end_, ssl_start_, ssl_end_), send_start_, send_end_, receive_headers_start_, receive_headers_end_, - push_start_, push_end_, worker_start_, worker_ready_); + /*first_early_hints_time=*/base::TimeTicks::Now(), push_start_, + push_end_, worker_start_, worker_ready_, worker_fetch_start_, + worker_respond_with_settled_); return timing; } @@ -88,6 +97,8 @@ bool ResourceLoadTiming::operator==(const ResourceLoadTiming& other) const { connect_end_ == other.connect_end_ && worker_start_ == other.worker_start_ && worker_ready_ == other.worker_ready_ && + worker_fetch_start_ == other.worker_fetch_start_ && + worker_respond_with_settled_ == other.worker_respond_with_settled_ && send_start_ == other.send_start_ && send_end_ == other.send_end_ && receive_headers_start_ == other.receive_headers_start_ && receive_headers_end_ == other.receive_headers_end_ && @@ -135,6 +146,16 @@ void ResourceLoadTiming::SetWorkerReady(base::TimeTicks worker_ready) { worker_ready_ = worker_ready; } +void ResourceLoadTiming::SetWorkerFetchStart( + base::TimeTicks worker_fetch_start) { + worker_fetch_start_ = worker_fetch_start; +} + +void ResourceLoadTiming::SetWorkerRespondWithSettled( + base::TimeTicks worker_respond_with_settled) { + worker_respond_with_settled_ = worker_respond_with_settled; +} + void ResourceLoadTiming::SetSendStart(base::TimeTicks send_start) { TRACE_EVENT_MARK_WITH_TIMESTAMP0("blink.user_timing", "requestStart", send_start); diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/resource_load_timing.h b/chromium/third_party/blink/renderer/platform/loader/fetch/resource_load_timing.h index b87da1d183f..0e0de9534d1 100644 --- a/chromium/third_party/blink/renderer/platform/loader/fetch/resource_load_timing.h +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/resource_load_timing.h @@ -54,6 +54,8 @@ class PLATFORM_EXPORT ResourceLoadTiming void SetConnectEnd(base::TimeTicks); void SetWorkerStart(base::TimeTicks); void SetWorkerReady(base::TimeTicks); + void SetWorkerFetchStart(base::TimeTicks); + void SetWorkerRespondWithSettled(base::TimeTicks); void SetSendStart(base::TimeTicks); void SetSendEnd(base::TimeTicks); void SetReceiveHeadersStart(base::TimeTicks); @@ -72,6 +74,10 @@ class PLATFORM_EXPORT ResourceLoadTiming base::TimeTicks ConnectEnd() const { return connect_end_; } base::TimeTicks WorkerStart() const { return worker_start_; } base::TimeTicks WorkerReady() const { return worker_ready_; } + base::TimeTicks WorkerFetchStart() const { return worker_fetch_start_; } + base::TimeTicks WorkerRespondWithSettled() const { + return worker_respond_with_settled_; + } base::TimeTicks SendStart() const { return send_start_; } base::TimeTicks SendEnd() const { return send_end_; } base::TimeTicks ReceiveHeadersStart() const { return receive_headers_start_; } @@ -94,6 +100,8 @@ class PLATFORM_EXPORT ResourceLoadTiming base::TimeTicks connect_end, base::TimeTicks worker_start, base::TimeTicks worker_ready, + base::TimeTicks worker_fetch_start, + base::TimeTicks worker_respond_with_settled, base::TimeTicks send_start, base::TimeTicks send_end, base::TimeTicks receive_headers_start, @@ -123,6 +131,8 @@ class PLATFORM_EXPORT ResourceLoadTiming base::TimeTicks connect_end_; base::TimeTicks worker_start_; base::TimeTicks worker_ready_; + base::TimeTicks worker_fetch_start_; + base::TimeTicks worker_respond_with_settled_; base::TimeTicks send_start_; base::TimeTicks send_end_; base::TimeTicks receive_headers_start_; diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/resource_loader.cc b/chromium/third_party/blink/renderer/platform/loader/fetch/resource_loader.cc index cd2ec6c9b14..40e9601c5fb 100644 --- a/chromium/third_party/blink/renderer/platform/loader/fetch/resource_loader.cc +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/resource_loader.cc @@ -418,7 +418,7 @@ ResourceLoader::ResourceLoader(ResourceFetcher* fetcher, ResourceLoader::~ResourceLoader() = default; -void ResourceLoader::Trace(Visitor* visitor) { +void ResourceLoader::Trace(Visitor* visitor) const { visitor->Trace(fetcher_); visitor->Trace(scheduler_); visitor->Trace(resource_); @@ -749,6 +749,8 @@ bool ResourceLoader::WillFollowRedirect( const ResourceResponse& redirect_response( passed_redirect_response.ToResourceResponse()); + const KURL& url_before_redirects = initial_request.Url(); + if (!IsManualRedirectFetchRequest(initial_request)) { bool unused_preload = resource_->IsUnusedPreload(); @@ -761,14 +763,13 @@ bool ResourceLoader::WillFollowRedirect( // ensure that violations are sent. Context().CheckCSPForRequest( request_context, request_destination, new_url, options, - reporting_disposition, + reporting_disposition, url_before_redirects, ResourceRequest::RedirectStatus::kFollowedRedirect); base::Optional<ResourceRequestBlockedReason> blocked_reason = - Context().CanRequest( - resource_type, *new_request, new_url, options, - reporting_disposition, - ResourceRequest::RedirectStatus::kFollowedRedirect); + Context().CanRequest(resource_type, *new_request, new_url, options, + reporting_disposition, + new_request->GetRedirectInfo()); if (Context().CalculateIfAdSubresource(*new_request, resource_type, options.initiator_info)) @@ -1043,18 +1044,24 @@ void ResourceLoader::DidReceiveResponseInternal( // pre-request checks, and consider running the checks regardless of service // worker interception. const KURL& response_url = response.ResponseUrl(); + const base::Optional<ResourceRequest::RedirectInfo>& + previous_redirect_info = request.GetRedirectInfo(); + const KURL& original_url = previous_redirect_info + ? previous_redirect_info->original_url + : request.Url(); + const ResourceRequest::RedirectInfo redirect_info(original_url, + request.Url()); // CanRequest() below only checks enforced policies: check report-only // here to ensure violations are sent. Context().CheckCSPForRequest( request_context, request_destination, response_url, options, - ReportingDisposition::kReport, + ReportingDisposition::kReport, original_url, ResourceRequest::RedirectStatus::kFollowedRedirect); base::Optional<ResourceRequestBlockedReason> blocked_reason = - Context().CanRequest( - resource_type, ResourceRequest(initial_request), response_url, - options, ReportingDisposition::kReport, - ResourceRequest::RedirectStatus::kFollowedRedirect); + Context().CanRequest(resource_type, ResourceRequest(initial_request), + response_url, options, + ReportingDisposition::kReport, redirect_info); if (blocked_reason) { HandleError(ResourceError::CancelledDueToAccessCheckError( response_url, blocked_reason.value())); diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/resource_loader.h b/chromium/third_party/blink/renderer/platform/loader/fetch/resource_loader.h index 2ecfb827b55..572c5025c61 100644 --- a/chromium/third_party/blink/renderer/platform/loader/fetch/resource_loader.h +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/resource_loader.h @@ -78,7 +78,7 @@ class PLATFORM_EXPORT ResourceLoader final ResourceRequestBody request_body = ResourceRequestBody(), uint32_t inflight_keepalive_bytes = 0); ~ResourceLoader() override; - void Trace(Visitor*) override; + void Trace(Visitor*) const override; void Start(); diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/resource_loader_test.cc b/chromium/third_party/blink/renderer/platform/loader/fetch/resource_loader_test.cc index 7d307cefc7c..c389ccf608a 100644 --- a/chromium/third_party/blink/renderer/platform/loader/fetch/resource_loader_test.cc +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/resource_loader_test.cc @@ -326,7 +326,7 @@ class TestRawResourceClient final } String DebugName() const override { return "TestRawResourceClient"; } - void Trace(Visitor* visitor) override { + void Trace(Visitor* visitor) const override { visitor->Trace(body_); RawResourceClient::Trace(visitor); } diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/resource_request.cc b/chromium/third_party/blink/renderer/platform/loader/fetch/resource_request.cc index 8ee020a6df7..d08337b3203 100644 --- a/chromium/third_party/blink/renderer/platform/loader/fetch/resource_request.cc +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/resource_request.cc @@ -76,8 +76,7 @@ ResourceRequestHead::ResourceRequestHead(const KURL& url) referrer_policy_(network::mojom::ReferrerPolicy::kDefault), is_external_request_(false), cors_preflight_policy_( - network::mojom::CorsPreflightPolicy::kConsiderPreflight), - redirect_status_(RedirectStatus::kNoRedirect) {} + network::mojom::CorsPreflightPolicy::kConsiderPreflight) {} ResourceRequestHead::ResourceRequestHead(const ResourceRequestHead&) = default; @@ -97,16 +96,26 @@ ResourceRequestBody::ResourceRequestBody( scoped_refptr<EncodedFormData> form_body) : form_body_(form_body) {} +ResourceRequestBody::ResourceRequestBody( + mojo::PendingRemote<network::mojom::blink::ChunkedDataPipeGetter> + stream_body) + : stream_body_(std::move(stream_body)) {} + ResourceRequestBody::ResourceRequestBody(ResourceRequestBody&& src) - : ResourceRequestBody(std::move(src.form_body_)) {} + : form_body_(std::move(src.form_body_)), + stream_body_(std::move(src.stream_body_)) {} -ResourceRequestBody& ResourceRequestBody::operator=(ResourceRequestBody&& src) { - form_body_ = std::move(src.form_body_); - return *this; -} +ResourceRequestBody& ResourceRequestBody::operator=(ResourceRequestBody&& src) = + default; ResourceRequestBody::~ResourceRequestBody() = default; +void ResourceRequestBody::SetStreamBody( + mojo::PendingRemote<network::mojom::blink::ChunkedDataPipeGetter> + stream_body) { + stream_body_ = std::move(stream_body); +} + ResourceRequest::ResourceRequest() : ResourceRequestHead(NullURL()) {} ResourceRequest::ResourceRequest(const String& url_string) @@ -118,6 +127,8 @@ ResourceRequest::ResourceRequest(const ResourceRequestHead& head) : ResourceRequestHead(head) {} ResourceRequest& ResourceRequest::operator=(const ResourceRequest& src) { + DCHECK(!body_.StreamBody().is_valid()); + DCHECK(!src.body_.StreamBody().is_valid()); this->ResourceRequestHead::operator=(src); body_.SetFormBody(src.body_.FormBody()); return *this; @@ -130,6 +141,8 @@ ResourceRequest& ResourceRequest::operator=(ResourceRequest&&) = default; ResourceRequest::~ResourceRequest() = default; void ResourceRequest::CopyFrom(const ResourceRequest& src) { + DCHECK(!body_.StreamBody().is_valid()); + DCHECK(!src.body_.StreamBody().is_valid()); *this = src; } @@ -155,7 +168,8 @@ std::unique_ptr<ResourceRequest> ResourceRequestHead::CreateRedirectRequest( request->SetReferrerString(referrer); request->SetReferrerPolicy(new_referrer_policy); request->SetSkipServiceWorker(skip_service_worker); - request->SetRedirectStatus(RedirectStatus::kFollowedRedirect); + request->redirect_info_ = RedirectInfo( + redirect_info_ ? redirect_info_->original_url : Url(), Url()); // Copy from parameters for |this|. request->SetDownloadToBlob(DownloadToBlob()); @@ -197,14 +211,6 @@ void ResourceRequestHead::SetUrl(const KURL& url) { url_ = url; } -const KURL& ResourceRequestHead::GetInitialUrlForResourceTiming() const { - return initial_url_for_resource_timing_; -} - -void ResourceRequestHead::SetInitialUrlForResourceTiming(const KURL& url) { - initial_url_for_resource_timing_ = url; -} - void ResourceRequestHead::RemoveUserAndPassFromURL() { if (url_.User().IsEmpty() && url_.Pass().IsEmpty()) return; diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/resource_request.h b/chromium/third_party/blink/renderer/platform/loader/fetch/resource_request.h index 71139b093a3..10d84b66618 100644 --- a/chromium/third_party/blink/renderer/platform/loader/fetch/resource_request.h +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/resource_request.h @@ -36,6 +36,7 @@ #include "base/unguessable_token.h" #include "net/cookies/site_for_cookies.h" #include "services/metrics/public/cpp/ukm_source_id.h" +#include "services/network/public/mojom/chunked_data_pipe_getter.mojom-blink.h" #include "services/network/public/mojom/cors.mojom-blink-forward.h" #include "services/network/public/mojom/fetch_api.mojom-blink-forward.h" #include "services/network/public/mojom/ip_address_space.mojom-blink-forward.h" @@ -64,7 +65,21 @@ class PLATFORM_EXPORT ResourceRequestHead { DISALLOW_NEW(); public: + // TODO: Remove this enum from here since it is not used in this class anymore enum class RedirectStatus : uint8_t { kFollowedRedirect, kNoRedirect }; + + struct RedirectInfo { + // Original (first) url in the redirect chain. + KURL original_url; + + // Previous url in the redirect chain. + KURL previous_url; + + RedirectInfo() = delete; + RedirectInfo(const KURL& original_url, const KURL& previous_url) + : original_url(original_url), previous_url(previous_url) {} + }; + ResourceRequestHead(); explicit ResourceRequestHead(const KURL&); @@ -91,14 +106,6 @@ class PLATFORM_EXPORT ResourceRequestHead { const KURL& Url() const; void SetUrl(const KURL&); - // ThreadableLoader sometimes breaks redirect chains into separate Resource - // and ResourceRequests. The ResourceTiming API needs the initial URL for the - // name attribute of PerformanceResourceTiming entries. This property - // remembers the initial URL for that purpose. Note that it can return a null - // URL. In that case, use Url() instead. - const KURL& GetInitialUrlForResourceTiming() const; - void SetInitialUrlForResourceTiming(const KURL&); - void RemoveUserAndPassFromURL(); mojom::FetchCacheMode GetCacheMode() const; @@ -334,8 +341,9 @@ class PLATFORM_EXPORT ResourceRequestHead { cors_preflight_policy_ = policy; } - void SetRedirectStatus(RedirectStatus status) { redirect_status_ = status; } - RedirectStatus GetRedirectStatus() const { return redirect_status_; } + const base::Optional<RedirectInfo>& GetRedirectInfo() const { + return redirect_info_; + } void SetSuggestedFilename(const base::Optional<String>& suggested_filename) { suggested_filename_ = suggested_filename; @@ -454,15 +462,19 @@ class PLATFORM_EXPORT ResourceRequestHead { // |url|, bool CanDisplay(const KURL&) const; + void SetAllowHTTP1ForStreamingUpload(bool allow) { + allowHTTP1ForStreamingUpload_ = allow; + } + bool AllowHTTP1ForStreamingUpload() const { + return allowHTTP1ForStreamingUpload_; + } + private: const CacheControlHeader& GetCacheControlHeader() const; bool NeedsHTTPOrigin() const; KURL url_; - // TODO(yoav): initial_url_for_resource_timing_ is a stop-gap only needed - // until Out-of-Blink CORS lands: https://crbug.com/736308 - KURL initial_url_for_resource_timing_; // base::TimeDelta::Max() represents the default timeout on platforms that // have one. base::TimeDelta timeout_interval_; @@ -503,7 +515,7 @@ class PLATFORM_EXPORT ResourceRequestHead { network::mojom::ReferrerPolicy referrer_policy_; bool is_external_request_; network::mojom::CorsPreflightPolicy cors_preflight_policy_; - RedirectStatus redirect_status_; + base::Optional<RedirectInfo> redirect_info_; base::Optional<network::mojom::blink::TrustTokenParams> trust_token_params_; base::Optional<String> suggested_filename_; @@ -541,6 +553,8 @@ class PLATFORM_EXPORT ResourceRequestHead { // the prefetch cache will be restricted to top-level-navigations. bool prefetch_maybe_for_top_level_navigation_ = false; + bool allowHTTP1ForStreamingUpload_ = false; + // This is used when fetching preload header requests from cross-origin // prefetch responses. The browser process uses this token to ensure the // request is cached correctly. @@ -551,6 +565,9 @@ class PLATFORM_EXPORT ResourceRequestBody { public: ResourceRequestBody(); explicit ResourceRequestBody(scoped_refptr<EncodedFormData> form_body); + explicit ResourceRequestBody( + mojo::PendingRemote<network::mojom::blink::ChunkedDataPipeGetter> + stream_body); ResourceRequestBody(const ResourceRequestBody&) = delete; ResourceRequestBody(ResourceRequestBody&&); @@ -559,11 +576,25 @@ class PLATFORM_EXPORT ResourceRequestBody { ~ResourceRequestBody(); + bool IsEmpty() const { return !form_body_ && !stream_body_; } const scoped_refptr<EncodedFormData>& FormBody() const { return form_body_; } void SetFormBody(scoped_refptr<EncodedFormData>); + mojo::PendingRemote<network::mojom::blink::ChunkedDataPipeGetter> + TakeStreamBody() { + return std::move(stream_body_); + } + const mojo::PendingRemote<network::mojom::blink::ChunkedDataPipeGetter>& + StreamBody() const { + return stream_body_; + } + void SetStreamBody( + mojo::PendingRemote<network::mojom::blink::ChunkedDataPipeGetter>); + private: scoped_refptr<EncodedFormData> form_body_; + mojo::PendingRemote<network::mojom::blink::ChunkedDataPipeGetter> + stream_body_; }; // A ResourceRequest is a "request" object for ResourceLoader. Conceptually diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/resource_response.cc b/chromium/third_party/blink/renderer/platform/loader/fetch/resource_response.cc index f7848a110e7..76717a71a0e 100644 --- a/chromium/third_party/blink/renderer/platform/loader/fetch/resource_response.cc +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/resource_response.cc @@ -82,14 +82,10 @@ ResourceResponse::SignedCertificateTimestamp::IsolatedCopy() const { signature_data_.IsolatedCopy()); } -ResourceResponse::ResourceResponse() - : is_null_(true), - response_type_(network::mojom::FetchResponseType::kDefault) {} +ResourceResponse::ResourceResponse() : is_null_(true) {} ResourceResponse::ResourceResponse(const KURL& current_request_url) - : current_request_url_(current_request_url), - is_null_(false), - response_type_(network::mojom::FetchResponseType::kDefault) {} + : current_request_url_(current_request_url), is_null_(false) {} ResourceResponse::ResourceResponse(const ResourceResponse&) = default; ResourceResponse& ResourceResponse::operator=(const ResourceResponse&) = diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/resource_response.h b/chromium/third_party/blink/renderer/platform/loader/fetch/resource_response.h index 4028c6341d2..26dc39ba236 100644 --- a/chromium/third_party/blink/renderer/platform/loader/fetch/resource_response.h +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/resource_response.h @@ -34,6 +34,7 @@ #include "base/optional.h" #include "base/time/time.h" #include "services/network/public/mojom/cross_origin_embedder_policy.mojom-shared.h" +#include "services/network/public/mojom/fetch_api.mojom-shared.h" #include "third_party/blink/public/platform/web_url_response.h" #include "third_party/blink/renderer/platform/network/http_header_map.h" #include "third_party/blink/renderer/platform/network/http_parsers.h" @@ -326,6 +327,15 @@ class PLATFORM_EXPORT ResourceResponse final { was_fetched_via_service_worker_ = value; } + network::mojom::FetchResponseSource GetServiceWorkerResponseSource() const { + return service_worker_response_source_; + } + + void SetServiceWorkerResponseSource( + network::mojom::FetchResponseSource value) { + service_worker_response_source_ = value; + } + // See network::ResourceResponseInfo::was_fallback_required_by_service_worker. bool WasFallbackRequiredByServiceWorker() const { return was_fallback_required_by_service_worker_; @@ -525,6 +535,11 @@ class PLATFORM_EXPORT ResourceResponse final { // Was the resource fetched over a ServiceWorker. bool was_fetched_via_service_worker_ = false; + // The source of the resource, if it was fetched via ServiceWorker. This is + // kUnspecified if |was_fetched_via_service_worker| is false. + network::mojom::FetchResponseSource service_worker_response_source_ = + network::mojom::FetchResponseSource::kUnspecified; + // Was the fallback request with skip service worker flag required. bool was_fallback_required_by_service_worker_ = false; @@ -556,7 +571,8 @@ class PLATFORM_EXPORT ResourceResponse final { bool was_alpn_negotiated_ = false; // https://fetch.spec.whatwg.org/#concept-response-type - network::mojom::FetchResponseType response_type_; + network::mojom::FetchResponseType response_type_ = + network::mojom::FetchResponseType::kDefault; // HTTP version used in the response, if known. HTTPVersion http_version_ = kHTTPVersionUnknown; diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/response_body_loader.cc b/chromium/third_party/blink/renderer/platform/loader/fetch/response_body_loader.cc index ecb144b4d3b..c878bb13838 100644 --- a/chromium/third_party/blink/renderer/platform/loader/fetch/response_body_loader.cc +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/response_body_loader.cc @@ -220,7 +220,7 @@ class ResponseBodyLoader::DelegatingBytesConsumer final } } - void Trace(Visitor* visitor) override { + void Trace(Visitor* visitor) const override { visitor->Trace(bytes_consumer_); visitor->Trace(loader_); visitor->Trace(bytes_consumer_client_); @@ -480,7 +480,7 @@ void ResponseBodyLoader::OnStateChange() { } } -void ResponseBodyLoader::Trace(Visitor* visitor) { +void ResponseBodyLoader::Trace(Visitor* visitor) const { visitor->Trace(bytes_consumer_); visitor->Trace(delegating_bytes_consumer_); visitor->Trace(client_); diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/response_body_loader.h b/chromium/third_party/blink/renderer/platform/loader/fetch/response_body_loader.h index e6d51e04693..b3c0e8264a7 100644 --- a/chromium/third_party/blink/renderer/platform/loader/fetch/response_body_loader.h +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/response_body_loader.h @@ -53,7 +53,7 @@ class PLATFORM_EXPORT ResponseBodyLoaderDrainableInterface // them back to the associated client asynchronously. virtual BytesConsumer& DrainAsBytesConsumer() = 0; - virtual void Trace(Visitor*) {} + virtual void Trace(Visitor*) const {} }; // ResponseBodyLoader reads the response body and reports the contents to the @@ -100,7 +100,7 @@ class PLATFORM_EXPORT ResponseBodyLoader final bool IsSuspended() const { return suspended_; } bool IsDrained() const { return drained_; } - void Trace(Visitor*) override; + void Trace(Visitor*) const override; // The maximal number of bytes consumed in a task. When there are more bytes // in the data pipe, they will be consumed in following tasks. Setting a too diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/response_body_loader_test.cc b/chromium/third_party/blink/renderer/platform/loader/fetch/response_body_loader_test.cc index 15b6cb9322b..80dc82ccaeb 100644 --- a/chromium/third_party/blink/renderer/platform/loader/fetch/response_body_loader_test.cc +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/response_body_loader_test.cc @@ -76,7 +76,7 @@ class ResponseBodyLoaderTest : public testing::Test { } void SetLoader(ResponseBodyLoader& loader) { loader_ = loader; } - void Trace(Visitor* visitor) override { visitor->Trace(loader_); } + void Trace(Visitor* visitor) const override { visitor->Trace(loader_); } private: const Option option_; @@ -122,7 +122,7 @@ class ResponseBodyLoaderTest : public testing::Test { EXPECT_FALSE(test_response_body_loader_client_->LoadingIsFailed()); } String DebugName() const override { return "ReadingClient"; } - void Trace(Visitor* visitor) override { + void Trace(Visitor* visitor) const override { visitor->Trace(bytes_consumer_); visitor->Trace(test_response_body_loader_client_); BytesConsumer::Client::Trace(visitor); diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/script_cached_metadata_handler.cc b/chromium/third_party/blink/renderer/platform/loader/fetch/script_cached_metadata_handler.cc index 33cedf848d7..08022c8bdc7 100644 --- a/chromium/third_party/blink/renderer/platform/loader/fetch/script_cached_metadata_handler.cc +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/script_cached_metadata_handler.cc @@ -24,7 +24,7 @@ ScriptCachedMetadataHandler::ScriptCachedMetadataHandler( std::unique_ptr<CachedMetadataSender> sender) : sender_(std::move(sender)), encoding_(encoding) {} -void ScriptCachedMetadataHandler::Trace(Visitor* visitor) { +void ScriptCachedMetadataHandler::Trace(Visitor* visitor) const { CachedMetadataHandler::Trace(visitor); } diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/script_cached_metadata_handler.h b/chromium/third_party/blink/renderer/platform/loader/fetch/script_cached_metadata_handler.h index df5ca5535a1..4839b7f7350 100644 --- a/chromium/third_party/blink/renderer/platform/loader/fetch/script_cached_metadata_handler.h +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/script_cached_metadata_handler.h @@ -33,7 +33,7 @@ class PLATFORM_EXPORT ScriptCachedMetadataHandler final ScriptCachedMetadataHandler(const WTF::TextEncoding&, std::unique_ptr<CachedMetadataSender>); ~ScriptCachedMetadataHandler() override = default; - void Trace(Visitor*) override; + void Trace(Visitor*) const override; void SetCachedMetadata(uint32_t, const uint8_t*, size_t) override; void ClearCachedMetadata(ClearCacheType) override; scoped_refptr<CachedMetadata> GetCachedMetadata(uint32_t) const override; diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/source_keyed_cached_metadata_handler.cc b/chromium/third_party/blink/renderer/platform/loader/fetch/source_keyed_cached_metadata_handler.cc index 7650c988f53..d024238c265 100644 --- a/chromium/third_party/blink/renderer/platform/loader/fetch/source_keyed_cached_metadata_handler.cc +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/source_keyed_cached_metadata_handler.cc @@ -18,7 +18,7 @@ const size_t SourceKeyedCachedMetadataHandler::kKeySize; class SourceKeyedCachedMetadataHandler::SingleKeyHandler final : public SingleCachedMetadataHandler { public: - void Trace(Visitor* visitor) override { + void Trace(Visitor* visitor) const override { visitor->Trace(parent_); SingleCachedMetadataHandler::Trace(visitor); } diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/stale_revalidation_resource_client.cc b/chromium/third_party/blink/renderer/platform/loader/fetch/stale_revalidation_resource_client.cc index bd1ead40055..2d1bb0e5f9b 100644 --- a/chromium/third_party/blink/renderer/platform/loader/fetch/stale_revalidation_resource_client.cc +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/stale_revalidation_resource_client.cc @@ -29,7 +29,7 @@ void StaleRevalidationResourceClient::NotifyFinished(Resource* resource) { } } -void StaleRevalidationResourceClient::Trace(Visitor* visitor) { +void StaleRevalidationResourceClient::Trace(Visitor* visitor) const { visitor->Trace(stale_resource_); RawResourceClient::Trace(visitor); } diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/stale_revalidation_resource_client.h b/chromium/third_party/blink/renderer/platform/loader/fetch/stale_revalidation_resource_client.h index b1b9a3eb226..2389675b740 100644 --- a/chromium/third_party/blink/renderer/platform/loader/fetch/stale_revalidation_resource_client.h +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/stale_revalidation_resource_client.h @@ -24,7 +24,7 @@ class StaleRevalidationResourceClient // RawResourceClient overloads. void NotifyFinished(Resource* resource) override; - void Trace(Visitor* visitor) override; + void Trace(Visitor* visitor) const override; String DebugName() const override; private: diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/trust_token_params_conversion.cc b/chromium/third_party/blink/renderer/platform/loader/fetch/trust_token_params_conversion.cc index 6654f8e72d5..c8c631bd23a 100644 --- a/chromium/third_party/blink/renderer/platform/loader/fetch/trust_token_params_conversion.cc +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/trust_token_params_conversion.cc @@ -26,6 +26,10 @@ network::OptionalTrustTokenParams ConvertTrustTokenParams( for (const String& additional_header : in.additional_signed_headers) { out->additional_signed_headers.push_back(additional_header.Latin1()); } + if (!in.possibly_unsafe_additional_signing_data.IsNull()) { + out->possibly_unsafe_additional_signing_data = + in.possibly_unsafe_additional_signing_data.Utf8(); + } return network::OptionalTrustTokenParams(std::move(out)); } diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/url_loader/request_conversion.cc b/chromium/third_party/blink/renderer/platform/loader/fetch/url_loader/request_conversion.cc index c0ddc73d986..25fa0aa4493 100644 --- a/chromium/third_party/blink/renderer/platform/loader/fetch/url_loader/request_conversion.cc +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/url_loader/request_conversion.cc @@ -30,6 +30,7 @@ #include "third_party/blink/renderer/platform/exported/wrapped_resource_request.h" #include "third_party/blink/renderer/platform/loader/fetch/resource_request.h" #include "third_party/blink/renderer/platform/loader/fetch/trust_token_params_conversion.h" +#include "third_party/blink/renderer/platform/network/encoded_form_data.h" #include "third_party/blink/renderer/platform/network/wrapped_data_pipe_getter.h" namespace blink { @@ -347,6 +348,17 @@ void PopulateResourceRequest(const ResourceRequestHead& src, dest->request_body = base::MakeRefCounted<network::ResourceRequestBody>(); PopulateResourceRequestBody(*body, dest->request_body.get()); + } else if (src_body.StreamBody().is_valid()) { + DCHECK_NE(dest->method, net::HttpRequestHeaders::kGetMethod); + DCHECK_NE(dest->method, net::HttpRequestHeaders::kHeadMethod); + mojo::PendingRemote<network::mojom::blink::ChunkedDataPipeGetter> + stream_body = src_body.TakeStreamBody(); + dest->request_body = base::MakeRefCounted<network::ResourceRequestBody>(); + mojo::PendingRemote<network::mojom::ChunkedDataPipeGetter> + network_stream_body(stream_body.PassPipe(), 0u); + dest->request_body->SetToChunkedDataPipe(std::move(network_stream_body)); + dest->request_body->SetAllowHTTP1ForStreamingUpload( + src.AllowHTTP1ForStreamingUpload()); } if (resource_type == mojom::ResourceType::kStylesheet) { diff --git a/chromium/third_party/blink/renderer/platform/loader/fetch/worker_resource_timing_notifier.h b/chromium/third_party/blink/renderer/platform/loader/fetch/worker_resource_timing_notifier.h index 92271f1c6ed..54d2ac975ab 100644 --- a/chromium/third_party/blink/renderer/platform/loader/fetch/worker_resource_timing_notifier.h +++ b/chromium/third_party/blink/renderer/platform/loader/fetch/worker_resource_timing_notifier.h @@ -31,7 +31,7 @@ class WorkerResourceTimingNotifier mojo::PendingReceiver<mojom::blink::WorkerTimingContainer> worker_timing_receiver) = 0; - virtual void Trace(Visitor*) {} + virtual void Trace(Visitor*) const {} }; } // namespace blink |