Index: content/browser/loader/mojo_async_resource_handler.cc |
diff --git a/content/browser/loader/mojo_async_resource_handler.cc b/content/browser/loader/mojo_async_resource_handler.cc |
new file mode 100644 |
index 0000000000000000000000000000000000000000..26799452f50c8b2062ba25be42f6101ca43ebbcb |
--- /dev/null |
+++ b/content/browser/loader/mojo_async_resource_handler.cc |
@@ -0,0 +1,405 @@ |
+// Copyright 2016 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 "content/browser/loader/mojo_async_resource_handler.h" |
+ |
+#include <utility> |
+ |
+#include "base/command_line.h" |
+#include "base/containers/hash_tables.h" |
+#include "base/logging.h" |
+#include "base/macros.h" |
+#include "base/strings/string_number_conversions.h" |
+#include "base/time/time.h" |
+#include "content/browser/loader/netlog_observer.h" |
+#include "content/browser/loader/resource_dispatcher_host_impl.h" |
+#include "content/browser/loader/resource_message_filter.h" |
+#include "content/browser/loader/resource_request_info_impl.h" |
+#include "content/common/resource_request_completion_status.h" |
+#include "content/public/browser/resource_dispatcher_host_delegate.h" |
+#include "content/public/common/resource_response.h" |
+#include "mojo/public/c/system/data_pipe.h" |
+#include "mojo/public/cpp/system/data_pipe.h" |
+#include "net/base/io_buffer.h" |
+#include "net/base/load_flags.h" |
+#include "net/base/mime_sniffer.h" |
+#include "net/log/net_log.h" |
+#include "net/url_request/redirect_info.h" |
+ |
+namespace content { |
+namespace { |
+ |
+int g_max_allocation_size = 1024 * 32; |
+// MimeTypeResourceHandler *implicitly* requires that the buffer size |
+// returned from OnWillRead should be larger than certain size. |
+// TODO(yhirano): Fix MimeTypeResourceHandler. |
+size_t kMinAllocationSize = 2 * net::kMaxBytesToSniff; |
+ |
+void GetNumericArg(const std::string& name, int* result) { |
+ const std::string& value = |
+ base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(name); |
+ if (!value.empty()) |
+ base::StringToInt(value, result); |
+} |
+ |
+void InitializeResourceBufferConstants() { |
+ static bool did_init = false; |
+ if (did_init) |
+ return; |
+ did_init = true; |
+ |
+ GetNumericArg("resource-buffer-max-allocation-size", &g_max_allocation_size); |
+} |
+ |
+} // namespace |
+ |
+class MojoAsyncResourceHandler::SharedWriter final |
mmenke
2016/06/13 20:56:58
This class needs to be documented.
yhirano
2016/07/12 10:49:11
Done.
|
+ : public base::RefCountedThreadSafe<SharedWriter> { |
+ public: |
+ explicit SharedWriter(mojo::ScopedDataPipeProducerHandle writer) |
+ : writer_(std::move(writer)) {} |
+ mojo::DataPipeProducerHandle writer() { return writer_.get(); } |
+ |
+ private: |
+ friend class base::RefCountedThreadSafe<SharedWriter>; |
+ ~SharedWriter() {} |
+ |
+ const mojo::ScopedDataPipeProducerHandle writer_; |
+ |
+ DISALLOW_COPY_AND_ASSIGN(SharedWriter); |
+}; |
+ |
+class MojoAsyncResourceHandler::WriterIOBuffer final |
mmenke
2016/06/13 20:56:58
This class needs to be documented.
yhirano
2016/07/12 10:49:11
Done.
|
+ : public net::IOBufferWithSize { |
+ public: |
+ WriterIOBuffer(scoped_refptr<MojoAsyncResourceHandler::SharedWriter> writer, |
+ void* data, |
+ size_t size) |
+ : net::IOBufferWithSize(static_cast<char*>(data), size), |
+ writer_(std::move(writer)) {} |
+ |
+ private: |
+ ~WriterIOBuffer() override { |
+ // Avoid deleting |data_| in the IOBuffer destructor. |
+ data_ = nullptr; |
+ } |
+ |
+ // This member is for keeping the writer alive. |
+ scoped_refptr<MojoAsyncResourceHandler::SharedWriter> writer_; |
+ |
+ DISALLOW_COPY_AND_ASSIGN(WriterIOBuffer); |
+}; |
+ |
+MojoAsyncResourceHandler::MojoAsyncResourceHandler( |
+ net::URLRequest* request, |
+ ResourceDispatcherHostImpl* rdh, |
+ std::unique_ptr<mojom::URLLoader> url_loader, |
+ mojom::URLLoaderClientPtr url_loader_client) |
+ : ResourceHandler(request), |
+ rdh_(rdh), |
+ url_loader_(std::move(url_loader)), |
+ url_loader_client_(std::move(url_loader_client)) { |
+ DCHECK(url_loader_); |
+ DCHECK(url_loader_client_); |
+ InitializeResourceBufferConstants(); |
+} |
+ |
+MojoAsyncResourceHandler::~MojoAsyncResourceHandler() { |
+ if (has_checked_for_sufficient_resources_) |
+ rdh_->FinishedWithResourcesForRequest(request()); |
+} |
+ |
+bool MojoAsyncResourceHandler::OnRequestRedirected( |
+ const net::RedirectInfo& redirect_info, |
+ ResourceResponse* response, |
+ bool* defer) { |
+ // Not implemented. |
+ return false; |
+} |
+ |
+bool MojoAsyncResourceHandler::OnResponseStarted(ResourceResponse* response, |
+ bool* defer) { |
+ const ResourceRequestInfoImpl* info = GetRequestInfo(); |
+ if (!info->filter()) |
+ return false; |
+ |
+ if (rdh_->delegate()) { |
+ rdh_->delegate()->OnResponseStarted(request(), info->GetContext(), response, |
+ info->filter()); |
+ } |
+ |
+ NetLogObserver::PopulateResponseInfo(request(), response); |
+ |
+ response->head.request_start = request()->creation_time(); |
+ response->head.response_start = base::TimeTicks::Now(); |
+ sent_received_response_message_ = true; |
+ url_loader_client_->OnReceiveResponse(response->head); |
+ return true; |
+} |
+ |
+bool MojoAsyncResourceHandler::OnWillStart(const GURL& url, bool* defer) { |
+ return true; |
+} |
+ |
+bool MojoAsyncResourceHandler::OnBeforeNetworkStart(const GURL& url, |
+ bool* defer) { |
+ return true; |
+} |
+ |
+bool MojoAsyncResourceHandler::OnWillRead(scoped_refptr<net::IOBuffer>* buf, |
+ int* buf_size, |
+ int min_size) { |
+ DCHECK_EQ(-1, min_size); |
+ |
+ if (!CheckForSufficientResource()) |
+ return false; |
+ |
+ if (!shared_writer_) { |
+ MojoCreateDataPipeOptions options; |
+ options.struct_size = sizeof(MojoCreateDataPipeOptions); |
+ options.flags = MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE; |
+ options.element_num_bytes = 1; |
+ options.capacity_num_bytes = g_max_allocation_size; |
+ mojo::DataPipe data_pipe(options); |
+ |
+ ResourceMessageFilter* filter = GetRequestInfo()->filter(); |
+ if (filter) { |
mmenke
2016/06/13 20:56:58
All these filter checks, except possibly the one i
yhirano
2016/07/12 10:49:11
I tried to mimic AsyncResourceHandler's behavior,
mmenke
2016/07/12 15:10:45
My opinion here (And it's certainly something that
|
+ url_loader_client_->OnStartLoadingResponseBody( |
+ std::move(data_pipe.consumer_handle)); |
+ } |
+ if (!data_pipe.producer_handle.is_valid()) |
+ return false; |
+ |
+ shared_writer_ = new SharedWriter(std::move(data_pipe.producer_handle)); |
+ |
+ void* data = nullptr; |
+ uint32_t available = 0; |
+ MojoResult result = mojo::BeginWriteDataRaw( |
+ shared_writer_->writer(), &data, &available, MOJO_WRITE_DATA_FLAG_NONE); |
+ |
+ if (result != MOJO_RESULT_OK && result != MOJO_RESULT_SHOULD_WAIT) |
+ return false; |
+ if (result == MOJO_RESULT_OK && available >= kMinAllocationSize) { |
+ *buf = buffer_ = new WriterIOBuffer(shared_writer_, data, available); |
+ *buf_size = buffer_->size(); |
+ return true; |
+ } |
+ |
+ if (result == MOJO_RESULT_OK) { |
+ // The allocated buffer is too small. |
+ if (mojo::EndWriteDataRaw(shared_writer_->writer(), 0) != MOJO_RESULT_OK) |
+ return false; |
+ } |
+ DCHECK(!is_using_io_buffer_not_from_writer_); |
+ is_using_io_buffer_not_from_writer_ = true; |
+ buffer_ = new net::IOBufferWithSize(kMinAllocationSize); |
+ } |
+ |
+ if (is_using_io_buffer_not_from_writer_) { |
+ DCHECK_EQ(0u, buffer_offset_); |
+ *buf = new net::WrappedIOBuffer(buffer_->data()); |
+ *buf_size = buffer_->size(); |
+ return true; |
+ } |
+ |
+ *buf = buffer_; |
+ *buf_size = buffer_->size(); |
+ return true; |
+} |
+ |
+bool MojoAsyncResourceHandler::OnReadCompleted(int bytes_read, bool* defer) { |
+ DCHECK_GE(bytes_read, 0); |
+ DCHECK(buffer_); |
+ |
+ if (!bytes_read) |
+ return true; |
+ |
+ if (is_using_io_buffer_not_from_writer_) { |
+ // Couldn't allocate a buffer on the data pipe in OnWillRead. |
+ DCHECK(!did_defer_); |
+ DCHECK_EQ(0u, buffer_bytes_read_); |
+ buffer_bytes_read_ = bytes_read; |
+ if (!CopyReadData(defer)) |
+ return false; |
+ if (*defer) { |
+ did_defer_ = true; |
+ OnDefer(); |
+ } |
+ return true; |
+ } |
+ |
+ MojoResult result = |
+ mojo::EndWriteDataRaw(shared_writer_->writer(), bytes_read); |
+ if (result != MOJO_RESULT_OK) |
+ return false; |
+ if (!AllocateBuffer(defer)) |
+ return false; |
+ if (*defer) { |
+ did_defer_ = true; |
+ OnDefer(); |
+ } |
+ return true; |
+} |
+ |
+void MojoAsyncResourceHandler::OnDataDownloaded(int bytes_downloaded) { |
+ // Not implemented. |
+} |
+ |
+void MojoAsyncResourceHandler::SetAllocationSizeForTesting(size_t size) { |
+ g_max_allocation_size = size; |
+} |
+ |
+void MojoAsyncResourceHandler::OnResponseCompleted( |
+ const net::URLRequestStatus& status, |
+ const std::string& security_info, |
+ bool* defer) { |
+ const ResourceRequestInfoImpl* info = GetRequestInfo(); |
+ if (!info->filter()) |
+ return; |
+ |
+ // TODO(gavinp): Remove this CHECK when we figure out the cause of |
+ // http://crbug.com/124680 . This check mirrors closely check in |
+ // WebURLLoaderImpl::OnCompletedRequest that routes this message to a WebCore |
+ // ResourceHandleInternal which asserts on its state and crashes. By crashing |
+ // when the message is sent, we should get better crash reports. |
+ CHECK(status.status() != net::URLRequestStatus::SUCCESS || |
+ sent_received_response_message_); |
+ |
+ int error_code = status.error(); |
+ bool was_ignored_by_handler = info->WasIgnoredByHandler(); |
+ |
+ DCHECK(status.status() != net::URLRequestStatus::IO_PENDING); |
+ // If this check fails, then we're in an inconsistent state because all |
+ // requests ignored by the handler should be canceled (which should result in |
+ // the ERR_ABORTED error code). |
+ DCHECK(!was_ignored_by_handler || error_code == net::ERR_ABORTED); |
+ |
+ // TODO(mkosiba): Fix up cases where we create a URLRequestStatus |
+ // with a status() != SUCCESS and an error_code() == net::OK. |
+ if (status.status() == net::URLRequestStatus::CANCELED && |
+ error_code == net::OK) { |
+ error_code = net::ERR_ABORTED; |
+ } else if (status.status() == net::URLRequestStatus::FAILED && |
+ error_code == net::OK) { |
+ error_code = net::ERR_FAILED; |
+ } |
+ |
+ ResourceRequestCompletionStatus request_complete_data; |
+ request_complete_data.error_code = error_code; |
+ request_complete_data.was_ignored_by_handler = was_ignored_by_handler; |
+ request_complete_data.exists_in_cache = request()->response_info().was_cached; |
+ request_complete_data.security_info = security_info; |
+ request_complete_data.completion_time = base::TimeTicks::Now(); |
+ request_complete_data.encoded_data_length = |
+ request()->GetTotalReceivedBytes(); |
+ |
+ url_loader_client_->OnComplete(request_complete_data); |
+} |
+ |
+bool MojoAsyncResourceHandler::CopyReadData(bool* defer) { |
+ while (true) { |
+ void* data = nullptr; |
+ uint32_t available = 0; |
+ MojoResult result = mojo::BeginWriteDataRaw( |
+ shared_writer_->writer(), &data, &available, MOJO_WRITE_DATA_FLAG_NONE); |
+ if (result == MOJO_RESULT_SHOULD_WAIT) { |
+ *defer = true; |
+ return true; |
+ } |
+ if (result != MOJO_RESULT_OK) |
+ return false; |
+ |
+ if (buffer_bytes_read_ == 0) { |
+ buffer_ = new WriterIOBuffer(shared_writer_, data, available); |
+ return true; |
+ } |
+ |
+ size_t copied_size = |
+ std::min(static_cast<uint32_t>(buffer_bytes_read_), available); |
+ memcpy(data, buffer_->data() + buffer_offset_, copied_size); |
+ buffer_offset_ += copied_size; |
+ buffer_bytes_read_ -= copied_size; |
+ result = mojo::EndWriteDataRaw(shared_writer_->writer(), copied_size); |
+ if (result != MOJO_RESULT_OK) |
+ return false; |
+ if (buffer_bytes_read_ == 0) { |
mmenke
2016/06/13 20:56:58
I think it's clearer (And less code) if you move t
yhirano
2016/07/12 10:49:11
Sorry I don't understand. Do you mean "the start o
mmenke
2016/07/12 15:10:45
Yes
yhirano
2016/07/13 12:04:57
Done.
|
+ // All bytes are copied. |
+ buffer_offset_ = 0; |
+ is_using_io_buffer_not_from_writer_ = false; |
+ } |
+ } |
+ NOTREACHED(); |
+ return false; |
mmenke
2016/06/13 20:56:58
There's no break in the loop. These two lines sho
yhirano
2016/07/12 10:49:11
Done.
|
+} |
+ |
+bool MojoAsyncResourceHandler::AllocateBuffer(bool* defer) { |
+ void* data = nullptr; |
+ uint32_t available = 0; |
+ MojoResult result = mojo::BeginWriteDataRaw( |
+ shared_writer_->writer(), &data, &available, MOJO_WRITE_DATA_FLAG_NONE); |
+ if (result == MOJO_RESULT_SHOULD_WAIT) { |
+ *defer = true; |
+ return true; |
+ } |
+ if (result != MOJO_RESULT_OK) |
+ return false; |
+ buffer_ = new WriterIOBuffer(shared_writer_, data, available); |
+ return true; |
+} |
+ |
+void MojoAsyncResourceHandler::ResumeIfDeferred() { |
+ if (did_defer_) { |
mmenke
2016/06/13 20:56:58
Can this ever be called if did_defer_ is false?
yhirano
2016/07/12 10:49:11
Currently not.
|
+ // did_defer_ is set only in OnReadCompleted (and here). |
+ did_defer_ = false; |
+ if (is_using_io_buffer_not_from_writer_) { |
+ DCHECK_GT(buffer_bytes_read_, 0u); |
+ if (!CopyReadData(&did_defer_)) { |
+ controller()->CancelWithError(net::ERR_FAILED); |
+ return; |
+ } |
+ } else { |
+ if (!AllocateBuffer(&did_defer_)) { |
+ controller()->CancelWithError(net::ERR_FAILED); |
+ return; |
+ } |
+ } |
+ if (did_defer_) { |
+ // Continue waiting. |
+ handle_watcher_.Start(shared_writer_->writer(), |
+ MOJO_HANDLE_SIGNAL_WRITABLE, |
+ MOJO_DEADLINE_INDEFINITE, |
+ base::Bind(&MojoAsyncResourceHandler::OnWritable, |
+ base::Unretained(this))); |
+ return; |
+ } |
+ request()->LogUnblocked(); |
+ controller()->Resume(); |
+ } |
+} |
+ |
+void MojoAsyncResourceHandler::OnDefer() { |
+ request()->LogBlockedBy("MojoAsyncResourceHandler"); |
+ handle_watcher_.Start(shared_writer_->writer(), MOJO_HANDLE_SIGNAL_WRITABLE, |
+ MOJO_DEADLINE_INDEFINITE, |
+ base::Bind(&MojoAsyncResourceHandler::OnWritable, |
+ base::Unretained(this))); |
+} |
+ |
+bool MojoAsyncResourceHandler::CheckForSufficientResource() { |
+ if (has_checked_for_sufficient_resources_) |
+ return true; |
+ has_checked_for_sufficient_resources_ = true; |
+ |
+ if (rdh_->HasSufficientResourcesForRequest(request())) |
+ return true; |
+ |
+ controller()->CancelWithError(net::ERR_INSUFFICIENT_RESOURCES); |
+ return false; |
+} |
+ |
+void MojoAsyncResourceHandler::OnWritable(MojoResult unused) { |
+ ResumeIfDeferred(); |
+} |
+ |
+} // namespace content |