Refactor HTMLLinkElement

third_party/WebKit/Source/core/html/LinkStyle.cpp

 // 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 "core/html/LinkStyle.h"
 
+#include "core/HTMLNames.h"
 #include "core/css/StyleSheetContents.h"
+#include "core/fetch/FetchRequest.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/SubresourceIntegrity.h"
 #include "core/frame/csp/ContentSecurityPolicy.h"
 #include "core/html/CrossOriginAttribute.h"
 #include "core/html/HTMLLinkElement.h"
+#include "core/html/imports/HTMLImportsController.h"
 #include "core/loader/FrameLoaderClient.h"
 #include "core/loader/resource/CSSStyleSheetResource.h"
 #include "platform/ContentType.h"
 #include "platform/Histogram.h"
 #include "platform/MIMETypeRegistry.h"
+#include "platform/weborigin/KURL.h"
+#include "wtf/text/WTFString.h"
 
 namespace blink {
 
 using namespace HTMLNames;
 
 static bool styleSheetTypeIsSupported(const String& type) {
   String trimmedType = ContentType(type).type();
   return trimmedType.isEmpty() ||
          MIMETypeRegistry::isSupportedStyleSheetMIMEType(trimmedType);
 }
@@ skipping 10 matching lines @@
       m_firedLoad(false),
       m_loadedSheet(false),
       m_fetchFollowingCORS(false) {}
 
 LinkStyle::~LinkStyle() {}
 
 Document& LinkStyle::document() {
   return m_owner->document();
 }
 
+const Document& LinkStyle::document() const {
+  return m_owner->document();
+}
+
 enum StyleSheetCacheStatus {
   StyleSheetNewEntry,
   StyleSheetInDiskCache,
   StyleSheetInMemoryCache,
   StyleSheetCacheStatusCount,
 };
 
 void LinkStyle::setCSSStyleSheet(
     const String& href,
     const KURL& baseURL,
@@ skipping 42 matching lines @@
 
     if (disposition == ResourceIntegrityDisposition::Failed) {
       m_loading = false;
       removePendingSheet();
       notifyLoadedSheetAndAllCriticalSubresources(
           Node::ErrorOccurredLoadingSubresource);
       return;
     }
   }
 
-  CSSParserContext parserContext(m_owner->document(), nullptr, baseURL,
-                                 charset);
+  CSSParserContext parserContext(document(), nullptr, baseURL, charset);
 
   DEFINE_STATIC_LOCAL(EnumerationHistogram, restoredCachedStyleSheetHistogram,
                       ("Blink.RestoredCachedStyleSheet", 2));
   DEFINE_STATIC_LOCAL(
       EnumerationHistogram, restoredCachedStyleSheet2Histogram,
       ("Blink.RestoredCachedStyleSheet2", StyleSheetCacheStatusCount));
 
   if (StyleSheetContents* restoredSheet =
           const_cast<CSSStyleSheetResource*>(cachedStyleSheet)
               ->restoreParsedStyleSheet(parserContext)) {
     DCHECK(restoredSheet->isCacheableForResource());
     DCHECK(!restoredSheet->isLoading());
 
     if (m_sheet)
       clearSheet();
     m_sheet = CSSStyleSheet::create(restoredSheet, *m_owner);
     m_sheet->setMediaQueries(MediaQuerySet::create(m_owner->media()));
     if (m_owner->isInDocumentTree())
       setSheetTitle(m_owner->title());
-    setCrossOriginStylesheetStatus(m_sheet.get());
+    setCrossOriginStylesheetStatus();
 
     m_loading = false;
     restoredSheet->checkLoaded();
 
     restoredCachedStyleSheetHistogram.count(true);
     restoredCachedStyleSheet2Histogram.count(StyleSheetInMemoryCache);
     return;
   }
   restoredCachedStyleSheetHistogram.count(false);
   StyleSheetCacheStatus cacheStatus = cachedStyleSheet->response().wasCached()
                                           ? StyleSheetInDiskCache
                                           : StyleSheetNewEntry;
   restoredCachedStyleSheet2Histogram.count(cacheStatus);
 
   StyleSheetContents* styleSheet =
       StyleSheetContents::create(href, parserContext);
 
   if (m_sheet)
     clearSheet();
 
   m_sheet = CSSStyleSheet::create(styleSheet, *m_owner);
   m_sheet->setMediaQueries(MediaQuerySet::create(m_owner->media()));
   if (m_owner->isInDocumentTree())
     setSheetTitle(m_owner->title());
-  setCrossOriginStylesheetStatus(m_sheet.get());
+  setCrossOriginStylesheetStatus();
 
   styleSheet->parseAuthorStyleSheet(cachedStyleSheet,
-                                    m_owner->document().getSecurityOrigin());
+                                    document().getSecurityOrigin());
 
   m_loading = false;
   styleSheet->notifyLoadedSheet(cachedStyleSheet);
   styleSheet->checkLoaded();
 
   if (styleSheet->isCacheableForResource()) {
     const_cast<CSSStyleSheetResource*>(cachedStyleSheet)
         ->saveParsedStyleSheet(styleSheet);
   }
   clearResource();
@@ skipping 36 matching lines @@
   return m_sheet->contents()->isLoading();
 }
 
 void LinkStyle::addPendingSheet(PendingSheetType type) {
   if (type <= m_pendingSheetType)
     return;
   m_pendingSheetType = type;
 
   if (m_pendingSheetType == NonBlocking)
     return;
-  m_owner->document().styleEngine().addPendingSheet(m_styleEngineContext);
+  document().styleEngine().addPendingSheet(m_styleEngineContext);
 }
 
 void LinkStyle::removePendingSheet() {
   DCHECK(m_owner);
   PendingSheetType type = m_pendingSheetType;
   m_pendingSheetType = None;
 
   if (type == None)
     return;
   if (type == NonBlocking) {
     // Tell StyleEngine to re-compute styleSheets of this m_owner's treescope.
-    m_owner->document().styleEngine().modifiedStyleSheetCandidateNode(*m_owner);
+    document().styleEngine().modifiedStyleSheetCandidateNode(*m_owner);
     return;
   }
 
-  m_owner->document().styleEngine().removePendingSheet(*m_owner,
-                                                       m_styleEngineContext);
+  document().styleEngine().removePendingSheet(*m_owner, m_styleEngineContext);
 }
 
 void LinkStyle::setDisabledState(bool disabled) {
   LinkStyle::DisabledState oldDisabledState = m_disabledState;
   m_disabledState = disabled ? Disabled : EnabledViaScript;
-  if (oldDisabledState != m_disabledState) {
-    // If we change the disabled state while the sheet is still loading, then we
-    // have to perform three checks:
-    if (styleSheetIsLoading()) {
-      // Check #1: The sheet becomes disabled while loading.
-      if (m_disabledState == Disabled)
-        removePendingSheet();
+  if (oldDisabledState == m_disabledState)
+    return;
 
-      // Check #2: An alternate sheet becomes enabled while it is still loading.
-      if (m_owner->relAttribute().isAlternate() &&
-          m_disabledState == EnabledViaScript)
-        addPendingSheet(Blocking);
+  // If we change the disabled state while the sheet is still loading, then we
+  // have to perform three checks:
+  if (styleSheetIsLoading()) {
+    // Check #1: The sheet becomes disabled while loading.
+    if (m_disabledState == Disabled)
+      removePendingSheet();
 
-      // Check #3: A main sheet becomes enabled while it was still loading and
-      // after it was disabled via script. It takes really terrible code to make
-      // this happen (a double toggle for no reason essentially). This happens
-      // on virtualplastic.net, which manages to do about 12 enable/disables on
-      // only 3 sheets. :)
-      if (!m_owner->relAttribute().isAlternate() &&
-          m_disabledState == EnabledViaScript && oldDisabledState == Disabled)
-        addPendingSheet(Blocking);
+    // Check #2: An alternate sheet becomes enabled while it is still loading.
+    if (m_owner->relAttribute().isAlternate() &&
+        m_disabledState == EnabledViaScript)
+      addPendingSheet(Blocking);
 
-      // If the sheet is already loading just bail.
-      return;
-    }
+    // Check #3: A main sheet becomes enabled while it was still loading and
+    // after it was disabled via script. It takes really terrible code to make
+    // this happen (a double toggle for no reason essentially). This happens
+    // on virtualplastic.net, which manages to do about 12 enable/disables on
+    // only 3 sheets. :)
+    if (!m_owner->relAttribute().isAlternate() &&
+        m_disabledState == EnabledViaScript && oldDisabledState == Disabled)
+      addPendingSheet(Blocking);
 
-    if (m_sheet) {
-      m_sheet->setDisabled(disabled);
-      return;
-    }
+    // If the sheet is already loading just bail.
+    return;
+  }
 
-    if (m_disabledState == EnabledViaScript && m_owner->shouldProcessStyle())
-      process();
+  if (m_sheet) {
+    m_sheet->setDisabled(disabled);
+    return;
   }
+
+  if (m_disabledState == EnabledViaScript && m_owner->shouldProcessStyle())
+    process();
 }
 
-void LinkStyle::setCrossOriginStylesheetStatus(CSSStyleSheet* sheet) {
+void LinkStyle::setCrossOriginStylesheetStatus() {
   if (m_fetchFollowingCORS && resource() && !resource()->errorOccurred()) {
     // Record the security origin the CORS access check succeeded at, if cross
     // origin.  Only origins that are script accessible to it may access the
     // stylesheet's rules.
-    sheet->setAllowRuleAccessFromOrigin(
-        m_owner->document().getSecurityOrigin());
+    m_sheet->setAllowRuleAccessFromOrigin(document().getSecurityOrigin());
   }
   m_fetchFollowingCORS = false;
 }
 
+bool LinkStyle::shouldLoadResource() const {
+  return document().frame() || document().importsController();
+}
+
 // TODO(yoav): move that logic to LinkLoader
-LinkStyle::LoadReturnValue LinkStyle::loadStylesheetIfNeeded(
-    const LinkRequestBuilder& builder,
-    const String& type) {
+void LinkStyle::loadStylesheetIfNeeded(const String& type) {
+  const KURL& href = m_owner->getNonEmptyURLAttribute(hrefAttr);
+
   if (m_disabledState == Disabled || !m_owner->relAttribute().isStyleSheet() ||
       !styleSheetTypeIsSupported(type) || !shouldLoadResource() ||
-      !builder.url().isValid())
-    return NotNeeded;
+      !href.isValid()) {
+    if (!m_sheet)
+      return;
+
+    // we no longer contain a stylesheet, e.g. perhaps rel or type was changed
+    StyleSheet* removedSheet = m_sheet.get();
+    clearSheet();
+    document().styleEngine().setNeedsActiveStyleUpdate(removedSheet,
+                                                       FullStyleUpdate);
+    return;
+  }
 
   if (resource()) {
     removePendingSheet();
     clearResource();
-    clearFetchFollowingCORS();
+    m_fetchFollowingCORS = false;
   }
 
-  if (!m_owner->shouldLoadLink())
-    return Bail;
+  if (m_owner->shouldLoadLink())
+    loadStylesheet();
+}
 
+LocalFrame* LinkStyle::loadingFrame() const {
+  HTMLImportsController* importsController = document().importsController();
+  if (!importsController)
+    return document().frame();
+  return importsController->master()->frame();
+}
+
+void LinkStyle::loadStylesheet() {
   m_loading = true;
 
   String title = m_owner->title();
   if (!title.isEmpty() && !m_owner->isAlternate() &&
       m_disabledState != EnabledViaScript && m_owner->isInDocumentTree()) {
     document().styleEngine().setPreferredStylesheetSetNameIfNotSet(
         title, StyleEngine::DontUpdateActiveSheets);
   }
 
   bool mediaQueryMatches = true;
   LocalFrame* frame = loadingFrame();
   if (!m_owner->media().isEmpty() && frame) {
     MediaQuerySet* media = MediaQuerySet::create(m_owner->media());
     MediaQueryEvaluator evaluator(frame);
     mediaQueryMatches = evaluator.eval(media);
   }
 
   // Don't hold up layout tree construction and script execution on
   // stylesheets that are not needed for the layout at the moment.
   bool blocking = mediaQueryMatches && !m_owner->isAlternate() &&
                   m_owner->isCreatedByParser();
   addPendingSheet(blocking ? Blocking : NonBlocking);
 
+  FetchRequest request = m_owner->createFetchRequest();
+
   // Load stylesheets that are not needed for the layout immediately with low
   // priority.  When the link element is created by scripts, load the
   // stylesheets asynchronously but in high priority.
-  bool lowPriority = !mediaQueryMatches || m_owner->isAlternate();
-  FetchRequest request = builder.build(lowPriority);
+  if (!mediaQueryMatches || m_owner->isAlternate())
+    request.setDefer(FetchRequest::LazyLoad);
+
   CrossOriginAttributeValue crossOrigin = crossOriginAttributeValue(
       m_owner->fastGetAttribute(HTMLNames::crossoriginAttr));
   if (crossOrigin != CrossOriginAttributeNotSet) {
     request.setCrossOriginAccessControl(document().getSecurityOrigin(),
                                         crossOrigin);
-    setFetchFollowingCORS();
+    DCHECK(!m_fetchFollowingCORS);
+    m_fetchFollowingCORS = true;
   }
 
   String integrityAttr = m_owner->fastGetAttribute(HTMLNames::integrityAttr);
   if (!integrityAttr.isEmpty()) {
     IntegrityMetadataSet metadataSet;
     SubresourceIntegrity::parseIntegrityAttribute(integrityAttr, metadataSet);
     request.setIntegrityMetadata(metadataSet);
   }
   setResource(CSSStyleSheetResource::fetch(request, document().fetcher()));
 
-  if (m_loading && !resource()) {
-    // The request may have been denied if (for example) the stylesheet is
-    // local and the document is remote, or if there was a Content Security
-    // Policy Failure.  setCSSStyleSheet() can be called synchronuosly in
-    // setResource() and thus resource() is null and |m_loading| is false in
-    // such cases even if the request succeeds.
-    m_loading = false;
-    removePendingSheet();
-    notifyLoadedSheetAndAllCriticalSubresources(
-        Node::ErrorOccurredLoadingSubresource);
-  }
-  return Loaded;
+  if (!m_loading || resource())
+    return;
+
+  // The request may have been denied if (for example) the stylesheet is
+  // local and the document is remote, or if there was a Content Security
+  // Policy Failure.  setCSSStyleSheet() can be called synchronuosly in
+  // setResource() and thus resource() is null and |m_loading| is false in
+  // such cases even if the request succeeds.
+  m_loading = false;
+  removePendingSheet();
+  notifyLoadedSheetAndAllCriticalSubresources(
+      Node::ErrorOccurredLoadingSubresource);
 }
 
 void LinkStyle::process() {
   DCHECK(m_owner->shouldProcessStyle());
+
   String type = m_owner->typeValue().lower();
   String as = m_owner->asValue().lower();
   String media = m_owner->media().lower();
-  LinkRequestBuilder builder(m_owner);
 
-  if (m_owner->relAttribute().getIconType() != InvalidIcon &&
-      builder.url().isValid() && !builder.url().isEmpty()) {
+  const KURL& href = m_owner->getNonEmptyURLAttribute(hrefAttr);
+
+  if (m_owner->relAttribute().getIconType() != InvalidIcon && href.isValid() &&
+      !href.isEmpty()) {
     if (!m_owner->shouldLoadLink())
       return;
-    if (!document().getSecurityOrigin()->canDisplay(builder.url()))
+    if (!document().getSecurityOrigin()->canDisplay(href))
       return;
-    if (!document().contentSecurityPolicy()->allowImageFromSource(
-            builder.url()))
+    if (!document().contentSecurityPolicy()->allowImageFromSource(href))
       return;
     if (document().frame() && document().frame()->loader().client()) {
       document().frame()->loader().client()->dispatchDidChangeIcons(
           m_owner->relAttribute().getIconType());
     }
   }
 
-  if (!m_owner->loadLink(type, as, media, m_owner->referrerPolicy(),
-                         builder.url()))
-    return;
-
-  if (loadStylesheetIfNeeded(builder, type) == NotNeeded && m_sheet) {
-    // we no longer contain a stylesheet, e.g. perhaps rel or type was changed
-    StyleSheet* removedSheet = m_sheet.get();
-    clearSheet();
-    document().styleEngine().setNeedsActiveStyleUpdate(removedSheet,
-                                                       FullStyleUpdate);
-  }
+  if (m_owner->loadLink(type, as, media, m_owner->referrerPolicy(), href))
+    loadStylesheetIfNeeded(type);
 }
 
 void LinkStyle::setSheetTitle(
     const String& title,
     StyleEngine::ActiveSheetsUpdate updateActiveSheets) {
   if (!m_owner->isInDocumentTree() || !m_owner->relAttribute().isStyleSheet())
     return;
 
   if (m_sheet)
     m_sheet->setTitle(title);
 
   if (title.isEmpty() || !isUnset() || m_owner->isAlternate())
     return;
 
-  KURL href = m_owner->getNonEmptyURLAttribute(hrefAttr);
+  const KURL& href = m_owner->getNonEmptyURLAttribute(hrefAttr);
   if (href.isValid() && !href.isEmpty()) {
     document().styleEngine().setPreferredStylesheetSetNameIfNotSet(
         title, updateActiveSheets);
   }
 }
 
 void LinkStyle::ownerRemoved() {
   if (m_sheet)
     clearSheet();
 
   if (styleSheetIsLoading())
     removePendingSheet();
 }
 
 DEFINE_TRACE(LinkStyle) {
   visitor->trace(m_sheet);
   LinkResource::trace(visitor);
   ResourceOwner<StyleSheetResource>::trace(visitor);
 }
 
 }  // namespace blink