Add Network.setSendRequestIdHeader and use it in headless

headless/public/util/generic_url_request_job.cc

 // 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 "headless/public/util/generic_url_request_job.h"
 
 #include <string.h>
 #include <algorithm>
 
 #include "base/logging.h"
 #include "headless/public/util/url_request_dispatcher.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "net/cookies/cookie_store.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request_context.h"
 
 namespace headless {
 namespace {
 
 // True if the request method is "safe" (per section 4.2.1 of RFC 7231).
 bool IsMethodSafe(const std::string& method) {
   return method == "GET" || method == "HEAD" || method == "OPTIONS" ||
          method == "TRACE";
 }
 
+// Keep in sync with X_DevTools_Emulate_Network_Conditions_Client_Id defined in

[Sami, 2017/02/27 12:39:07]

Comment talks about a different header.

[alex clarke (OOO till 29th), 2017/02/27 13:51:16]

Done.

+// HTTPNames.in.
+const char kDevtoolsRequestId[] = "X-DevTools-Request-Id";
+
 }  // namespace
 
 GenericURLRequestJob::GenericURLRequestJob(
     net::URLRequest* request,
     net::NetworkDelegate* network_delegate,
     URLRequestDispatcher* url_request_dispatcher,
     std::unique_ptr<URLFetcher> url_fetcher,
     Delegate* delegate)
     : ManagedDispatchURLRequestJob(request,
                                    network_delegate,
                                    url_request_dispatcher),
       url_fetcher_(std::move(url_fetcher)),
       delegate_(delegate),
       weak_factory_(this) {}
 
 GenericURLRequestJob::~GenericURLRequestJob() = default;
 
 void GenericURLRequestJob::SetExtraRequestHeaders(
     const net::HttpRequestHeaders& headers) {
   extra_request_headers_ = headers;
+
+  if (extra_request_headers_.GetHeader(kDevtoolsRequestId,
+                                       &devtools_request_id_)) {
+    extra_request_headers_.RemoveHeader(kDevtoolsRequestId);
+  }
 }
 
 void GenericURLRequestJob::Start() {
   auto callback = [this](RewriteResult result, const GURL& url,
                          const std::string& method) {
     switch (result) {
       case RewriteResult::kAllow:
         // Note that we use the rewritten url for selecting cookies.
         // Also, rewriting does not affect the request initiator.
         PrepareCookies(url, method, url::Origin(url));
         break;
       case RewriteResult::kDeny:
         DispatchStartError(net::ERR_FILE_NOT_FOUND);
         break;
       case RewriteResult::kFailure:
         DispatchStartError(net::ERR_UNEXPECTED);
         break;
       default:
         DCHECK(false);
     }
   };
 
-  if (!delegate_->BlockOrRewriteRequest(request_->url(), request_->method(),
+  if (!delegate_->BlockOrRewriteRequest(request_->url(), devtools_request_id_,
+                                        request_->method(),
                                         request_->referrer(), callback)) {
     PrepareCookies(request_->url(), request_->method(),
                    url::Origin(request_->first_party_for_cookies()));
   }
 }
 
 void GenericURLRequestJob::PrepareCookies(const GURL& rewritten_url,
                                           const std::string& method,
                                           const url::Origin& site_for_cookies) {
   net::CookieStore* cookie_store = request_->context()->cookie_store();
@@ skipping 30 matching lines @@
   // Pass cookies, the referrer and any extra headers into the fetch request.
   extra_request_headers_.SetHeader(
       net::HttpRequestHeaders::kCookie,
       net::CookieStore::BuildCookieLine(cookie_list));
 
   extra_request_headers_.SetHeader(net::HttpRequestHeaders::kReferer,
                                    request_->referrer());
 
   // The resource may have been supplied in the request.
   const HttpResponse* matched_resource = delegate_->MaybeMatchResource(
-      rewritten_url, method, extra_request_headers_);
+      rewritten_url, devtools_request_id_, method, extra_request_headers_);
 
   if (matched_resource) {
     OnFetchCompleteExtractHeaders(
         matched_resource->final_url, matched_resource->http_response_code,
         matched_resource->response_data, matched_resource->response_data_size);
   } else {
     url_fetcher_->StartFetch(rewritten_url, method, extra_request_headers_,
                              this);
   }
 }
@@ skipping 12 matching lines @@
   http_response_code_ = http_response_code;
   response_headers_ = response_headers;
   body_ = body;
   body_size_ = body_size;
 
   DispatchHeadersComplete();
 
   std::string mime_type;
   GetMimeType(&mime_type);
 
-  delegate_->OnResourceLoadComplete(final_url, mime_type, http_response_code);
+  delegate_->OnResourceLoadComplete(final_url, devtools_request_id_, mime_type,
+                                    http_response_code);
 }
 
 int GenericURLRequestJob::ReadRawData(net::IOBuffer* buf, int buf_size) {
   // TODO(skyostil): Implement ranged fetches.
   // TODO(alexclarke): Add coverage for all the cases below.
   size_t bytes_available = body_size_ - read_offset_;
   size_t bytes_to_copy =
       std::min(static_cast<size_t>(buf_size), bytes_available);
   if (bytes_to_copy) {
     std::memcpy(buf->data(), &body_[read_offset_], bytes_to_copy);
@@ skipping 21 matching lines @@
     return false;
   return response_headers_->GetCharset(charset);
 }
 
 void GenericURLRequestJob::GetLoadTimingInfo(
     net::LoadTimingInfo* load_timing_info) const {
   // TODO(alexclarke): Investigate setting the other members too where possible.
   load_timing_info->receive_headers_end = response_time_;
 }
 
+bool GenericURLRequestJob::Delegate::BlockOrRewriteRequest(
+    const GURL& url,
+    const std::string& devtools_id,
+    const std::string& method,
+    const std::string& referrer,
+    RewriteCallback callback) {
+  return BlockOrRewriteRequest(url, method, referrer, callback);
+}
+
+bool GenericURLRequestJob::Delegate::BlockOrRewriteRequest(
+    const GURL& url,
+    const std::string& method,
+    const std::string& referrer,
+    RewriteCallback callback) {
+  return false;
+}
+
+const GenericURLRequestJob::HttpResponse*
+GenericURLRequestJob::Delegate::MaybeMatchResource(
+    const GURL& url,
+    const std::string& devtools_id,
+    const std::string& method,
+    const net::HttpRequestHeaders& request_headers) {
+  return MaybeMatchResource(url, method, request_headers);
+}
+
+const GenericURLRequestJob::HttpResponse*
+GenericURLRequestJob::Delegate::MaybeMatchResource(
+    const GURL& url,
+    const std::string& method,
+    const net::HttpRequestHeaders& request_headers) {
+  return nullptr;
+}
+
+void GenericURLRequestJob::Delegate::OnResourceLoadComplete(
+    const GURL& final_url,
+    const std::string& devtools_id,
+    const std::string& mime_type,
+    int http_response_code) {
+  OnResourceLoadComplete(final_url, mime_type, http_response_code);
+}
+
 }  // namespace headless