[preload] Mandatory `as` value and related spec alignments

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 208 matching lines @@
   } else if (as == "style") {
     return Resource::kCSSStyleSheet;
   } else if (as == "video") {
     return Resource::kMedia;
   } else if (as == "audio") {
     return Resource::kMedia;
   } else if (as == "track") {
     return Resource::kTextTrack;
   } else if (as == "font") {
     return Resource::kFont;
-  } else if (as.IsEmpty()) {
+  } else if (as == "fetch") {
     return Resource::kRaw;
   }
   return WTF::nullopt;
 }
 
 Resource* LinkLoader::LinkPreloadedResourceForTesting() {
   return link_preload_resource_client_
              ? link_preload_resource_client_->GetResource()
              : nullptr;
 }
@@ skipping 55 matching lines @@
 }
 
 static Resource* PreloadIfNeeded(const LinkRelAttribute& rel_attribute,
                                  const KURL& href,
                                  Document& document,
                                  const String& as,
                                  const String& mime_type,
                                  const String& media,
                                  CrossOriginAttributeValue cross_origin,
                                  LinkCaller caller,
-                                 bool& error_occurred,
                                  ViewportDescription* viewport_description,
                                  ReferrerPolicy referrer_policy) {
   if (!document.Loader() || !rel_attribute.IsLinkPreload())
     return nullptr;
 
   UseCounter::Count(document, UseCounter::kLinkRelPreload);
   if (!href.IsValid() || href.IsEmpty()) {
     document.AddConsoleMessage(ConsoleMessage::Create(
         kOtherMessageSource, kWarningMessageLevel,
         String("<link rel=preload> has an invalid `href` value")));
@@ skipping 16 matching lines @@
       return nullptr;
   }
   if (caller == kLinkCalledFromHeader)
     UseCounter::Count(document, UseCounter::kLinkHeaderPreload);
   Optional<Resource::Type> resource_type =
       LinkLoader::GetResourceTypeFromAsAttribute(as);
   if (resource_type == WTF::nullopt) {
     document.AddConsoleMessage(ConsoleMessage::Create(
         kOtherMessageSource, kWarningMessageLevel,
         String("<link rel=preload> must have a valid `as` value")));
-    error_occurred = true;
     return nullptr;
   }
 
   if (!IsSupportedType(resource_type.value(), mime_type)) {
     document.AddConsoleMessage(ConsoleMessage::Create(
         kOtherMessageSource, kWarningMessageLevel,
         String("<link rel=preload> has an unsupported `type` value")));
     return nullptr;
   }
   ResourceRequest resource_request(document.CompleteURL(href));
@@ skipping 78 matching lines @@
     if (can_load_resources != kOnlyLoadResources) {
       DnsPrefetchIfNeeded(rel_attribute, url, document, &frame,
                           network_hints_interface, kLinkCalledFromHeader);
 
       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);
+                      kLinkCalledFromHeader, viewport_description,
+                      kReferrerPolicyDefault);
       PrefetchIfNeeded(*document, url, rel_attribute, cross_origin,
                        kReferrerPolicyDefault);
     }
     if (rel_attribute.IsServiceWorker()) {
       UseCounter::Count(&frame, UseCounter::kLinkHeaderServiceWorker);
     }
     // TODO(yoav): Add more supported headers as needed.
   }
 }
 
@@ skipping 10 matching lines @@
   if (!client_->ShouldLoadLink())
     return false;
 
   DnsPrefetchIfNeeded(rel_attribute, href, &document, document.GetFrame(),
                       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);
+      kLinkCalledFromMarkup, nullptr, referrer_policy));
 
   if (href.IsEmpty() || !href.IsValid())
     Released();
 
   Resource* resource = PrefetchIfNeeded(document, href, rel_attribute,
                                         cross_origin, referrer_policy);
   if (resource)
     SetResource(resource);
 
   if (const unsigned prerender_rel_types =
@@ skipping 27 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