Drop GetFrame()->GetDocument() usage in FrameFetchContext

third_party/WebKit/Source/core/loader/LinkLoader.cpp

 /*
  * Copyright (C) 2011 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 16 matching lines @@
  * (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 "core/loader/LinkLoader.h"
 
 #include "core/css/MediaList.h"
 #include "core/css/MediaQueryEvaluator.h"
 #include "core/dom/Document.h"
+#include "core/frame/FrameConsole.h"
+#include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/frame/UseCounter.h"
 #include "core/html/CrossOriginAttribute.h"
 #include "core/html/LinkRelAttribute.h"
 #include "core/html/parser/HTMLPreloadScanner.h"
 #include "core/inspector/ConsoleMessage.h"
 #include "core/loader/DocumentLoader.h"
 #include "core/loader/NetworkHintsInterface.h"
 #include "core/loader/private/PrerenderHandle.h"
 #include "core/loader/resource/LinkFetchResource.h"
@@ skipping 74 matching lines @@
 
 void LinkLoader::DidSendDOMContentLoadedForPrerender() {
   client_->DidSendDOMContentLoadedForLinkPrerender();
 }
 
 enum LinkCaller {
   kLinkCalledFromHeader,
   kLinkCalledFromMarkup,
 };
 
+static void SendMessageToConsoleForPossiblyNullDocument(

[Nate Chapin, 2017/04/28 21:33:31]

I hate this name, but I don't have a better idea. It's a similar problem to the
one in FrameFetchContext::AddConsoleMessage.

[kinuko, 2017/04/29 14:10:20]

Maybe add the same comment with the one in FrameFetchContext?

+    ConsoleMessage* console_message,
+    Document* document,
+    LocalFrame* frame) {
+  DCHECK(document || frame);
+  DCHECK(!document || document->GetFrame() == frame);
+  if (document)
+    document->AddConsoleMessage(console_message);
+  else
+    frame->Console().AddMessage(console_message);
+}
+
 static void DnsPrefetchIfNeeded(
     const LinkRelAttribute& rel_attribute,
     const KURL& href,
-    Document& document,
+    Document* document,
+    LocalFrame* frame,
     const NetworkHintsInterface& network_hints_interface,
     LinkCaller caller) {
   if (rel_attribute.IsDNSPrefetch()) {
-    UseCounter::Count(document, UseCounter::kLinkRelDnsPrefetch);
+    UseCounter::Count(frame, UseCounter::kLinkRelDnsPrefetch);
     if (caller == kLinkCalledFromHeader)
-      UseCounter::Count(document, UseCounter::kLinkHeaderDnsPrefetch);
-    Settings* settings = document.GetSettings();
+      UseCounter::Count(frame, UseCounter::kLinkHeaderDnsPrefetch);
+    Settings* settings = frame ? frame->GetSettings() : nullptr;
     // FIXME: The href attribute of the link element can be in "//hostname"
     // form, and we shouldn't attempt to complete that as URL
     // <https://bugs.webkit.org/show_bug.cgi?id=48857>.
     if (settings && settings->GetDNSPrefetchingEnabled() && href.IsValid() &&
         !href.IsEmpty()) {
       if (settings->GetLogDnsPrefetchAndPreconnect()) {
-        document.AddConsoleMessage(ConsoleMessage::Create(
-            kOtherMessageSource, kVerboseMessageLevel,
-            String("DNS prefetch triggered for " + href.Host())));
+        SendMessageToConsoleForPossiblyNullDocument(
+            ConsoleMessage::Create(
+                kOtherMessageSource, kVerboseMessageLevel,
+                String("DNS prefetch triggered for " + href.Host())),
+            document, frame);
       }
       network_hints_interface.DnsPrefetchHost(href.Host());
     }
   }
 }
 
 static void PreconnectIfNeeded(
     const LinkRelAttribute& rel_attribute,
     const KURL& href,
-    Document& document,
+    Document* document,
+    LocalFrame* frame,
     const CrossOriginAttributeValue cross_origin,
     const NetworkHintsInterface& network_hints_interface,
     LinkCaller caller) {
   if (rel_attribute.IsPreconnect() && href.IsValid() &&
       href.ProtocolIsInHTTPFamily()) {
-    UseCounter::Count(document, UseCounter::kLinkRelPreconnect);
+    UseCounter::Count(frame, UseCounter::kLinkRelPreconnect);
     if (caller == kLinkCalledFromHeader)
-      UseCounter::Count(document, UseCounter::kLinkHeaderPreconnect);
-    Settings* settings = document.GetSettings();
+      UseCounter::Count(frame, UseCounter::kLinkHeaderPreconnect);
+    Settings* settings = frame ? frame->GetSettings() : nullptr;
     if (settings && settings->GetLogDnsPrefetchAndPreconnect()) {
-      document.AddConsoleMessage(ConsoleMessage::Create(
-          kOtherMessageSource, kVerboseMessageLevel,
-          String("Preconnect triggered for ") + href.GetString()));
+      SendMessageToConsoleForPossiblyNullDocument(
+          ConsoleMessage::Create(
+              kOtherMessageSource, kVerboseMessageLevel,
+              String("Preconnect triggered for ") + href.GetString()),
+          document, frame);
       if (cross_origin != kCrossOriginAttributeNotSet) {
-        document.AddConsoleMessage(ConsoleMessage::Create(
-            kOtherMessageSource, kVerboseMessageLevel,
-            String("Preconnect CORS setting is ") +
-                String((cross_origin == kCrossOriginAttributeAnonymous)
-                           ? "anonymous"
-                           : "use-credentials")));
+        SendMessageToConsoleForPossiblyNullDocument(
+            ConsoleMessage::Create(
+                kOtherMessageSource, kVerboseMessageLevel,
+                String("Preconnect CORS setting is ") +
+                    String((cross_origin == kCrossOriginAttributeAnonymous)
+                               ? "anonymous"
+                               : "use-credentials")),
+            document, frame);
       }
     }
     network_hints_interface.PreconnectHost(href, cross_origin);
   }
 }
 
 WTF::Optional<Resource::Type> LinkLoader::GetResourceTypeFromAsAttribute(
     const String& as) {
   DCHECK_EQ(as.DeprecatedLower(), as);
   if (as == "image") {
@@ skipping 182 matching lines @@
     }
     return LinkFetchResource::Fetch(Resource::kLinkPrefetch, link_fetch_params,
                                     document.Fetcher());
   }
   return nullptr;
 }
 
 void LinkLoader::LoadLinksFromHeader(
     const String& header_value,
     const KURL& base_url,
+    LocalFrame& frame,
     Document* document,
     const NetworkHintsInterface& network_hints_interface,
     CanLoadResources can_load_resources,
     MediaPreloadPolicy media_policy,
     ViewportDescriptionWrapper* viewport_description_wrapper) {
-  if (!document || header_value.IsEmpty())
+  if (header_value.IsEmpty())
     return;
   LinkHeaderSet header_set(header_value);
   for (auto& header : header_set) {
     if (!header.Valid() || header.Url().IsEmpty() || header.Rel().IsEmpty())
       continue;
 
     if (media_policy == kOnlyLoadMedia && header.Media().IsEmpty())
       continue;
     if (media_policy == kOnlyLoadNonMedia && !header.Media().IsEmpty())
       continue;
 
     LinkRelAttribute rel_attribute(header.Rel());
     KURL url(base_url, header.Url());
     // Sanity check to avoid re-entrancy here.
     if (url == base_url)
       continue;
     if (can_load_resources != kOnlyLoadResources) {
-      DnsPrefetchIfNeeded(rel_attribute, url, *document,
+      DnsPrefetchIfNeeded(rel_attribute, url, document, &frame,
                           network_hints_interface, kLinkCalledFromHeader);
 
-      PreconnectIfNeeded(rel_attribute, url, *document,
+      PreconnectIfNeeded(rel_attribute, url, document, &frame,
                          GetCrossOriginAttributeValue(header.CrossOrigin()),
                          network_hints_interface, kLinkCalledFromHeader);
     }
     if (can_load_resources != kDoNotLoadResources) {
+      DCHECK(document);
       bool error_occurred = false;
       ViewportDescription* viewport_description =
           (viewport_description_wrapper && viewport_description_wrapper->set)
               ? &(viewport_description_wrapper->description)
               : nullptr;
 
       CrossOriginAttributeValue cross_origin =
           GetCrossOriginAttributeValue(header.CrossOrigin());
       PreloadIfNeeded(rel_attribute, url, *document, header.As(),
                       header.MimeType(), header.Media(), cross_origin,
                       kLinkCalledFromHeader, error_occurred,
                       viewport_description, kReferrerPolicyDefault);
       PrefetchIfNeeded(*document, url, rel_attribute, cross_origin,
                        kReferrerPolicyDefault);
     }
     if (rel_attribute.IsServiceWorker()) {
-      UseCounter::Count(*document, UseCounter::kLinkHeaderServiceWorker);
+      UseCounter::Count(&frame, UseCounter::kLinkHeaderServiceWorker);
     }
     // TODO(yoav): Add more supported headers as needed.
   }
 }
 
 bool LinkLoader::LoadLink(
     const LinkRelAttribute& rel_attribute,
     CrossOriginAttributeValue cross_origin,
     const String& type,
     const String& as,
     const String& media,
     ReferrerPolicy referrer_policy,
     const KURL& href,
     Document& document,
     const NetworkHintsInterface& network_hints_interface) {
   if (!client_->ShouldLoadLink())
     return false;
 
-  DnsPrefetchIfNeeded(rel_attribute, href, document, network_hints_interface,
-                      kLinkCalledFromMarkup);
+  DnsPrefetchIfNeeded(rel_attribute, href, &document, document.GetFrame(),
+                      network_hints_interface, kLinkCalledFromMarkup);
 
-  PreconnectIfNeeded(rel_attribute, href, document, cross_origin,
-                     network_hints_interface, kLinkCalledFromMarkup);
+  PreconnectIfNeeded(rel_attribute, href, &document, document.GetFrame(),
+                     cross_origin, network_hints_interface,
+                     kLinkCalledFromMarkup);
 
   bool error_occurred = false;
   CreateLinkPreloadResourceClient(PreloadIfNeeded(
       rel_attribute, href, document, as, type, media, cross_origin,
       kLinkCalledFromMarkup, error_occurred, nullptr, referrer_policy));
   if (error_occurred)
     link_loading_error_timer_.StartOneShot(0, BLINK_FROM_HERE);
 
   if (href.IsEmpty() || !href.IsValid())
     Released();
@@ skipping 34 matching lines @@
 
 DEFINE_TRACE(LinkLoader) {
   visitor->Trace(client_);
   visitor->Trace(prerender_);
   visitor->Trace(link_preload_resource_client_);
   ResourceOwner<Resource, ResourceClient>::Trace(visitor);
   PrerenderClient::Trace(visitor);
 }
 
 }  // namespace blink