Remove blink::NetworkHintsInterface

Get rid of NetworkHintsInterface and replace it with
WebPrescientNetworking.
Mock classes which subclass NetworkHintsInterface for tests
also changed to subclass of WebPrescientNetworking.

Bug: 939636
Change-Id: I12aa8a2769262490377d20ea89a1ab0bfbd68a88
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1513796
Commit-Queue: Hwanseung Lee <hs1217.lee@samsung.com>
Reviewed-by: Dmitry Gozman <dgozman@chromium.org>
Cr-Commit-Position: refs/heads/master@{#642382}

third_party/blink/renderer/core/html/html_anchor_element.cc

@@ -25,6 +25,8 @@
 #include "third_party/blink/renderer/core/html/html_anchor_element.h"
 
 #include "base/metrics/histogram_macros.h"
+#include "third_party/blink/public/platform/platform.h"
+#include "third_party/blink/public/platform/web_prescient_networking.h"
 #include "third_party/blink/renderer/bindings/core/v8/usv_string_or_trusted_url.h"
 #include "third_party/blink/renderer/core/dom/user_gesture_indicator.h"
 #include "third_party/blink/renderer/core/editing/editing_utilities.h"
@@ -42,7 +44,6 @@
 #include "third_party/blink/renderer/core/layout/layout_box.h"
 #include "third_party/blink/renderer/core/loader/frame_load_request.h"
 #include "third_party/blink/renderer/core/loader/navigation_policy.h"
-#include "third_party/blink/renderer/core/loader/network_hints_interface.h"
 #include "third_party/blink/renderer/core/loader/ping_loader.h"
 #include "third_party/blink/renderer/core/origin_trials/origin_trials.h"
 #include "third_party/blink/renderer/core/page/chrome_client.h"
@@ -209,8 +210,12 @@ void HTMLAnchorElement::ParseAttribute(
       if (GetDocument().IsDNSPrefetchEnabled()) {
         if (ProtocolIs(parsed_url, "http") || ProtocolIs(parsed_url, "https") ||
             parsed_url.StartsWith("//")) {
-          NetworkHintsInterfaceImpl().DnsPrefetchHost(
-              GetDocument().CompleteURL(parsed_url).Host());
+          WebPrescientNetworking* web_prescient_networking =
+              Platform::Current()->PrescientNetworking();
+          if (web_prescient_networking) {
+            web_prescient_networking->PrefetchDNS(
+                GetDocument().CompleteURL(parsed_url).Host());
+          }
         }
       }
     }

third_party/blink/renderer/core/html/html_link_element.cc

@@ -27,6 +27,7 @@
 
 #include "third_party/blink/public/platform/task_type.h"
 #include "third_party/blink/public/platform/web_icon_sizes_parser.h"
+#include "third_party/blink/public/platform/web_prescient_networking.h"
 #include "third_party/blink/public/platform/web_size.h"
 #include "third_party/blink/renderer/bindings/core/v8/script_event_listener.h"
 #include "third_party/blink/renderer/core/core_initializer.h"
@@ -42,7 +43,6 @@
 #include "third_party/blink/renderer/core/html_names.h"
 #include "third_party/blink/renderer/core/inspector/console_message.h"
 #include "third_party/blink/renderer/core/loader/link_loader.h"
-#include "third_party/blink/renderer/core/loader/network_hints_interface.h"
 #include "third_party/blink/renderer/core/origin_trials/origin_trials.h"
 #include "third_party/blink/renderer/platform/weborigin/security_policy.h"
 #include "third_party/blink/renderer/platform/wtf/functional.h"
@@ -162,8 +162,7 @@ bool HTMLLinkElement::IsLinkCreatedByParser() {
 }
 
 bool HTMLLinkElement::LoadLink(const LinkLoadParameters& params) {
-  return link_loader_->LoadLink(params, GetDocument(),
-                                NetworkHintsInterfaceImpl());
+  return link_loader_->LoadLink(params, GetDocument());
 }
 
 void HTMLLinkElement::LoadStylesheet(const LinkLoadParameters& params,

third_party/blink/renderer/core/html/parser/html_preload_scanner_fuzzer.cc

@@ -32,8 +32,7 @@ std::unique_ptr<CachedDocumentParameters> CachedDocumentParametersForFuzzing(
 }
 
 class MockResourcePreloader : public ResourcePreloader {
-  void Preload(std::unique_ptr<PreloadRequest>,
-               const NetworkHintsInterface&) override {}
+  void Preload(std::unique_ptr<PreloadRequest>) override {}
 };
 
 int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {

third_party/blink/renderer/core/html/parser/html_preload_scanner_test.cc

@@ -200,8 +200,7 @@ class HTMLMockHTMLResourcePreloader : public ResourcePreloader {
   }
 
  protected:
-  void Preload(std::unique_ptr<PreloadRequest> preload_request,
-               const NetworkHintsInterface&) override {
+  void Preload(std::unique_ptr<PreloadRequest> preload_request) override {
     preload_request_ = std::move(preload_request);
   }
 

third_party/blink/renderer/core/html/parser/html_resource_preloader.cc

@@ -26,6 +26,8 @@
 #include "third_party/blink/renderer/core/html/parser/html_resource_preloader.h"
 
 #include <memory>
+#include "third_party/blink/public/platform/platform.h"
+#include "third_party/blink/public/platform/web_prescient_networking.h"
 #include "third_party/blink/renderer/core/dom/document.h"
 #include "third_party/blink/renderer/core/frame/deprecation.h"
 #include "third_party/blink/renderer/core/frame/settings.h"
@@ -46,22 +48,23 @@ void HTMLResourcePreloader::Trace(Visitor* visitor) {
   visitor->Trace(document_);
 }
 
-static void PreconnectHost(
-    PreloadRequest* request,
-    const NetworkHintsInterface& network_hints_interface) {
+static void PreconnectHost(PreloadRequest* request) {
   DCHECK(request);
   DCHECK(request->IsPreconnect());
   KURL host(request->BaseURL(), request->ResourceURL());
   if (!host.IsValid() || !host.ProtocolIsInHTTPFamily())
     return;
-  network_hints_interface.PreconnectHost(host, request->CrossOrigin());
+  WebPrescientNetworking* web_prescient_networking =
+      Platform::Current()->PrescientNetworking();
+  if (web_prescient_networking) {
+    web_prescient_networking->Preconnect(
+        host, request->CrossOrigin() != kCrossOriginAttributeAnonymous);
+  }
 }
 
-void HTMLResourcePreloader::Preload(
-    std::unique_ptr<PreloadRequest> preload,
-    const NetworkHintsInterface& network_hints_interface) {
+void HTMLResourcePreloader::Preload(std::unique_ptr<PreloadRequest> preload) {
   if (preload->IsPreconnect()) {
-    PreconnectHost(preload.get(), network_hints_interface);
+    PreconnectHost(preload.get());
     return;
   }
   // TODO(yoichio): Should preload if document is imported.

third_party/blink/renderer/core/html/parser/html_resource_preloader.h

@@ -31,7 +31,6 @@
 #include "base/macros.h"
 #include "third_party/blink/renderer/core/html/parser/preload_request.h"
 #include "third_party/blink/renderer/core/html/parser/resource_preloader.h"
-#include "third_party/blink/renderer/core/loader/network_hints_interface.h"
 #include "third_party/blink/renderer/platform/heap/heap.h"
 #include "third_party/blink/renderer/platform/wtf/text/text_position.h"
 #include "third_party/blink/renderer/platform/wtf/time.h"
@@ -53,8 +52,7 @@ class CORE_EXPORT HTMLResourcePreloader
   void Trace(Visitor*);
 
  protected:
-  void Preload(std::unique_ptr<PreloadRequest>,
-               const NetworkHintsInterface&) override;
+  void Preload(std::unique_ptr<PreloadRequest>) override;
 
  private:
   Member<Document> document_;

third_party/blink/renderer/core/html/parser/html_resource_preloader_test.cc

@@ -5,7 +5,9 @@
 #include "third_party/blink/renderer/core/html/parser/html_resource_preloader.h"
 
 #include <memory>
+#include <utility>
 #include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/blink/public/platform/web_prescient_networking.h"
 #include "third_party/blink/renderer/core/html/parser/preload_request.h"
 #include "third_party/blink/renderer/core/testing/page_test_base.h"
 
@@ -18,27 +20,40 @@ struct HTMLResourcePreconnectTestCase {
   bool is_https;
 };
 
-class PreloaderNetworkHintsMock : public NetworkHintsInterface {
+class PreloaderNetworkHintsMock : public WebPrescientNetworking {
  public:
   PreloaderNetworkHintsMock() : did_preconnect_(false) {}
 
-  void DnsPrefetchHost(const String& host) const override {}
-  void PreconnectHost(
-      const KURL& host,
-      const CrossOriginAttributeValue cross_origin) const override {
+  void PrefetchDNS(const WebString& hostname) override {}
+  void Preconnect(const WebURL& url, const bool allow_credentials) override {
     did_preconnect_ = true;
-    is_https_ = host.ProtocolIs("https");
-    is_cross_origin_ = (cross_origin == kCrossOriginAttributeAnonymous);
+    is_https_ = url.ProtocolIs("https");
+    allow_credentials_ = allow_credentials;
   }
 
   bool DidPreconnect() { return did_preconnect_; }
   bool IsHTTPS() { return is_https_; }
-  bool IsCrossOrigin() { return is_cross_origin_; }
+  bool AllowCredentials() { return allow_credentials_; }
 
  private:
   mutable bool did_preconnect_;
   mutable bool is_https_;
-  mutable bool is_cross_origin_;
+  mutable bool allow_credentials_;
+};
+
+class TestingPlatformSupportWithPreloaderNetworkHintsMock
+    : public TestingPlatformSupport {
+ public:
+  PreloaderNetworkHintsMock& GetMockPrescientNetworking() {
+    return mock_prescient_networking_;
+  }
+
+ private:
+  WebPrescientNetworking* PrescientNetworking() override {
+    return &mock_prescient_networking_;
+  }
+
+  PreloaderNetworkHintsMock mock_prescient_networking_;
 };
 
 class HTMLResourcePreloaderTest : public PageTestBase {
@@ -48,7 +63,6 @@ class HTMLResourcePreloaderTest : public PageTestBase {
   void Test(HTMLResourcePreconnectTestCase test_case) {
     // TODO(yoav): Need a mock loader here to verify things are happenning
     // beyond preconnect.
-    PreloaderNetworkHintsMock network_hints;
     auto preload_request = PreloadRequest::CreateIfNeeded(
         String(), TextPosition(), test_case.url, KURL(test_case.base_url),
         ResourceType::kImage, network::mojom::ReferrerPolicy(),
@@ -60,11 +74,16 @@ class HTMLResourcePreloaderTest : public PageTestBase {
       preload_request->SetCrossOrigin(kCrossOriginAttributeAnonymous);
     HTMLResourcePreloader* preloader =
         HTMLResourcePreloader::Create(GetDocument());
-    preloader->Preload(std::move(preload_request), network_hints);
-    ASSERT_TRUE(network_hints.DidPreconnect());
-    ASSERT_EQ(test_case.is_cors, network_hints.IsCrossOrigin());
-    ASSERT_EQ(test_case.is_https, network_hints.IsHTTPS());
+    preloader->Preload(std::move(preload_request));
+    ASSERT_TRUE(platform_->GetMockPrescientNetworking().DidPreconnect());
+    ASSERT_NE(test_case.is_cors,
+              platform_->GetMockPrescientNetworking().AllowCredentials());
+    ASSERT_EQ(test_case.is_https,
+              platform_->GetMockPrescientNetworking().IsHTTPS());
   }
+  ScopedTestingPlatformSupport<
+      TestingPlatformSupportWithPreloaderNetworkHintsMock>
+      platform_;
 };
 
 TEST_F(HTMLResourcePreloaderTest, testPreconnect) {

third_party/blink/renderer/core/html/parser/resource_preloader.cc

@@ -3,18 +3,18 @@
 // found in the LICENSE file.
 
 #include "third_party/blink/renderer/core/html/parser/resource_preloader.h"
-#include "third_party/blink/renderer/core/loader/network_hints_interface.h"
+
+#include <utility>
 
 namespace blink {
 
 void ResourcePreloader::TakeAndPreload(PreloadRequestStream& r) {
   PreloadRequestStream requests;
-  NetworkHintsInterfaceImpl network_hints_interface;
   requests.swap(r);
 
   for (PreloadRequestStream::iterator it = requests.begin();
        it != requests.end(); ++it)
-    Preload(std::move(*it), network_hints_interface);
+    Preload(std::move(*it));
 }
 
 }  // namespace blink

third_party/blink/renderer/core/html/parser/resource_preloader.h

@@ -11,15 +11,12 @@
 
 namespace blink {
 
-class NetworkHintsInterface;
-
 class CORE_EXPORT ResourcePreloader {
  public:
   virtual void TakeAndPreload(PreloadRequestStream&);
 
  private:
-  virtual void Preload(std::unique_ptr<PreloadRequest>,
-                       const NetworkHintsInterface&) = 0;
+  virtual void Preload(std::unique_ptr<PreloadRequest>) = 0;
 };
 
 }  // namespace blink

third_party/blink/renderer/core/loader/BUILD.gn

@@ -87,8 +87,6 @@ blink_core_sources("loader") {
     "navigation_policy.h",
     "navigation_scheduler.cc",
     "navigation_scheduler.h",
-    "network_hints_interface.cc",
-    "network_hints_interface.h",
     "ping_loader.cc",
     "ping_loader.h",
     "preload_helper.cc",

third_party/blink/renderer/core/loader/document_loader.cc

@@ -36,7 +36,6 @@
 #include "services/metrics/public/cpp/ukm_recorder.h"
 #include "third_party/blink/public/common/origin_policy/origin_policy.h"
 #include "third_party/blink/public/platform/modules/service_worker/web_service_worker_network_provider.h"
-#include "third_party/blink/public/platform/platform.h"
 #include "third_party/blink/public/platform/web_url_request.h"
 #include "third_party/blink/public/web/web_history_commit_type.h"
 #include "third_party/blink/renderer/core/dom/document.h"
@@ -65,7 +64,6 @@
 #include "third_party/blink/renderer/core/loader/idleness_detector.h"
 #include "third_party/blink/renderer/core/loader/interactive_detector.h"
 #include "third_party/blink/renderer/core/loader/mixed_content_checker.h"
-#include "third_party/blink/renderer/core/loader/network_hints_interface.h"
 #include "third_party/blink/renderer/core/loader/preload_helper.h"
 #include "third_party/blink/renderer/core/loader/private/frame_client_hints_preferences_context.h"
 #include "third_party/blink/renderer/core/loader/progress_tracker.h"
@@ -352,8 +350,7 @@ void DocumentLoader::DispatchLinkHeaderPreloads(
   PreloadHelper::LoadLinksFromHeader(
       GetResponse().HttpHeaderField(http_names::kLink),
       GetResponse().CurrentRequestUrl(), *frame_, frame_->GetDocument(),
-      NetworkHintsInterfaceImpl(), PreloadHelper::kOnlyLoadResources,
-      media_policy, viewport);
+      PreloadHelper::kOnlyLoadResources, media_policy, viewport);
 }
 
 void DocumentLoader::DidChangePerformanceTiming() {
@@ -1166,8 +1163,8 @@ void DocumentLoader::StartLoadingInternal() {
   ParseAndPersistClientHints(response);
   PreloadHelper::LoadLinksFromHeader(
       response.HttpHeaderField(http_names::kLink), response.CurrentRequestUrl(),
-      *GetFrame(), nullptr, NetworkHintsInterfaceImpl(),
-      PreloadHelper::kDoNotLoadResources, PreloadHelper::kLoadAll, nullptr);
+      *GetFrame(), nullptr, PreloadHelper::kDoNotLoadResources,
+      PreloadHelper::kLoadAll, nullptr);
   if (!frame_->IsMainFrame() && response.HasMajorCertificateErrors()) {
     MixedContentChecker::HandleCertificateError(
         GetFrame(), response, mojom::RequestContextType::HYPERLINK);

third_party/blink/renderer/core/loader/frame_fetch_context.cc

@@ -41,7 +41,6 @@
 #include "third_party/blink/public/common/device_memory/approximated_device_memory.h"
 #include "third_party/blink/public/mojom/fetch/fetch_api_request.mojom-shared.h"
 #include "third_party/blink/public/platform/modules/service_worker/web_service_worker_network_provider.h"
-#include "third_party/blink/public/platform/platform.h"
 #include "third_party/blink/public/platform/web_application_cache_host.h"
 #include "third_party/blink/public/platform/web_content_settings_client.h"
 #include "third_party/blink/public/platform/web_effective_connection_type.h"
@@ -80,7 +79,6 @@
 #include "third_party/blink/renderer/core/loader/interactive_detector.h"
 #include "third_party/blink/renderer/core/loader/loader_factory_for_frame.h"
 #include "third_party/blink/renderer/core/loader/mixed_content_checker.h"
-#include "third_party/blink/renderer/core/loader/network_hints_interface.h"
 #include "third_party/blink/renderer/core/loader/ping_loader.h"
 #include "third_party/blink/renderer/core/loader/progress_tracker.h"
 #include "third_party/blink/renderer/core/loader/subresource_filter.h"
@@ -504,8 +502,7 @@ void FrameFetchContext::DispatchDidReceiveResponse(
   PreloadHelper::LoadLinksFromHeader(
       response.HttpHeaderField(http_names::kLink), response.CurrentRequestUrl(),
       *GetFrame(), &frame_or_imported_document_->GetDocument(),
-      NetworkHintsInterfaceImpl(), resource_loading_policy,
-      PreloadHelper::kLoadAll, nullptr);
+      resource_loading_policy, PreloadHelper::kLoadAll, nullptr);
 
   DCHECK_EQ(network::mojom::RequestContextFrameType::kNone,
             request.GetFrameType());

third_party/blink/renderer/core/loader/frame_loader.cc

@@ -80,7 +80,6 @@
 #include "third_party/blink/renderer/core/loader/frame_load_request.h"
 #include "third_party/blink/renderer/core/loader/mixed_content_checker.h"
 #include "third_party/blink/renderer/core/loader/navigation_scheduler.h"
-#include "third_party/blink/renderer/core/loader/network_hints_interface.h"
 #include "third_party/blink/renderer/core/loader/progress_tracker.h"
 #include "third_party/blink/renderer/core/page/chrome_client.h"
 #include "third_party/blink/renderer/core/page/create_window.h"

third_party/blink/renderer/core/loader/link_loader.cc

@@ -51,7 +51,7 @@
 
 namespace blink {
 
-class NetworkHintsInterface;
+class WebPrescientNetworking;
 
 namespace {
 
@@ -169,10 +169,8 @@ Resource* LinkLoader::GetResourceForTesting() {
   return finish_observer_ ? finish_observer_->GetResource() : nullptr;
 }
 
-bool LinkLoader::LoadLink(
-    const LinkLoadParameters& params,
-    Document& document,
-    const NetworkHintsInterface& network_hints_interface) {
+bool LinkLoader::LoadLink(const LinkLoadParameters& params,
+                          Document& document) {
   // If any loading process is in progress, abort it.
   Abort();
 
@@ -180,11 +178,9 @@ bool LinkLoader::LoadLink(
     return false;
 
   PreloadHelper::DnsPrefetchIfNeeded(params, &document, document.GetFrame(),
-                                     network_hints_interface,
                                      PreloadHelper::kLinkCalledFromMarkup);
 
   PreloadHelper::PreconnectIfNeeded(params, &document, document.GetFrame(),
-                                    network_hints_interface,
                                     PreloadHelper::kLinkCalledFromMarkup);
 
   Resource* resource = PreloadHelper::PreloadIfNeeded(

third_party/blink/renderer/core/loader/link_loader.h

@@ -42,7 +42,6 @@ namespace blink {
 
 class Document;
 class LinkLoaderClient;
-class NetworkHintsInterface;
 class PrerenderHandle;
 class Resource;
 class ResourceClient;
@@ -66,9 +65,7 @@ class CORE_EXPORT LinkLoader final : public SingleModuleClient,
   void DidSendDOMContentLoadedForPrerender() override;
 
   void Abort();
-  bool LoadLink(const LinkLoadParameters&,
-                Document&,
-                const NetworkHintsInterface&);
+  bool LoadLink(const LinkLoadParameters&, Document&);
   void LoadStylesheet(const LinkLoadParameters&,
                       const AtomicString&,
                       const WTF::TextEncoding&,

third_party/blink/renderer/core/loader/link_loader_test.cc

@@ -9,6 +9,7 @@
 #include "base/single_thread_task_runner.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/blink/public/platform/platform.h"
+#include "third_party/blink/public/platform/web_prescient_networking.h"
 #include "third_party/blink/public/platform/web_url_loader_mock_factory.h"
 #include "third_party/blink/renderer/bindings/core/v8/v8_binding_for_core.h"
 #include "third_party/blink/renderer/core/frame/csp/content_security_policy.h"
@@ -17,12 +18,12 @@
 #include "third_party/blink/renderer/core/loader/document_loader.h"
 #include "third_party/blink/renderer/core/loader/link_loader_client.h"
 #include "third_party/blink/renderer/core/loader/modulescript/module_script_fetch_request.h"
-#include "third_party/blink/renderer/core/loader/network_hints_interface.h"
 #include "third_party/blink/renderer/core/testing/dummy_modulator.h"
 #include "third_party/blink/renderer/core/testing/dummy_page_holder.h"
 #include "third_party/blink/renderer/platform/loader/fetch/memory_cache.h"
 #include "third_party/blink/renderer/platform/loader/fetch/resource_fetcher.h"
 #include "third_party/blink/renderer/platform/loader/fetch/resource_load_priority.h"
+#include "third_party/blink/renderer/platform/testing/testing_platform_support.h"
 #include "third_party/blink/renderer/platform/testing/url_test_helpers.h"
 
 namespace blink {
@@ -63,32 +64,51 @@ class MockLinkLoaderClient final
   const bool should_load_;
 };
 
-class NetworkHintsMock : public NetworkHintsInterface {
+class NetworkHintsMock : public WebPrescientNetworking {
  public:
   NetworkHintsMock() = default;
 
-  void DnsPrefetchHost(const String& host) const override {
-    did_dns_prefetch_ = true;
+  void Reset() {
+    did_dns_prefetch_ = false;
+    did_preconnect_ = false;
+    is_https_ = false;
+    allow_credentials_ = false;
   }
 
-  void PreconnectHost(
-      const KURL& host,
-      const CrossOriginAttributeValue cross_origin) const override {
+  void PrefetchDNS(const WebString& hostname) override {
+    did_dns_prefetch_ = true;
+  }
+  void Preconnect(const WebURL& url, const bool allow_credentials) override {
     did_preconnect_ = true;
-    is_https_ = host.ProtocolIs("https");
-    is_cross_origin_ = (cross_origin == kCrossOriginAttributeAnonymous);
+    is_https_ = url.ProtocolIs("https");
+    allow_credentials_ = allow_credentials;
   }
 
   bool DidDnsPrefetch() { return did_dns_prefetch_; }
   bool DidPreconnect() { return did_preconnect_; }
   bool IsHTTPS() { return is_https_; }
-  bool IsCrossOrigin() { return is_cross_origin_; }
+  bool AllowCredentials() { return allow_credentials_; }
 
  private:
   mutable bool did_dns_prefetch_ = false;
   mutable bool did_preconnect_ = false;
   mutable bool is_https_ = false;
-  mutable bool is_cross_origin_ = false;
+  mutable bool allow_credentials_ = false;
+};
+
+class TestingPlatformSupportWithNetworkHintsMock
+    : public TestingPlatformSupport {
+ public:
+  NetworkHintsMock& GetMockPrescientNetworking() {
+    return mock_prescient_networking_;
+  }
+
+ private:
+  WebPrescientNetworking* PrescientNetworking() override {
+    return &mock_prescient_networking_;
+  }
+
+  NetworkHintsMock mock_prescient_networking_;
 };
 
 class LinkLoaderPreloadTestBase : public testing::Test {
@@ -121,8 +141,7 @@ class LinkLoaderPreloadTestBase : public testing::Test {
         MockLinkLoaderClient::Create(expected.link_loader_should_load_value);
     LinkLoader* loader = LinkLoader::Create(loader_client.Get());
     url_test_helpers::RegisterMockedErrorURLLoad(params.href);
-    loader->LoadLink(params, dummy_page_holder_->GetDocument(),
-                     NetworkHintsMock());
+    loader->LoadLink(params, dummy_page_holder_->GetDocument());
     if (!expected.load_url.IsNull() &&
         expected.priority != ResourceLoadPriority::kUnresolved) {
       ASSERT_EQ(1, fetcher->CountPreloads());
@@ -524,8 +543,7 @@ TEST_P(LinkLoaderModulePreloadTest, ModulePreload) {
       String() /* type */, String() /* as */, String() /* media */,
       test_case.nonce, test_case.integrity, String(), test_case.referrer_policy,
       href_url, String() /* image_srcset */, String() /* image_sizes */);
-  loader->LoadLink(params, dummy_page_holder->GetDocument(),
-                   NetworkHintsMock());
+  loader->LoadLink(params, dummy_page_holder->GetDocument());
   ASSERT_EQ(test_case.expecting_load, modulator->fetched());
 }
 
@@ -533,7 +551,13 @@ INSTANTIATE_TEST_SUITE_P(LinkLoaderModulePreloadTest,
                          LinkLoaderModulePreloadTest,
                          testing::ValuesIn(kModulePreloadTestParams));
 
-TEST(LinkLoaderTest, Prefetch) {
+class LinkLoaderTest : public testing::Test {
+ protected:
+  ScopedTestingPlatformSupport<TestingPlatformSupportWithNetworkHintsMock>
+      platform_;
+};
+
+TEST_F(LinkLoaderTest, Prefetch) {
   struct TestCase {
     const char* href;
     // TODO(yoav): Add support for type and media crbug.com/662687
@@ -571,8 +595,7 @@ TEST(LinkLoaderTest, Prefetch) {
         test_case.type, "", test_case.media, "", "", String(),
         test_case.referrer_policy, href_url, String() /* image_srcset */,
         String() /* image_sizes */);
-    loader->LoadLink(params, dummy_page_holder->GetDocument(),
-                     NetworkHintsMock());
+    loader->LoadLink(params, dummy_page_holder->GetDocument());
     ASSERT_TRUE(dummy_page_holder->GetDocument().Fetcher());
     Resource* resource = loader->GetResourceForTesting();
     if (test_case.expecting_load) {
@@ -593,7 +616,7 @@ TEST(LinkLoaderTest, Prefetch) {
   }
 }
 
-TEST(LinkLoaderTest, DNSPrefetch) {
+TEST_F(LinkLoaderTest, DNSPrefetch) {
   struct {
     const char* href;
     const bool should_load;
@@ -606,6 +629,7 @@ TEST(LinkLoaderTest, DNSPrefetch) {
 
   // Test the cases with a single header
   for (const auto& test_case : cases) {
+    platform_->GetMockPrescientNetworking().Reset();
     std::unique_ptr<DummyPageHolder> dummy_page_holder =
         DummyPageHolder::Create(IntSize(500, 500));
     dummy_page_holder->GetDocument().GetSettings()->SetDNSPrefetchingEnabled(
@@ -614,19 +638,19 @@ TEST(LinkLoaderTest, DNSPrefetch) {
         MockLinkLoaderClient::Create(test_case.should_load);
     LinkLoader* loader = LinkLoader::Create(loader_client.Get());
     KURL href_url = KURL(KURL(String("http://example.com")), test_case.href);
-    NetworkHintsMock network_hints;
     LinkLoadParameters params(
         LinkRelAttribute("dns-prefetch"), kCrossOriginAttributeNotSet, String(),
         String(), String(), String(), String(), String(),
         network::mojom::ReferrerPolicy::kDefault, href_url,
         String() /* image_srcset */, String() /* image_sizes */);
-    loader->LoadLink(params, dummy_page_holder->GetDocument(), network_hints);
-    EXPECT_FALSE(network_hints.DidPreconnect());
-    EXPECT_EQ(test_case.should_load, network_hints.DidDnsPrefetch());
+    loader->LoadLink(params, dummy_page_holder->GetDocument());
+    EXPECT_FALSE(platform_->GetMockPrescientNetworking().DidPreconnect());
+    EXPECT_EQ(test_case.should_load,
+              platform_->GetMockPrescientNetworking().DidDnsPrefetch());
   }
 }
 
-TEST(LinkLoaderTest, Preconnect) {
+TEST_F(LinkLoaderTest, Preconnect) {
   struct {
     const char* href;
     CrossOriginAttributeValue cross_origin;
@@ -644,26 +668,34 @@ TEST(LinkLoaderTest, Preconnect) {
 
   // Test the cases with a single header
   for (const auto& test_case : cases) {
+    platform_->GetMockPrescientNetworking().Reset();
     std::unique_ptr<DummyPageHolder> dummy_page_holder =
         DummyPageHolder::Create(IntSize(500, 500));
     Persistent<MockLinkLoaderClient> loader_client =
         MockLinkLoaderClient::Create(test_case.should_load);
     LinkLoader* loader = LinkLoader::Create(loader_client.Get());
     KURL href_url = KURL(KURL(String("http://example.com")), test_case.href);
-    NetworkHintsMock network_hints;
     LinkLoadParameters params(
         LinkRelAttribute("preconnect"), test_case.cross_origin, String(),
         String(), String(), String(), String(), String(),
         network::mojom::ReferrerPolicy::kDefault, href_url,
         String() /* image_srcset */, String() /* image_sizes */);
-    loader->LoadLink(params, dummy_page_holder->GetDocument(), network_hints);
-    EXPECT_EQ(test_case.should_load, network_hints.DidPreconnect());
-    EXPECT_EQ(test_case.is_https, network_hints.IsHTTPS());
-    EXPECT_EQ(test_case.is_cross_origin, network_hints.IsCrossOrigin());
+    loader->LoadLink(params, dummy_page_holder->GetDocument());
+    EXPECT_EQ(test_case.should_load,
+              platform_->GetMockPrescientNetworking().DidPreconnect());
+    EXPECT_EQ(test_case.is_https,
+              platform_->GetMockPrescientNetworking().IsHTTPS());
+    if (test_case.should_load) {
+      EXPECT_NE(test_case.is_cross_origin,
+                platform_->GetMockPrescientNetworking().AllowCredentials());
+    } else {
+      EXPECT_EQ(test_case.is_cross_origin,
+                platform_->GetMockPrescientNetworking().AllowCredentials());
+    }
   }
 }
 
-TEST(LinkLoaderTest, PreloadAndPrefetch) {
+TEST_F(LinkLoaderTest, PreloadAndPrefetch) {
   std::unique_ptr<DummyPageHolder> dummy_page_holder =
       DummyPageHolder::Create(IntSize(500, 500));
   ResourceFetcher* fetcher = dummy_page_holder->GetDocument().Fetcher();
@@ -679,8 +711,7 @@ TEST(LinkLoaderTest, PreloadAndPrefetch) {
       "application/javascript", "script", "", "", "", String(),
       network::mojom::ReferrerPolicy::kDefault, href_url,
       String() /* image_srcset */, String() /* image_sizes */);
-  loader->LoadLink(params, dummy_page_holder->GetDocument(),
-                   NetworkHintsMock());
+  loader->LoadLink(params, dummy_page_holder->GetDocument());
   ASSERT_EQ(1, fetcher->CountPreloads());
   Resource* resource = loader->GetResourceForTesting();
   ASSERT_NE(resource, nullptr);

third_party/blink/renderer/core/loader/network_hints_interface.cc

-/*
- * Copyright (C) 2008 Collin Jackson  <collinj@webkit.org>
- * Copyright (C) 2013 Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
- * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include "third_party/blink/renderer/core/loader/network_hints_interface.h"
-
-#include "third_party/blink/public/platform/platform.h"
-#include "third_party/blink/public/platform/web_prescient_networking.h"
-
-namespace blink {
-
-void NetworkHintsInterfaceImpl::DnsPrefetchHost(const String& hostname) const {
-  if (WebPrescientNetworking* prescient_networking =
-          Platform::Current()->PrescientNetworking())
-    prescient_networking->PrefetchDNS(hostname);
-}
-
-void NetworkHintsInterfaceImpl::PreconnectHost(
-    const KURL& url,
-    const CrossOriginAttributeValue cross_origin) const {
-  if (WebPrescientNetworking* prescient_networking =
-          Platform::Current()->PrescientNetworking()) {
-    bool allow_credentials = (cross_origin != kCrossOriginAttributeAnonymous);
-    prescient_networking->Preconnect(url, allow_credentials);
-  }
-}
-
-}  // namespace blink

third_party/blink/renderer/core/loader/network_hints_interface.h

-// Copyright 2015 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.
-
-#ifndef THIRD_PARTY_BLINK_RENDERER_CORE_LOADER_NETWORK_HINTS_INTERFACE_H_
-#define THIRD_PARTY_BLINK_RENDERER_CORE_LOADER_NETWORK_HINTS_INTERFACE_H_
-
-#include "third_party/blink/renderer/platform/loader/fetch/cross_origin_attribute_value.h"
-#include "third_party/blink/renderer/platform/weborigin/kurl.h"
-
-namespace blink {
-
-class NetworkHintsInterface {
- public:
-  virtual void DnsPrefetchHost(const String&) const = 0;
-  virtual void PreconnectHost(const KURL&,
-                              const CrossOriginAttributeValue) const = 0;
-};
-
-class NetworkHintsInterfaceImpl : public NetworkHintsInterface {
- public:
-  void DnsPrefetchHost(const String& host) const override;
-
-  void PreconnectHost(
-      const KURL& host,
-      const CrossOriginAttributeValue cross_origin) const override;
-};
-
-}  // namespace blink
-
-#endif

third_party/blink/renderer/core/loader/preload_helper.cc

@@ -4,6 +4,8 @@
 
 #include "third_party/blink/renderer/core/loader/preload_helper.h"
 
+#include "third_party/blink/public/platform/platform.h"
+#include "third_party/blink/public/platform/web_prescient_networking.h"
 #include "third_party/blink/renderer/bindings/core/v8/v8_binding_for_core.h"
 #include "third_party/blink/renderer/core/css/media_list.h"
 #include "third_party/blink/renderer/core/css/media_query_evaluator.h"
@@ -20,7 +22,6 @@
 #include "third_party/blink/renderer/core/loader/importance_attribute.h"
 #include "third_party/blink/renderer/core/loader/link_load_parameters.h"
 #include "third_party/blink/renderer/core/loader/modulescript/module_script_fetch_request.h"
-#include "third_party/blink/renderer/core/loader/network_hints_interface.h"
 #include "third_party/blink/renderer/core/loader/resource/css_style_sheet_resource.h"
 #include "third_party/blink/renderer/core/loader/resource/font_resource.h"
 #include "third_party/blink/renderer/core/loader/resource/image_resource.h"
@@ -102,7 +103,6 @@ void PreloadHelper::DnsPrefetchIfNeeded(
     const LinkLoadParameters& params,
     Document* document,
     LocalFrame* frame,
-    const NetworkHintsInterface& network_hints_interface,
     LinkCaller caller) {
   if (params.rel.IsDNSPrefetch()) {
     UseCounter::Count(document, WebFeature::kLinkRelDnsPrefetch);
@@ -121,7 +121,11 @@ void PreloadHelper::DnsPrefetchIfNeeded(
                 String("DNS prefetch triggered for " + params.href.Host())),
             document, frame);
       }
-      network_hints_interface.DnsPrefetchHost(params.href.Host());
+      WebPrescientNetworking* web_prescient_networking =
+          Platform::Current()->PrescientNetworking();
+      if (web_prescient_networking) {
+        web_prescient_networking->PrefetchDNS(params.href.Host());
+      }
     }
   }
 }
@@ -130,7 +134,6 @@ void PreloadHelper::PreconnectIfNeeded(
     const LinkLoadParameters& params,
     Document* document,
     LocalFrame* frame,
-    const NetworkHintsInterface& network_hints_interface,
     LinkCaller caller) {
   if (params.rel.IsPreconnect() && params.href.IsValid() &&
       params.href.ProtocolIsInHTTPFamily()) {
@@ -156,7 +159,12 @@ void PreloadHelper::PreconnectIfNeeded(
             document, frame);
       }
     }
-    network_hints_interface.PreconnectHost(params.href, params.cross_origin);
+    WebPrescientNetworking* web_prescient_networking =
+        Platform::Current()->PrescientNetworking();
+    if (web_prescient_networking) {
+      web_prescient_networking->Preconnect(
+          params.href, params.cross_origin != kCrossOriginAttributeAnonymous);
+    }
   }
 }
 
@@ -445,7 +453,6 @@ void PreloadHelper::LoadLinksFromHeader(
     const KURL& base_url,
     LocalFrame& frame,
     Document* document,
-    const NetworkHintsInterface& network_hints_interface,
     CanLoadResources can_load_resources,
     MediaPreloadPolicy media_policy,
     ViewportDescriptionWrapper* viewport_description_wrapper) {
@@ -466,11 +473,9 @@ void PreloadHelper::LoadLinksFromHeader(
     if (params.href == base_url)
       continue;
     if (can_load_resources != kOnlyLoadResources) {
-      DnsPrefetchIfNeeded(params, document, &frame, network_hints_interface,
-                          kLinkCalledFromHeader);
+      DnsPrefetchIfNeeded(params, document, &frame, kLinkCalledFromHeader);
 
-      PreconnectIfNeeded(params, document, &frame, network_hints_interface,
-                         kLinkCalledFromHeader);
+      PreconnectIfNeeded(params, document, &frame, kLinkCalledFromHeader);
     }
     if (can_load_resources != kDoNotLoadResources) {
       DCHECK(document);

third_party/blink/renderer/core/loader/preload_helper.h

@@ -12,7 +12,6 @@ namespace blink {
 
 class Document;
 class LocalFrame;
-class NetworkHintsInterface;
 class SingleModuleClient;
 struct LinkLoadParameters;
 struct ViewportDescription;
@@ -39,7 +38,6 @@ class PreloadHelper final {
                                   const KURL& base_url,
                                   LocalFrame&,
                                   Document*,  // can be nullptr
-                                  const NetworkHintsInterface&,
                                   CanLoadResources,
                                   MediaPreloadPolicy,
                                   ViewportDescriptionWrapper*);
@@ -56,12 +54,10 @@ class PreloadHelper final {
   static void DnsPrefetchIfNeeded(const LinkLoadParameters&,
                                   Document*,
                                   LocalFrame*,
-                                  const NetworkHintsInterface&,
                                   LinkCaller);
   static void PreconnectIfNeeded(const LinkLoadParameters&,
                                  Document*,
                                  LocalFrame*,
-                                 const NetworkHintsInterface&,
                                  LinkCaller);
   static Resource* PrefetchIfNeeded(const LinkLoadParameters&, Document&);
   static Resource* PreloadIfNeeded(const LinkLoadParameters&,

third_party/blink/renderer/core/page/chrome_client.cc

@@ -22,6 +22,8 @@
 #include "third_party/blink/renderer/core/page/chrome_client.h"
 
 #include <algorithm>
+#include "third_party/blink/public/platform/platform.h"
+#include "third_party/blink/public/platform/web_prescient_networking.h"
 #include "third_party/blink/public/platform/web_screen_info.h"
 #include "third_party/blink/renderer/core/core_initializer.h"
 #include "third_party/blink/renderer/core/dom/document.h"
@@ -30,7 +32,6 @@
 #include "third_party/blink/renderer/core/frame/local_frame.h"
 #include "third_party/blink/renderer/core/inspector/console_message.h"
 #include "third_party/blink/renderer/core/layout/hit_test_result.h"
-#include "third_party/blink/renderer/core/loader/network_hints_interface.h"
 #include "third_party/blink/renderer/core/page/frame_tree.h"
 #include "third_party/blink/renderer/core/page/page.h"
 #include "third_party/blink/renderer/core/page/scoped_page_pauser.h"
@@ -184,8 +185,11 @@ void ChromeClient::MouseDidMoveOverElement(LocalFrame& frame,
                                            const HitTestResult& result) {
   if (!result.GetScrollbar() && result.InnerNode() &&
       result.InnerNode()->GetDocument().IsDNSPrefetchEnabled()) {
-    NetworkHintsInterfaceImpl().DnsPrefetchHost(
-        result.AbsoluteLinkURL().Host());
+    WebPrescientNetworking* web_prescient_networking =
+        Platform::Current()->PrescientNetworking();
+    if (web_prescient_networking) {
+      web_prescient_networking->PrefetchDNS(result.AbsoluteLinkURL().Host());
+    }
   }
 
   ShowMouseOverURL(result);