DevTools protocol interception, blocking & modification of requests

content/browser/devtools/devtools_url_interceptor_request_job.cc

+// 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 this should probably be a
weak pointer.

[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 like in the other cases?

[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
DevToolsURLInterceptorRequestJob::OnReceivedRedirect and we'd be taking the
address of a temporary.

+  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 Iris's SSL error handling patch
(https://codereview.chromium.org/2639203003)? Does the client also see these
errors there?

+    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 helper for that somewhere.

[alex clarke (OOO till 29th), 2017/03/23 12:25:10]

Seems pointless adding it because net::HttpResponseHeaders mostly ignores it.

[Sami, 2017/03/24 10:53:51]

Okay, but maybe add a short comment about it since we're not following the spec
here.

+    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 request instead of creating a new
subrequest?

[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 way to keep this as a stream?
Maybe add a TODO?

[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 be used in Chromium, but
no-one is using the new alternative yet :P

https://cs.chromium.org/chromium/src/net/url_request/url_request_context.h?rc...

[alex clarke (OOO till 29th), 2017/03/23 12:25:10]

Yeah I noticed that.  I've no idea what to put in NetworkTrafficAnnotationTag.

+      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 termination

[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