Pipe the devTools FrameId from blink into the browser for 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 "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/lib/browser/headless_browser_context_impl.h"
+#include "headless/public/headless_browser_context.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 {
@@ skipping 10 matching lines @@
 
 }  // 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)
+    Delegate* delegate,
+    HeadlessBrowserContext* headless_browser_context)
     : ManagedDispatchURLRequestJob(request,
                                    network_delegate,
                                    url_request_dispatcher),
       url_fetcher_(std::move(url_fetcher)),
       origin_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       delegate_(delegate),
+      headless_browser_context_(headless_browser_context),
       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(
@@ skipping 130 matching lines @@
 const net::URLRequest* GenericURLRequestJob::GetURLRequest() const {
   return request_;
 }
 
 int GenericURLRequestJob::GetFrameTreeNodeId() const {
   // 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)) {
+          request_, &render_process_id, &render_frame_id) &&
+      render_process_id != -1) {
+    if (headless_browser_context_) {
+      return static_cast<HeadlessBrowserContextImpl*>(headless_browser_context_)
+          ->GetFrameTreeNodeId(render_process_id, render_frame_id);
+    }
+    // TODO(alexclarke): Remove this.
     content::RenderFrameHost* render_frame_host =
         content::RenderFrameHost::FromID(render_process_id, render_frame_id);

[Charlie Reis, 2017/04/26 19:52:56]

I'm trying to understand this a bit more, but I can't find any callers of this
method.  What thread does this class run on?  It sounds like IO thread stuff
(URLRequestJobs, protocol handlers, etc), but this can only be called on the UI
thread and has a DCHECK to that effect.  Is all of this on the UI thread?

[alex clarke (OOO till 29th), 2017/04/27 08:49:44]

I expect this will be called on the IO thread.

     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;
@@ skipping 126 matching lines @@
   }
 
   mock_response_ = std::move(mock_response);
 
   OnFetchCompleteExtractHeaders(request_->url(),
                                 mock_response_->response_data.data(),
                                 mock_response_->response_data.size());
 }
 
 }  // namespace headless