Prerender: Disable prefetch if there's an appcache.

third_party/WebKit/Source/core/html/parser/HTMLPreloadScanner.cpp

 /*
  * Copyright (C) 2008 Apple Inc. All Rights Reserved.
  * Copyright (C) 2009 Torch Mobile, Inc. http://www.torchmobile.com/
  * Copyright (C) 2010 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.
@@ skipping 519 matching lines @@
 };
 
 TokenPreloadScanner::TokenPreloadScanner(
     const KURL& documentURL,
     std::unique_ptr<CachedDocumentParameters> documentParameters,
     const MediaValuesCached::MediaValuesCachedData& mediaValuesCachedData)
     : m_documentURL(documentURL),
       m_inStyle(false),
       m_inPicture(false),
       m_inScript(false),
+      m_isAppCacheEnabled(false),
       m_templateCount(0),
       m_documentParameters(std::move(documentParameters)),
       m_mediaValues(MediaValuesCached::create(mediaValuesCachedData)),
       m_didRewind(false) {
   DCHECK(m_documentParameters.get());
   DCHECK(m_mediaValues.get());
   DCHECK(documentURL.isValid());
   m_cssScanner.setReferrerPolicy(m_documentParameters->referrerPolicy);
 }
 
 TokenPreloadScanner::~TokenPreloadScanner() {}
 
 TokenPreloadScannerCheckpoint TokenPreloadScanner::createCheckpoint() {
   TokenPreloadScannerCheckpoint checkpoint = m_checkpoints.size();
   m_checkpoints.push_back(Checkpoint(m_predictedBaseElementURL, m_inStyle,
-                                     m_inScript, m_templateCount));
+                                     m_inScript, m_isAppCacheEnabled,
+                                     m_templateCount));
   return checkpoint;
 }
 
 void TokenPreloadScanner::rewindTo(
     TokenPreloadScannerCheckpoint checkpointIndex) {
   // If this ASSERT fires, checkpointIndex is invalid.
   ASSERT(checkpointIndex < m_checkpoints.size());
   const Checkpoint& checkpoint = m_checkpoints[checkpointIndex];
   m_predictedBaseElementURL = checkpoint.predictedBaseElementURL;
   m_inStyle = checkpoint.inStyle;
+  m_isAppCacheEnabled = checkpoint.isAppCacheEnabled;
   m_templateCount = checkpoint.templateCount;
 
   m_didRewind = true;
   m_inScript = checkpoint.inScript;
 
   m_cssScanner.reset();
   m_checkpoints.clear();
 }
 
 void TokenPreloadScanner::scan(const HTMLToken& token,
@@ skipping 132 matching lines @@
 template <typename Token>
 void TokenPreloadScanner::scanCommon(const Token& token,
                                      const SegmentedString& source,
                                      PreloadRequestStream& requests,
                                      ViewportDescriptionWrapper* viewport,
                                      bool* isCSPMetaTag,
                                      bool* likelyDocumentWriteScript) {
   if (!m_documentParameters->doHtmlPreloadScanning)
     return;
 
+  // If the document is prefetching, AppCache support has not yet been enabled,
+  // and fetches will go to the network even if there is an AppCache
+  // manifest. Therefore if a manifest is seen prefetching is stopped to avoid
+  // incorrect behavior.
+  if (m_documentParameters->isPrefetchOnly && m_isAppCacheEnabled)

[michaeln, 2017/03/27 23:27:44]

Could this be done more directly and with less code in the renderer?

Prior to HTMLPreloadScannerConstruction in the renderer, does the Document have
it's mainResourceResponse? If so, would it make sense to replace the test in the
firstg snapshot for appCached'ness with a different test based on the value of
ResourceResponse.appCacheID(). The CachedDocumentParameters struct could be
modified tell is if the doc was loaded from an appcache.


CachedDocumentParameters::CachedDocumentParameters(Document* document) {
  DCHECK(isMainThread());
  DCHECK(document);
  ...
  isLoadedFromAppCache = document->loader()->response().appCacheID() != 0;
  ...
}

Here we could test...

  if (m_documentParameters->isPrefetchOnly &&
      m_documentParameters->isLoadedFromAppCache) {
    return;
  }

+    return;
+
   switch (token.type()) {
     case HTMLToken::Character: {
       if (m_inStyle) {
         m_cssScanner.scan(token.data(), source, requests,
                           m_predictedBaseElementURL);
       } else if (m_inScript && likelyDocumentWriteScript && !m_didRewind) {
         // Don't mark scripts for evaluation if the preloader rewound to a
         // previous checkpoint. This could cause re-evaluation of scripts if
         // care isn't given.
         // TODO(csharrison): Revisit this if rewinds are low hanging fruit for
@@ skipping 41 matching lines @@
       if (match(tagImpl, scriptTag)) {
         m_inScript = true;
       }
       if (match(tagImpl, baseTag)) {
         // The first <base> element is the one that wins.
         if (!m_predictedBaseElementURL.isEmpty())
           return;
         updatePredictedBaseURL(token);
         return;
       }
+      if (match(tagImpl, htmlTag) && token.getAttributeItem(manifestAttr)) {
+        m_isAppCacheEnabled = true;
+        return;
+      }
       if (match(tagImpl, metaTag)) {
         const typename Token::Attribute* equivAttribute =
             token.getAttributeItem(http_equivAttr);
         if (equivAttribute) {
           String equivAttributeValue(equivAttribute->value());
           if (equalIgnoringCase(equivAttributeValue,
                                 "content-security-policy")) {
             *isCSPMetaTag = true;
           } else if (equalIgnoringCase(equivAttributeValue, "accept-ch")) {
             const typename Token::Attribute* contentAttribute =
@@ skipping 100 matching lines @@
       !document->settings() || document->settings()->getDoHtmlPreloadScanning();
   doDocumentWritePreloadScanning = doHtmlPreloadScanning && document->frame() &&
                                    document->frame()->isMainFrame();
   defaultViewportMinWidth = document->viewportDefaultMinWidth();
   viewportMetaZeroValuesQuirk =
       document->settings() &&
       document->settings()->getViewportMetaZeroValuesQuirk();
   viewportMetaEnabled =
       document->settings() && document->settings()->getViewportMetaEnabled();
   referrerPolicy = document->getReferrerPolicy();
+  isPrefetchOnly = document->isPrefetchOnly();
 }
 
 }  // namespace blink