Adding dev tool header reporting to Search Prefetch

This CL adds report_raw_headers to all search prefetch requests. When
the request is being served, the raw headers are stripped unless the
intercepted request also has report_raw_headers set. This allows dev
tools to see the request headers correctly without special handling to
tie a prefetch request to a specific tab.

Bug: 1142014
Change-Id: I619374e424a74286ffdafdb184d1ffd7a2b74763
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2559283
Commit-Queue: Ryan Sturm <ryansturm@chromium.org>
Reviewed-by: Robert Ogden <robertogden@chromium.org>
Reviewed-by: Matt Falkenhagen <falken@chromium.org>
Cr-Commit-Position: refs/heads/master@{#832476}

chrome/browser/prefetch/search_prefetch/base_search_prefetch_request.cc

@@ -64,6 +64,10 @@ void BaseSearchPrefetchRequest::StartPrefetchRequest(Profile* profile) {
   auto resource_request = std::make_unique<network::ResourceRequest>();
   resource_request->load_flags |= net::LOAD_PREFETCH;
   resource_request->url = prefetch_url_;
+  // Search prefetch URL Loaders should check |report_raw_headers| on the
+  // intercepted request to clear out the raw headers when |report_raw_headers|
+  // is false.
+  resource_request->report_raw_headers = true;
   resource_request->credentials_mode =
       network::mojom::CredentialsMode::kInclude;
   variations::AppendVariationsHeaderUnknownSignedIn(

chrome/browser/prefetch/search_prefetch/search_prefetch_from_string_url_loader.cc

@@ -104,6 +104,10 @@ void SearchPrefetchFromStringURLLoader::BindAndStart(
     return;
   }
 
+  if (!request.report_raw_headers) {
+    head_->raw_request_response_info = nullptr;
+  }
+
   client_->OnReceiveResponse(std::move(head_));
   client_->OnStartLoadingResponseBody(std::move(consumer_handle));
 

chrome/browser/prefetch/search_prefetch/search_prefetch_service_browsertest.cc

@@ -8,7 +8,10 @@
 #include "base/test/scoped_feature_list.h"
 #include "base/time/time.h"
 #include "chrome/browser/autocomplete/chrome_autocomplete_scheme_classifier.h"
+#include "chrome/browser/chrome_content_browser_client.h"
 #include "chrome/browser/content_settings/host_content_settings_map_factory.h"
+#include "chrome/browser/devtools/devtools_window.h"
+#include "chrome/browser/devtools/devtools_window_testing.h"
 #include "chrome/browser/net/prediction_options.h"
 #include "chrome/browser/prefetch/search_prefetch/field_trial_settings.h"
 #include "chrome/browser/prefetch/search_prefetch/search_prefetch_service.h"
@@ -34,6 +37,7 @@
 #include "content/public/browser/browser_task_traits.h"
 #include "content/public/browser/browsing_data_filter_builder.h"
 #include "content/public/browser/browsing_data_remover.h"
+#include "content/public/common/content_client.h"
 #include "content/public/test/browser_test.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/browsing_data_remover_test_util.h"
@@ -44,6 +48,7 @@
 #include "net/test/embedded_test_server/embedded_test_server_connection_listener.h"
 #include "net/test/embedded_test_server/http_request.h"
 #include "net/test/embedded_test_server/http_response.h"
+#include "third_party/blink/public/common/loader/url_loader_throttle.h"
 #include "url/gurl.h"
 
 namespace {
@@ -250,6 +255,14 @@ class SearchPrefetchBaseBrowserTest : public InProcessBrowserTest {
     model->Add(std::make_unique<TemplateURL>(data));
   }
 
+  void OpenDevToolsWindow(content::WebContents* tab) {
+    window_ = DevToolsWindowTesting::OpenDevToolsWindowSync(tab, true);
+  }
+
+  void CloseDevToolsWindow() {
+    DevToolsWindowTesting::CloseDevToolsWindowSync(window_);
+  }
+
  private:
   std::unique_ptr<net::test_server::HttpResponse> HandleSearchRequest(
       const net::test_server::HttpRequest& request) {
@@ -400,6 +413,8 @@ class SearchPrefetchBaseBrowserTest : public InProcessBrowserTest {
 
   // When set to true, serves a response that hangs after the start of the body.
   bool hang_requests_after_start_ = false;
+
+  DevToolsWindow* window_ = nullptr;
 };
 
 class SearchPrefetchServiceDisabledBrowserTest
@@ -530,6 +545,120 @@ IN_PROC_BROWSER_TEST_P(SearchPrefetchServiceEnabledBrowserTest,
   EXPECT_EQ(SearchPrefetchStatus::kCanBeServed, prefetch_status.value());
 }
 
+class HeaderObserverContentBrowserClient : public ChromeContentBrowserClient {
+ public:
+  HeaderObserverContentBrowserClient() = default;
+  ~HeaderObserverContentBrowserClient() override = default;
+
+  // ContentBrowserClient overrides:
+  std::vector<std::unique_ptr<blink::URLLoaderThrottle>>
+  CreateURLLoaderThrottles(
+      const network::ResourceRequest& request,
+      content::BrowserContext* browser_context,
+      const base::RepeatingCallback<content::WebContents*()>& wc_getter,
+      content::NavigationUIData* navigation_ui_data,
+      int frame_tree_node_id) override;
+
+  bool had_raw_request_info() { return had_raw_request_info_; }
+
+  void set_had_raw_request_info(bool had_raw_request_info) {
+    had_raw_request_info_ = had_raw_request_info;
+  }
+
+ private:
+  bool had_raw_request_info_ = false;
+};
+
+// A delegate to cancel prefetch requests by setting |defer| to true.
+class HeaderObserverThrottle : public blink::URLLoaderThrottle {
+ public:
+  explicit HeaderObserverThrottle(HeaderObserverContentBrowserClient* client)
+      : client_(client) {}
+  ~HeaderObserverThrottle() override = default;
+
+  void WillProcessResponse(const GURL& response_url,
+                           network::mojom::URLResponseHead* response_head,
+                           bool* defer) override {
+    client_->set_had_raw_request_info(
+        !!response_head->raw_request_response_info);
+  }
+
+ private:
+  HeaderObserverContentBrowserClient* client_;
+};
+
+std::vector<std::unique_ptr<blink::URLLoaderThrottle>>
+HeaderObserverContentBrowserClient::CreateURLLoaderThrottles(
+    const network::ResourceRequest& request,
+    content::BrowserContext* browser_context,
+    const base::RepeatingCallback<content::WebContents*()>& wc_getter,
+    content::NavigationUIData* navigation_ui_data,
+    int frame_tree_node_id) {
+  std::vector<std::unique_ptr<blink::URLLoaderThrottle>> throttles =
+      ChromeContentBrowserClient::CreateURLLoaderThrottles(
+          request, browser_context, wc_getter, navigation_ui_data,
+          frame_tree_node_id);
+  throttles.push_back(std::make_unique<HeaderObserverThrottle>(this));
+  return throttles;
+}
+
+IN_PROC_BROWSER_TEST_P(SearchPrefetchServiceEnabledBrowserTest,
+                       HeadersNotReportedFromNetwork) {
+  auto* search_prefetch_service =
+      SearchPrefetchServiceFactory::GetForProfile(browser()->profile());
+  EXPECT_NE(nullptr, search_prefetch_service);
+
+  std::string search_terms = "prefetch_content";
+
+  GURL prefetch_url = GetSearchServerQueryURL(search_terms);
+
+  EXPECT_TRUE(search_prefetch_service->MaybePrefetchURL(prefetch_url));
+  auto prefetch_status =
+      search_prefetch_service->GetSearchPrefetchStatusForTesting(
+          base::ASCIIToUTF16(search_terms));
+  ASSERT_TRUE(prefetch_status.has_value());
+  EXPECT_EQ(SearchPrefetchStatus::kInFlight, prefetch_status.value());
+
+  WaitUntilStatusChanges(base::ASCIIToUTF16(search_terms));
+
+  HeaderObserverContentBrowserClient browser_client;
+  auto* old_client = content::SetBrowserClientForTesting(&browser_client);
+  ui_test_utils::NavigateToURL(browser(), prefetch_url);
+
+  EXPECT_FALSE(browser_client.had_raw_request_info());
+  content::SetBrowserClientForTesting(old_client);
+}
+
+IN_PROC_BROWSER_TEST_P(SearchPrefetchServiceEnabledBrowserTest,
+                       HeadersReportedFromNetworkWithDevTools) {
+  auto* search_prefetch_service =
+      SearchPrefetchServiceFactory::GetForProfile(browser()->profile());
+  EXPECT_NE(nullptr, search_prefetch_service);
+
+  std::string search_terms = "prefetch_content";
+
+  GURL prefetch_url = GetSearchServerQueryURL(search_terms);
+
+  EXPECT_TRUE(search_prefetch_service->MaybePrefetchURL(prefetch_url));
+  auto prefetch_status =
+      search_prefetch_service->GetSearchPrefetchStatusForTesting(
+          base::ASCIIToUTF16(search_terms));
+  ASSERT_TRUE(prefetch_status.has_value());
+  EXPECT_EQ(SearchPrefetchStatus::kInFlight, prefetch_status.value());
+
+  WaitUntilStatusChanges(base::ASCIIToUTF16(search_terms));
+
+  OpenDevToolsWindow(browser()->tab_strip_model()->GetActiveWebContents());
+
+  HeaderObserverContentBrowserClient browser_client;
+  auto* old_client = content::SetBrowserClientForTesting(&browser_client);
+  ui_test_utils::NavigateToURL(browser(), prefetch_url);
+
+  EXPECT_TRUE(browser_client.had_raw_request_info());
+  CloseDevToolsWindow();
+  content::SetBrowserClientForTesting(old_client);
+}
+
 IN_PROC_BROWSER_TEST_P(SearchPrefetchServiceEnabledBrowserTest,
                        PrefetchRateLimiting) {
   auto* search_prefetch_service =

chrome/browser/prefetch/search_prefetch/streaming_search_prefetch_url_loader.cc

@@ -58,7 +58,7 @@ StreamingSearchPrefetchURLLoader::ServingResponseHandler() {
 }
 
 void StreamingSearchPrefetchURLLoader::SetUpForwardingClient(
-    const network::ResourceRequest& /* resource_request */,
+    const network::ResourceRequest& resource_request,
     mojo::PendingReceiver<network::mojom::URLLoader> receiver,
     mojo::PendingRemote<network::mojom::URLLoaderClient> forwarding_client) {
   DCHECK(!streaming_prefetch_request_);
@@ -70,6 +70,10 @@ void StreamingSearchPrefetchURLLoader::SetUpForwardingClient(
                      weak_factory_.GetWeakPtr()));
   forwarding_client_.Bind(std::move(forwarding_client));
 
+  if (!resource_request.report_raw_headers) {
+    resource_response_->raw_request_response_info = nullptr;
+  }
+
   forwarding_client_->OnReceiveResponse(std::move(resource_response_));
 
   // Resume previously paused network service URLLoader.