Add GetPostData and ID to headless::Request plus fix GetFrameTreeNodeId

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 "content/public/browser/devtools_agent_host.h"
+#include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/browser/web_contents.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/base/upload_bytes_element_reader.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_Request_Id defined in HTTPNames.json5.
 const char kDevtoolsRequestId[] = "X-DevTools-Request-Id";
 
 }  // namespace
 
+uint64_t GenericURLRequestJob::next_request_id_ = 0;
+
 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)),
       origin_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       delegate_(delegate),
       request_resource_info_(
           content::ResourceRequestInfo::ForRequest(request_)),
+      request_id_(next_request_id_++),
       weak_factory_(this) {}
 
 GenericURLRequestJob::~GenericURLRequestJob() {
   DCHECK(origin_task_runner_->RunsTasksOnCurrentThread());
 }
 
 void GenericURLRequestJob::SetExtraRequestHeaders(
     const net::HttpRequestHeaders& headers) {
   DCHECK(origin_task_runner_->RunsTasksOnCurrentThread());
   extra_request_headers_ = headers;
@@ skipping 42 matching lines @@
 }
 
 void GenericURLRequestJob::OnCookiesAvailable(
     const GURL& rewritten_url,
     const std::string& method,
     const base::Closure& done_callback,
     const net::CookieList& cookie_list) {
   DCHECK(origin_task_runner_->RunsTasksOnCurrentThread());
   // TODO(alexclarke): Set user agent.
   // Pass cookies, the referrer and any extra headers into the fetch request.
-  extra_request_headers_.SetHeader(
-      net::HttpRequestHeaders::kCookie,
-      net::CookieStore::BuildCookieLine(cookie_list));
+  std::string cookie = net::CookieStore::BuildCookieLine(cookie_list);
+  if (!cookie.empty())
+    extra_request_headers_.SetHeader(net::HttpRequestHeaders::kCookie, cookie);
 
-  extra_request_headers_.SetHeader(net::HttpRequestHeaders::kReferer,
-                                   request_->referrer());
+  if (!request_->referrer().empty()) {
+    extra_request_headers_.SetHeader(net::HttpRequestHeaders::kReferer,
+                                     request_->referrer());
+  }
 
   done_callback.Run();
 }
 
 void GenericURLRequestJob::OnFetchStartError(net::Error error) {
   DCHECK(origin_task_runner_->RunsTasksOnCurrentThread());
   DispatchStartError(error);
   delegate_->OnResourceLoadFailed(this, error);
 }
 
@@ skipping 49 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_;
 }
 
+uint64_t GenericURLRequestJob::GenericURLRequestJob::GetRequestId() const {
+  return request_id_;
+}
+
 const net::URLRequest* GenericURLRequestJob::GetURLRequest() const {
   return request_;
 }
 
 int GenericURLRequestJob::GetFrameTreeNodeId() const {
-  return request_resource_info_->GetFrameTreeNodeId();
+  // URLRequestUserData will be set for all renderer initiated resource
+  // requests, but not for browser side navigations.
+  int render_process_id;
+  int render_frame_id;
+  if (content::ResourceRequestInfo::GetRenderFrameForRequest(
+          request_, &render_process_id, &render_frame_id)) {
+    content::RenderFrameHost* render_frame_host =
+        content::RenderFrameHost::FromID(render_process_id, render_frame_id);
+    DCHECK(render_frame_host);
+    return render_frame_host->GetFrameTreeNodeId();
+  }
+  // ResourceRequestInfo::GetFrameTreeNodeId is only set for browser side
+  // navigations.
+  if (request_resource_info_)
+    return request_resource_info_->GetFrameTreeNodeId();
+
+  // This should only happen in tests.
+  return -1;
 }
 
 std::string GenericURLRequestJob::GetDevToolsAgentHostId() const {
   return content::DevToolsAgentHost::GetOrCreateFor(
              request_resource_info_->GetWebContentsGetterForRequest().Run())
       ->GetId();
 }
 
 Request::ResourceType GenericURLRequestJob::GetResourceType() const {
+  // This should only happen in some tests.
+  if (!request_resource_info_)
+    return Request::ResourceType::MAIN_FRAME;
+
   switch (request_resource_info_->GetResourceType()) {
     case content::RESOURCE_TYPE_MAIN_FRAME:
       return Request::ResourceType::MAIN_FRAME;
     case content::RESOURCE_TYPE_SUB_FRAME:
       return Request::ResourceType::SUB_FRAME;
     case content::RESOURCE_TYPE_STYLESHEET:
       return Request::ResourceType::STYLESHEET;
     case content::RESOURCE_TYPE_SCRIPT:
       return Request::ResourceType::SCRIPT;
     case content::RESOURCE_TYPE_IMAGE:
@@ skipping 23 matching lines @@
     case content::RESOURCE_TYPE_CSP_REPORT:
       return Request::ResourceType::CSP_REPORT;
     case content::RESOURCE_TYPE_PLUGIN_RESOURCE:
       return Request::ResourceType::PLUGIN_RESOURCE;
     default:
       NOTREACHED() << "Unrecognized resource type";
       return Request::ResourceType::MAIN_FRAME;
   }
 }
 
-namespace {
-std::string GetUploadData(net::URLRequest* request) {
-  if (!request->has_upload())
+std::string GenericURLRequestJob::GetPostData() const {
+  if (!request_->has_upload())
     return "";
 
-  const net::UploadDataStream* stream = request->get_upload();
+  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());
 }
-}  // namespace
 
 const Request* GenericURLRequestJob::GetRequest() const {
   return this;
 }
 
 void GenericURLRequestJob::AllowRequest() {
   if (!origin_task_runner_->RunsTasksOnCurrentThread()) {
     origin_task_runner_->PostTask(
         FROM_HERE, base::Bind(&GenericURLRequestJob::AllowRequest,
                               weak_factory_.GetWeakPtr()));
     return;
   }
 
-  url_fetcher_->StartFetch(request_->url(), request_->method(),
-                           GetUploadData(request_), extra_request_headers_,
-                           this);
+  url_fetcher_->StartFetch(request_->url(), request_->method(), GetPostData(),
+                           extra_request_headers_, this);
 }
 
 void GenericURLRequestJob::BlockRequest(net::Error error) {
   if (!origin_task_runner_->RunsTasksOnCurrentThread()) {
     origin_task_runner_->PostTask(
         FROM_HERE, base::Bind(&GenericURLRequestJob::BlockRequest,
                               weak_factory_.GetWeakPtr(), error));
     return;
   }
 
@@ skipping 33 matching lines @@
 
   mock_response_ = std::move(mock_response);
 
   OnFetchCompleteExtractHeaders(request_->url(),
                                 mock_response_->http_response_code,
                                 mock_response_->response_data.data(),
                                 mock_response_->response_data.size());
 }
 
 }  // namespace headless