Add <meta viewport> support to the preloader

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 14 matching lines @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "core/html/parser/HTMLPreloadScanner.h"
 
 #include "core/HTMLNames.h"
 #include "core/InputTypeNames.h"
 #include "core/css/MediaList.h"
 #include "core/css/MediaQueryEvaluator.h"
+#include "core/css/MediaValuesCached.h"
 #include "core/css/parser/SizesAttributeParser.h"
+#include "core/dom/Document.h"
+#include "core/frame/Settings.h"
+#include "core/html/HTMLMetaElement.h"
 #include "core/html/LinkRelAttribute.h"
 #include "core/html/parser/HTMLParserIdioms.h"
 #include "core/html/parser/HTMLSrcsetParser.h"
 #include "core/html/parser/HTMLTokenizer.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/TraceEvent.h"
 #include "wtf/MainThread.h"
 
 namespace blink {
 
@@ skipping 63 matching lines @@
         , m_linkIsStyleSheet(false)
         , m_matchedMediaAttribute(true)
         , m_inputIsImage(false)
         , m_sourceSize(0)
         , m_sourceSizeSet(false)
         , m_isCORSEnabled(false)
         , m_defer(FetchRequest::NoDefer)
         , m_allowCredentials(DoNotAllowStoredCredentials)
         , m_mediaValues(mediaValues)
     {
+        ASSERT(m_mediaValues->isCached());
         if (match(m_tagImpl, imgTag)
             || match(m_tagImpl, sourceTag)) {
             m_sourceSize = SizesAttributeParser(m_mediaValues, String()).length();
             return;
         }
         if ( !match(m_tagImpl, inputTag)
             && !match(m_tagImpl, linkTag)
             && !match(m_tagImpl, scriptTag)
             && !match(m_tagImpl, videoTag))
             m_tagImpl = 0;
@@ skipping 247 matching lines @@
     String m_imgSrcUrl;
     String m_srcsetAttributeValue;
     float m_sourceSize;
     bool m_sourceSizeSet;
     bool m_isCORSEnabled;
     FetchRequest::DeferOption m_defer;
     StoredCredentials m_allowCredentials;
     RefPtr<MediaValues> m_mediaValues;
 };
 
-TokenPreloadScanner::TokenPreloadScanner(const KURL& documentURL, PassRefPtr<MediaValues> mediaValues)
+TokenPreloadScanner::TokenPreloadScanner(const KURL& documentURL, PassOwnPtr<CachedDocumentParameters> documentParameters)
     : m_documentURL(documentURL)
     , m_inStyle(false)
     , m_inPicture(false)
     , m_isAppCacheEnabled(false)
     , m_isCSPEnabled(false)
     , m_templateCount(0)
-    , m_mediaValues(mediaValues)
+    , m_documentParameters(documentParameters)
 {
+    ASSERT(m_documentParameters.get());
+    ASSERT(m_documentParameters->mediaValues.get());
+    ASSERT(m_documentParameters->mediaValues->isCached());
 }
 
 TokenPreloadScanner::~TokenPreloadScanner()
 {
 }
 
 TokenPreloadScannerCheckpoint TokenPreloadScanner::createCheckpoint()
 {
     TokenPreloadScannerCheckpoint checkpoint = m_checkpoints.size();
     m_checkpoints.append(Checkpoint(m_predictedBaseElementURL, m_inStyle, m_isAppCacheEnabled, m_isCSPEnabled, m_templateCount));
@@ skipping 80 matching lines @@
         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 && equalIgnoringCase(String(equivAttribute->value), "content-security-policy")) {
                 m_isCSPEnabled = true;
                 return;
             }
+            const typename Token::Attribute* nameAttribute = token.getAttributeItem(nameAttr);
+            if (nameAttribute && equalIgnoringCase(String(nameAttribute->value), "viewport")) {
+                const typename Token::Attribute* contentAttribute = token.getAttributeItem(contentAttr);
+
+                if (contentAttribute) {
+                    ViewportDescription description(ViewportDescription::ViewportMeta);
+                    HTMLMetaElement::getViewportDescriptionFromContentAttribute(String(contentAttribute->value), description, nullptr, m_documentParameters->viewportMetaZeroValuesQuirk);
+                    FloatSize initialViewport(m_documentParameters->mediaValues->viewportHeight(), m_documentParameters->mediaValues->viewportWidth());
+                    PageScaleConstraints constraints = description.resolve(initialViewport, m_documentParameters->defaultViewportMinWidth);
+                    MediaValuesCached* cachedMediaValues = static_cast<MediaValuesCached*>(m_documentParameters->mediaValues.get());
+                    cachedMediaValues->setViewportHeight(constraints.layoutSize.height());
+                    cachedMediaValues->setViewportWidth(constraints.layoutSize.width());
+                }
+            }
         }
 
         if (RuntimeEnabledFeatures::pictureEnabled() && (match(tagImpl, pictureTag))) {
             m_inPicture = true;
             m_pictureSourceURL = String();
             return;
         }
 
-        StartTagScanner scanner(tagImpl, m_mediaValues);
+        StartTagScanner scanner(tagImpl, m_documentParameters->mediaValues);
         scanner.processAttributes(token.attributes());
         if (m_inPicture)
             scanner.handlePictureSourceURL(m_pictureSourceURL);
         OwnPtr<PreloadRequest> request = scanner.createPreloadRequest(m_predictedBaseElementURL, source);
         if (request)
             requests.append(request.release());
         return;
     }
     default: {
         return;
     }
     }
 }
 
 template<typename Token>
 void TokenPreloadScanner::updatePredictedBaseURL(const Token& token)
 {
     ASSERT(m_predictedBaseElementURL.isEmpty());
     if (const typename Token::Attribute* hrefAttribute = token.getAttributeItem(hrefAttr)) {
         KURL url(m_documentURL, stripLeadingAndTrailingHTMLSpaces(hrefAttribute->value));
         m_predictedBaseElementURL = url.isValid() ? url.copy() : KURL();
     }
 }
 
-HTMLPreloadScanner::HTMLPreloadScanner(const HTMLParserOptions& options, const KURL& documentURL, PassRefPtr<MediaValues> mediaValues)
-    : m_scanner(documentURL, mediaValues)
+HTMLPreloadScanner::HTMLPreloadScanner(const HTMLParserOptions& options, const KURL& documentURL, PassOwnPtr<CachedDocumentParameters> documentParameters)
+    : m_scanner(documentURL, documentParameters)
     , m_tokenizer(HTMLTokenizer::create(options))
 {
 }
 
 HTMLPreloadScanner::~HTMLPreloadScanner()
 {
 }
 
 void HTMLPreloadScanner::appendToEnd(const SegmentedString& source)
 {
@@ skipping 15 matching lines @@
     while (m_tokenizer->nextToken(m_source, m_token)) {
         if (m_token.type() == HTMLToken::StartTag)
             m_tokenizer->updateStateFor(attemptStaticStringCreation(m_token.name(), Likely8Bit));
         m_scanner.scan(m_token, m_source, requests);
         m_token.clear();
     }
 
     preloader->takeAndPreload(requests);
 }
 
+CachedDocumentParameters::CachedDocumentParameters(Document* document, PassRefPtr<MediaValues> givenMediaValues)
+{
+    ASSERT(isMainThread());
+    ASSERT(document);
+    if (givenMediaValues)
+        mediaValues = givenMediaValues;
+    else
+        mediaValues = MediaValuesCached::create(*document);
+    ASSERT(mediaValues->isSafeToSendToAnotherThread());
+    defaultViewportMinWidth = document->viewportDefaultMinWidth();
+    viewportMetaZeroValuesQuirk = document->settings() && document->settings()->viewportMetaZeroValuesQuirk();
 }
+
+}