Index: content/browser/devtools/devtools_url_interceptor_request_job.cc |
diff --git a/content/browser/devtools/devtools_url_interceptor_request_job.cc b/content/browser/devtools/devtools_url_interceptor_request_job.cc |
new file mode 100644 |
index 0000000000000000000000000000000000000000..7a3d68cffa2c2cb4f4ace1d7992865ec7d46f271 |
--- /dev/null |
+++ b/content/browser/devtools/devtools_url_interceptor_request_job.cc |
@@ -0,0 +1,542 @@ |
+// Copyright 2017 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/devtools/devtools_url_interceptor_request_job.h" |
+ |
+#include "base/memory/ptr_util.h" |
+#include "base/strings/stringprintf.h" |
+#include "content/browser/devtools/protocol/network_handler.h" |
+#include "net/base/elements_upload_data_stream.h" |
+#include "net/base/io_buffer.h" |
+#include "net/base/upload_bytes_element_reader.h" |
+#include "net/cert/cert_status_flags.h" |
+#include "net/http/http_response_headers.h" |
+#include "net/http/http_util.h" |
+#include "net/url_request/url_request_context.h" |
+ |
+namespace content { |
+namespace { |
+// Keep in sync with X_DevTools_Intercept_Id defined in HTTPNames.json5. |
+const char kDevToolsInterceptId[] = "X-Devtools-Intercept-Id"; |
+} |
+ |
+DevToolsURLInterceptorRequestJob::DevToolsURLInterceptorRequestJob( |
+ base::WeakPtr<DevToolsURLRequestInterceptor::State> interceptor_state, |
+ const std::string& intercept_id, |
+ net::URLRequest* origional_request, |
+ net::NetworkDelegate* origional_network_delegate, |
+ protocol::NetworkHandler* network_handler, |
+ bool is_redirect) |
+ : net::URLRequestJob(origional_request, origional_network_delegate), |
Sami
2017/03/22 17:00:44
typo: original (2x)
alex clarke (OOO till 29th)
2017/03/23 12:25:11
Done.
|
+ io_thread_only_(origional_request), |
+ intercept_id_(intercept_id), |
+ network_handler_(network_handler), |
+ interceptor_state_(interceptor_state), |
+ io_thread_task_runner_( |
+ BrowserThread::GetTaskRunnerForThread(BrowserThread::IO)), |
+ is_redirect_(is_redirect) { |
+ DCHECK_CURRENTLY_ON(BrowserThread::IO); |
+ network_handler_->RegisterURLInterceptor(intercept_id_, this); |
+} |
+ |
+DevToolsURLInterceptorRequestJob::~DevToolsURLInterceptorRequestJob() { |
+ DCHECK_CURRENTLY_ON(BrowserThread::IO); |
+ if (network_handler_) |
+ network_handler_->UnregisterURLInterceptor(intercept_id_, this); |
+} |
+ |
+void DevToolsURLInterceptorRequestJob::OnNetworkHandlerDeleted() { |
+ network_handler_ = nullptr; |
+} |
+ |
+// net::URLRequestJob implementation: |
+void DevToolsURLInterceptorRequestJob::SetExtraRequestHeaders( |
+ const net::HttpRequestHeaders& headers) { |
+ io_thread_only().request_details.extra_request_headers = headers; |
+} |
+ |
+void DevToolsURLInterceptorRequestJob::Start() { |
+ DCHECK_CURRENTLY_ON(BrowserThread::IO); |
+ if (is_redirect_) { |
+ io_thread_only().sub_request.reset(new SubRequest( |
+ io_thread_only().request_details, interceptor_state_, this)); |
+ } else { |
+ BrowserThread::PostTask( |
+ BrowserThread::UI, FROM_HERE, |
+ base::Bind(&DevToolsURLInterceptorRequestJob:: |
+ SendInterceptedRequestEventOnUiThread, |
+ base::Unretained(this))); |
Sami
2017/03/22 17:00:45
The job is owned by net/ on the network thread, so
alex clarke (OOO till 29th)
2017/03/23 12:25:10
Done.
|
+ } |
+} |
+ |
+void DevToolsURLInterceptorRequestJob::SendInterceptedRequestEventOnUiThread() { |
+ DCHECK_CURRENTLY_ON(BrowserThread::UI); |
+ ui_thread_only().waiting_for_user_response = true; |
+ if (network_handler_) { |
+ network_handler_->frontend()->InterceptedRequest( |
+ intercept_id_, |
+ protocol::NetworkHandler::CreateRequestFromURLRequest(request())); |
+ } |
+} |
+ |
+void DevToolsURLInterceptorRequestJob::Kill() { |
+ if (io_thread_only().sub_request) |
+ io_thread_only().sub_request->Cancel(); |
+ |
+ URLRequestJob::Kill(); |
+} |
+ |
+int DevToolsURLInterceptorRequestJob::ReadRawData(net::IOBuffer* buf, |
+ int buf_size) { |
+ if (io_thread_only().sub_request) { |
+ int size = io_thread_only().sub_request->request()->Read(buf, buf_size); |
+ return size; |
+ } else { |
+ CHECK(io_thread_only().mock_response); |
+ return io_thread_only().mock_response->ReadRawData(buf, buf_size); |
+ } |
+} |
+ |
+int DevToolsURLInterceptorRequestJob::GetResponseCode() const { |
+ if (io_thread_only().sub_request) { |
+ return io_thread_only().sub_request->request()->GetResponseCode(); |
+ } else { |
+ CHECK(io_thread_only().mock_response); |
+ return io_thread_only().mock_response->response_headers()->response_code(); |
+ } |
+} |
+ |
+void DevToolsURLInterceptorRequestJob::GetResponseInfo( |
+ net::HttpResponseInfo* info) { |
+ if (io_thread_only().sub_request) { |
+ *info = io_thread_only().sub_request->request()->response_info(); |
+ } else if (io_thread_only().mock_response) { |
Sami
2017/03/22 17:00:45
Can we CHECK that the mock response exists here li
alex clarke (OOO till 29th)
2017/03/23 12:25:10
Done.
|
+ info->headers = io_thread_only().mock_response->response_headers().get(); |
+ } |
+} |
+ |
+const net::HttpResponseHeaders* |
+DevToolsURLInterceptorRequestJob::GetHttpResponseHeaders() const { |
+ if (io_thread_only().sub_request) { |
+ net::URLRequest* request = io_thread_only().sub_request->request(); |
+ return request->response_info().headers.get(); |
+ } |
+ CHECK(io_thread_only().mock_response); |
+ return io_thread_only().mock_response->response_headers().get(); |
+} |
+ |
+bool DevToolsURLInterceptorRequestJob::GetMimeType( |
+ std::string* mime_type) const { |
+ const net::HttpResponseHeaders* response_headers = GetHttpResponseHeaders(); |
+ if (!response_headers) |
+ return false; |
+ return response_headers->GetMimeType(mime_type); |
+} |
+ |
+bool DevToolsURLInterceptorRequestJob::GetCharset(std::string* charset) { |
+ const net::HttpResponseHeaders* response_headers = GetHttpResponseHeaders(); |
+ if (!response_headers) |
+ return false; |
+ return response_headers->GetCharset(charset); |
+} |
+ |
+void DevToolsURLInterceptorRequestJob::GetLoadTimingInfo( |
+ net::LoadTimingInfo* load_timing_info) const { |
+ if (io_thread_only().sub_request) { |
+ io_thread_only().sub_request->request()->GetLoadTimingInfo( |
+ load_timing_info); |
+ } else { |
+ CHECK(io_thread_only().mock_response); |
+ // TODO(alexclarke): Investigate setting the other members too where |
+ // possible. |
+ load_timing_info->receive_headers_end = |
+ io_thread_only().mock_response->response_time(); |
+ } |
+} |
+ |
+void DevToolsURLInterceptorRequestJob::OnAuthRequired( |
+ net::URLRequest* request, |
+ net::AuthChallengeInfo* auth_info) { |
+ DCHECK(io_thread_only().sub_request); |
+ DCHECK_EQ(request, io_thread_only().sub_request->request()); |
+ LOG(WARNING) << "Auth required to fetch URL, aborting."; |
Sami
2017/03/22 17:00:45
TODO to implement this?
|
+ request->CancelAuth(); |
+ DispatchError(net::ERR_NOT_IMPLEMENTED); |
+} |
+ |
+void DevToolsURLInterceptorRequestJob::OnResponseStarted( |
+ net::URLRequest* request, |
+ int net_error) { |
+ DCHECK_CURRENTLY_ON(BrowserThread::IO); |
+ DCHECK(io_thread_only().sub_request); |
+ DCHECK_EQ(request, io_thread_only().sub_request->request()); |
+ DCHECK_NE(net::ERR_IO_PENDING, net_error); |
+ |
+ if (net_error != net::OK) { |
+ io_thread_only().sub_request->Cancel(); |
+ DispatchError(static_cast<net::Error>(net_error)); |
+ return; |
+ } |
+ |
+ request->response_info().headers->RemoveHeader(kDevToolsInterceptId); |
+ request->response_info().headers->AddHeader(base::StringPrintf( |
+ "%s: %s", kDevToolsInterceptId, intercept_id_.c_str())); |
+ |
+ NotifyHeadersComplete(); |
+} |
+ |
+void DevToolsURLInterceptorRequestJob::OnReadCompleted(net::URLRequest* request, |
+ int num_bytes) { |
+ DCHECK_CURRENTLY_ON(BrowserThread::IO); |
+ DCHECK_EQ(request, io_thread_only().sub_request->request()); |
+ |
+ ReadRawDataComplete(num_bytes); |
+} |
+ |
+void DevToolsURLInterceptorRequestJob::OnReceivedRedirect( |
+ net::URLRequest* request, |
+ const net::RedirectInfo& redirectinfo, |
+ bool* defer_redirect) { |
+ DCHECK_CURRENTLY_ON(BrowserThread::IO); |
+ *defer_redirect = true; |
+ |
+ size_t iter = 0; |
+ std::string header_name; |
+ std::string header_value; |
+ std::unique_ptr<protocol::DictionaryValue> headers_dict( |
+ protocol::DictionaryValue::create()); |
+ while (request->response_headers()->EnumerateHeaderLines(&iter, &header_name, |
+ &header_value)) { |
+ headers_dict->setString(header_name, header_value); |
+ } |
+ |
+ io_thread_only().redirect.reset(new net::RedirectInfo(redirectinfo)); |
+ io_thread_only().sub_request->Cancel(); |
+ io_thread_only().sub_request.reset(); |
+ |
+ BrowserThread::PostTask( |
+ BrowserThread::UI, FROM_HERE, |
+ base::Bind(&DevToolsURLInterceptorRequestJob:: |
+ SendInterceptedRedirectEventOnUiThread, |
+ base::Unretained(this), base::Owned(headers_dict.release()), |
Sami
2017/03/22 17:00:45
Ditto about WeakPtr.
alex clarke (OOO till 29th)
2017/03/23 12:25:10
Done.
|
+ redirectinfo.status_code, redirectinfo.new_url.spec())); |
+} |
+ |
+void DevToolsURLInterceptorRequestJob::SendInterceptedRedirectEventOnUiThread( |
+ protocol::DictionaryValue* headers_dict, |
+ int http_status_code, |
+ std::string redirecturl) { |
Sami
2017/03/22 17:00:45
nit: const ref, redirect_url
alex clarke (OOO till 29th)
2017/03/23 12:25:11
It can't be a const ref because this is posted by
|
+ DCHECK_CURRENTLY_ON(BrowserThread::UI); |
+ ui_thread_only().waiting_for_user_response = true; |
+ |
+ return network_handler_->frontend()->InterceptedRedirect( |
+ intercept_id_, protocol::Object::fromValue(headers_dict, nullptr), |
+ http_status_code, redirecturl); |
+} |
+ |
+void DevToolsURLInterceptorRequestJob::OnSSLCertificateError( |
Sami
2017/03/22 17:00:45
I'm trying to work out if this integrates with Iri
|
+ net::URLRequest* request, |
+ const net::SSLInfo& ssl_info, |
+ bool fatal) { |
+ DCHECK_CURRENTLY_ON(BrowserThread::IO); |
+ DCHECK(io_thread_only().sub_request); |
+ DCHECK_EQ(request, io_thread_only().sub_request->request()); |
+ |
+ // Revocation check failures are not fatal. |
+ if (net::IsCertStatusMinorError(ssl_info.cert_status)) { |
+ request->ContinueDespiteLastError(); |
+ return; |
+ } |
+ LOG(WARNING) << "SSL certificate error, aborting."; |
+ |
+ // Certificate errors are in same space as net errors. |
+ io_thread_only().sub_request->Cancel(); |
+ DispatchError(static_cast<net::Error>( |
+ net::MapCertStatusToNetError(ssl_info.cert_status))); |
+} |
+ |
+bool DevToolsURLInterceptorRequestJob::OnAllow() { |
+ DCHECK_CURRENTLY_ON(BrowserThread::UI); |
+ if (!ui_thread_only().waiting_for_user_response) |
+ return false; |
+ ui_thread_only().waiting_for_user_response = false; |
+ io_thread_task_runner_->PostTask( |
+ FROM_HERE, |
+ base::Bind(&DevToolsURLInterceptorRequestJob::ProcessOnAllowOnIoThread, |
+ base::Unretained(this))); |
+ return true; |
+} |
+ |
+void DevToolsURLInterceptorRequestJob::ProcessOnAllowOnIoThread() { |
+ DCHECK_CURRENTLY_ON(BrowserThread::IO); |
+ if (io_thread_only().redirect) { |
+ std::string raw_headers = base::StringPrintf( |
+ "HTTP/1.1 %d", io_thread_only().redirect->status_code); |
Sami
2017/03/22 17:00:44
Missing the reason-phrase -- I'm sure there's a he
alex clarke (OOO till 29th)
2017/03/23 12:25:10
Seems pointless adding it because net::HttpRespons
Sami
2017/03/24 10:53:51
Okay, but maybe add a short comment about it since
|
+ raw_headers.append(1, '\0'); |
+ raw_headers.append("Location: "); |
+ raw_headers.append(io_thread_only().redirect->new_url.spec()); |
+ raw_headers.append(2, '\0'); |
+ io_thread_only().mock_response.reset(new MockResponse( |
+ make_scoped_refptr(new net::HttpResponseHeaders(raw_headers)), "", 0, |
+ base::TimeTicks::Now())); |
+ io_thread_only().redirect.reset(); |
+ interceptor_state_->ExpectRequestAfterRedirect(request(), intercept_id_); |
+ NotifyHeadersComplete(); |
+ } else { |
+ io_thread_only().sub_request.reset(new SubRequest( |
Sami
2017/03/22 17:00:45
Dumb question: Why can't we reuse the original req
alex clarke (OOO till 29th)
2017/03/23 12:25:10
I added a comment where I try to explain.
|
+ io_thread_only().request_details, interceptor_state_, this)); |
+ } |
+} |
+ |
+bool DevToolsURLInterceptorRequestJob::OnBlock(net::Error error_reason) { |
+ DCHECK_CURRENTLY_ON(BrowserThread::UI); |
+ if (!ui_thread_only().waiting_for_user_response) |
+ return false; |
+ ui_thread_only().waiting_for_user_response = false; |
+ DispatchError(error_reason); |
+ return true; |
+} |
+ |
+bool DevToolsURLInterceptorRequestJob::OnModifyRequest( |
+ protocol::Maybe<protocol::String> url, |
+ protocol::Maybe<protocol::String> method, |
+ protocol::Maybe<protocol::String> post_data, |
+ protocol::Maybe<protocol::Network::Headers> headers) { |
+ DCHECK_CURRENTLY_ON(BrowserThread::UI); |
+ if (!ui_thread_only().waiting_for_user_response) |
+ return false; |
+ ui_thread_only().waiting_for_user_response = false; |
+ io_thread_task_runner_->PostTask( |
+ FROM_HERE, |
+ base::Bind(&DevToolsURLInterceptorRequestJob::ModifyRequestOnIoThread, |
+ base::Unretained(this), |
Sami
2017/03/22 17:00:44
Ditto for WeakPtr
alex clarke (OOO till 29th)
2017/03/23 12:25:10
Done.
|
+ base::Passed(base::MakeUnique<ModifyRequest>( |
+ std::move(url), std::move(method), std::move(post_data), |
+ std::move(headers))))); |
+ return true; |
+} |
+ |
+void DevToolsURLInterceptorRequestJob::ModifyRequestOnIoThread( |
+ std::unique_ptr<ModifyRequest> modify_request) { |
+ DCHECK_CURRENTLY_ON(BrowserThread::IO); |
+ |
+ // Note this redirect is not visible to the caller by design. If they want a |
+ // visible redirect they can mock a response with a 302. |
+ if (modify_request->url.isJust()) |
+ io_thread_only().request_details.url = GURL(modify_request->url.fromJust()); |
+ |
+ if (modify_request->method.isJust()) |
+ io_thread_only().request_details.method = modify_request->method.fromJust(); |
+ |
+ if (modify_request->post_data.isJust()) |
Sami
2017/03/22 17:00:45
nit: {}
alex clarke (OOO till 29th)
2017/03/23 12:25:10
Done.
|
+ io_thread_only().request_details.post_data = |
+ modify_request->post_data.fromJust(); |
+ |
+ if (modify_request->headers.isJust()) { |
+ io_thread_only().request_details.extra_request_headers.Clear(); |
+ std::unique_ptr<protocol::DictionaryValue> headers = |
+ modify_request->headers.fromJust()->toValue(); |
+ for (size_t i = 0; i < headers->size(); i++) { |
+ protocol::String value; |
+ if (headers->at(i).second->asString(&value)) { |
+ io_thread_only().request_details.extra_request_headers.SetHeader( |
+ headers->at(i).first, value); |
+ } |
+ } |
+ } |
+ |
+ io_thread_only().sub_request.reset(new SubRequest( |
+ io_thread_only().request_details, interceptor_state_, this)); |
+} |
+ |
+bool DevToolsURLInterceptorRequestJob::OnMockResponse( |
+ const protocol::String& raw_response) { |
+ DCHECK_CURRENTLY_ON(BrowserThread::UI); |
+ if (!ui_thread_only().waiting_for_user_response) |
+ return false; |
+ ui_thread_only().waiting_for_user_response = false; |
+ io_thread_task_runner_->PostTask( |
+ FROM_HERE, |
+ base::Bind( |
+ &DevToolsURLInterceptorRequestJob::ProcessMockResponeOnIoThread, |
Sami
2017/03/22 17:00:45
typo: response
alex clarke (OOO till 29th)
2017/03/23 12:25:10
Done.
|
+ base::Unretained(this), raw_response)); |
+ return true; |
+} |
+ |
+void DevToolsURLInterceptorRequestJob::ProcessMockResponeOnIoThread( |
+ protocol::String raw_response) { |
+ DCHECK_CURRENTLY_ON(BrowserThread::IO); |
+ io_thread_only().mock_response.reset(new MockResponse( |
+ std::move(raw_response), base::TimeTicks::Now(), intercept_id_)); |
+ |
+ std::string value; |
+ if (io_thread_only().mock_response->response_headers()->IsRedirect(&value)) |
+ interceptor_state_->ExpectRequestAfterRedirect(request(), intercept_id_); |
+ |
+ NotifyHeadersComplete(); |
+} |
+ |
+void DevToolsURLInterceptorRequestJob::DispatchError(net::Error reason) { |
+ DCHECK_NE(reason, net::OK); |
+ io_thread_task_runner_->PostTask( |
+ FROM_HERE, |
+ base::Bind(&DevToolsURLInterceptorRequestJob::NotifyStartError, |
+ base::Unretained(this), |
+ net::URLRequestStatus(net::URLRequestStatus::FAILED, reason))); |
+} |
+ |
+namespace { |
+std::string GetUploadData(net::URLRequest* request) { |
+ if (!request->has_upload()) |
+ return ""; |
+ |
+ const net::UploadDataStream* stream = request->get_upload(); |
+ if (!stream->GetElementReaders()) |
+ return ""; |
+ |
+ DCHECK_EQ(1u, stream->GetElementReaders()->size()); |
+ const net::UploadBytesElementReader* reader = |
+ (*stream->GetElementReaders())[0]->AsBytesReader(); |
+ return std::string(reader->bytes(), reader->length()); |
Sami
2017/03/22 17:00:45
This could be several GB. I wonder if there's a wa
alex clarke (OOO till 29th)
2017/03/23 12:25:10
Done.
|
+} |
+} // namespace |
+ |
+DevToolsURLInterceptorRequestJob::IoThreadOnly::IoThreadOnly( |
+ net::URLRequest* request) |
+ : request_details(request->url(), |
+ request->method(), |
+ GetUploadData(request), |
+ request->extra_request_headers(), |
+ request->priority(), |
+ request->context()) {} |
+ |
+DevToolsURLInterceptorRequestJob::IoThreadOnly::~IoThreadOnly() {} |
+ |
+DevToolsURLInterceptorRequestJob::UiThreadOnly::UiThreadOnly() |
+ : waiting_for_user_response(false) {} |
+ |
+DevToolsURLInterceptorRequestJob::ModifyRequest::ModifyRequest( |
+ protocol::Maybe<protocol::String> url, |
+ protocol::Maybe<protocol::String> method, |
+ protocol::Maybe<protocol::String> post_data, |
+ protocol::Maybe<protocol::Network::Headers> headers) |
+ : url(std::move(url)), |
+ method(std::move(method)), |
+ post_data(std::move(post_data)), |
+ headers(std::move(headers)) {} |
+ |
+DevToolsURLInterceptorRequestJob::ModifyRequest::~ModifyRequest() {} |
+ |
+DevToolsURLInterceptorRequestJob::RequestDetails::RequestDetails( |
+ const GURL& url, |
+ const std::string& method, |
+ const std::string& post_data, |
+ const net::HttpRequestHeaders& extra_request_headers, |
+ const net::RequestPriority& priority, |
+ const net::URLRequestContext* url_request_context) |
+ : url(url), |
+ method(method), |
+ post_data(post_data), |
+ extra_request_headers(extra_request_headers), |
+ priority(priority), |
+ url_request_context(url_request_context) {} |
+ |
+DevToolsURLInterceptorRequestJob::RequestDetails::~RequestDetails() {} |
+ |
+DevToolsURLInterceptorRequestJob::SubRequest::SubRequest( |
+ const DevToolsURLInterceptorRequestJob::RequestDetails& request_details, |
+ base::WeakPtr<DevToolsURLRequestInterceptor::State> interceptor_state, |
+ DevToolsURLInterceptorRequestJob* devtools_interceptor_request_job) |
+ : buf_(new net::IOBuffer(kBufSize)), |
+ interceptor_state_(interceptor_state), |
+ devtools_interceptor_request_job_(devtools_interceptor_request_job), |
+ fetch_in_progress_(true) { |
+ DCHECK_CURRENTLY_ON(BrowserThread::IO); |
+ request_ = request_details.url_request_context->CreateRequest( |
Sami
2017/03/22 17:00:45
FWIW this method has a comment saying it shouldn't
alex clarke (OOO till 29th)
2017/03/23 12:25:10
Yeah I noticed that. I've no idea what to put in
|
+ request_details.url, request_details.priority, |
+ devtools_interceptor_request_job_), |
+ request_->set_method(request_details.method); |
+ request_->SetExtraRequestHeaders(request_details.extra_request_headers); |
+ |
+ if (!request_details.post_data.empty()) { |
+ std::unique_ptr<net::UploadElementReader> reader( |
+ new net::UploadBytesElementReader(request_details.post_data.data(), |
+ request_details.post_data.size())); |
+ request_->set_upload( |
+ net::ElementsUploadDataStream::CreateWithReader(std::move(reader), 0)); |
+ } |
+ |
+ DCHECK(interceptor_state); |
+ interceptor_state->RegisterSubRequest(request_.get()); |
+ request_->Start(); |
+} |
+ |
+DevToolsURLInterceptorRequestJob::SubRequest::~SubRequest() { |
+ DCHECK_CURRENTLY_ON(BrowserThread::IO); |
+ if (interceptor_state_) |
+ interceptor_state_->UnregisterSubRequest(request_.get()); |
+} |
+ |
+void DevToolsURLInterceptorRequestJob::SubRequest::Cancel() { |
+ DCHECK_CURRENTLY_ON(BrowserThread::IO); |
+ if (!fetch_in_progress_) |
+ return; |
+ |
+ fetch_in_progress_ = false; |
+ request_->Cancel(); |
+} |
+ |
+DevToolsURLInterceptorRequestJob::MockResponse::MockResponse( |
+ std::string response_bytes, |
+ base::TimeTicks response_time, |
+ const std::string& intercept_id) |
+ : response_bytes_(std::move(response_bytes)), |
+ read_offset_(0), |
+ response_time_(response_time) { |
+ int header_size = net::HttpUtil::LocateEndOfHeaders(response_bytes_.c_str(), |
+ response_bytes_.size()); |
+ if (header_size == -1) { |
+ LOG(WARNING) << "Can't find headers in result"; |
+ response_headers_ = new net::HttpResponseHeaders(""); |
+ } else { |
+ response_headers_ = |
+ new net::HttpResponseHeaders(net::HttpUtil::AssembleRawHeaders( |
+ response_bytes_.c_str(), header_size)); |
+ read_offset_ = header_size; |
+ } |
+ |
+ response_headers_->RemoveHeader(kDevToolsInterceptId); |
+ response_headers_->AddHeader( |
+ base::StringPrintf("%s: %s", kDevToolsInterceptId, intercept_id.c_str())); |
+ |
+ CHECK_LE(read_offset_, response_bytes_.size()); |
+} |
+ |
+DevToolsURLInterceptorRequestJob::MockResponse::MockResponse( |
+ const scoped_refptr<net::HttpResponseHeaders>& response_headers, |
+ std::string response_bytes, |
+ size_t read_offset, |
+ base::TimeTicks response_time) |
+ : response_headers_(response_headers), |
+ response_bytes_(std::move(response_bytes)), |
+ read_offset_(read_offset), |
+ response_time_(response_time) {} |
+ |
+DevToolsURLInterceptorRequestJob::MockResponse::~MockResponse() {} |
+ |
+int DevToolsURLInterceptorRequestJob::MockResponse::ReadRawData( |
+ net::IOBuffer* buf, |
+ int buf_size) { |
+ size_t bytes_available = response_bytes_.size() - read_offset_; |
+ size_t bytes_to_copy = |
+ std::min(static_cast<size_t>(buf_size), bytes_available); |
+ if (bytes_to_copy > 0) { |
+ std::memcpy(buf->data(), &response_bytes_.c_str()[read_offset_], |
Sami
2017/03/22 17:00:45
c_str() -> data() since this doesn't need null ter
alex clarke (OOO till 29th)
2017/03/23 12:25:10
Done.
|
+ bytes_to_copy); |
+ read_offset_ += bytes_to_copy; |
+ } |
+ return bytes_to_copy; |
+} |
+ |
+} // namespace content |