Home | History | Annotate | Download | only in parser 
      1 /*
      2  * Copyright (C) 2008 Apple Inc. All Rights Reserved.
      3  * Copyright (C) 2009 Torch Mobile, Inc. http://www.torchmobile.com/
      4  * Copyright (C) 2010 Google Inc. All Rights Reserved.
      5  *
      6  * Redistribution and use in source and binary forms, with or without
      7  * modification, are permitted provided that the following conditions
      8  * are met:
      9  * 1. Redistributions of source code must retain the above copyright
     10  *    notice, this list of conditions and the following disclaimer.
     11  * 2. Redistributions in binary form must reproduce the above copyright
     12  *    notice, this list of conditions and the following disclaimer in the
     13  *    documentation and/or other materials provided with the distribution.
     14  *
     15  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
     16  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     18  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
     19  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
     20  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
     21  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
     22  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
     23  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
     25  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     26  */
     27 
     28 #include "config.h"
     29 #include "core/html/parser/HTMLPreloadScanner.h"
     30 
     31 #include "core/HTMLNames.h"
     32 #include "core/InputTypeNames.h"
     33 #include "core/css/MediaList.h"
     34 #include "core/css/MediaQueryEvaluator.h"
     35 #include "core/css/MediaValues.h"
     36 #include "core/css/parser/SizesAttributeParser.h"
     37 #include "core/html/LinkRelAttribute.h"
     38 #include "core/html/parser/HTMLParserIdioms.h"
     39 #include "core/html/parser/HTMLSrcsetParser.h"
     40 #include "core/html/parser/HTMLTokenizer.h"
     41 #include "platform/RuntimeEnabledFeatures.h"
     42 #include "platform/TraceEvent.h"
     43 #include "wtf/MainThread.h"
     44 
     45 namespace WebCore {
     46 
     47 using namespace HTMLNames;
     48 
     49 static bool match(const StringImpl* impl, const QualifiedName& qName)
     50 {
     51     return impl == qName.localName().impl();
     52 }
     53 
     54 static bool match(const AtomicString& name, const QualifiedName& qName)
     55 {
     56     ASSERT(isMainThread());
     57     return qName.localName() == name;
     58 }
     59 
     60 static bool match(const String& name, const QualifiedName& qName)
     61 {
     62     return threadSafeMatch(name, qName);
     63 }
     64 
     65 static const StringImpl* tagImplFor(const HTMLToken::DataVector& data)
     66 {
     67     AtomicString tagName(data);
     68     const StringImpl* result = tagName.impl();
     69     if (result->isStatic())
     70         return result;
     71     return 0;
     72 }
     73 
     74 static const StringImpl* tagImplFor(const String& tagName)
     75 {
     76     const StringImpl* result = tagName.impl();
     77     if (result->isStatic())
     78         return result;
     79     return 0;
     80 }
     81 
     82 static String initiatorFor(const StringImpl* tagImpl)
     83 {
     84     ASSERT(tagImpl);
     85     if (match(tagImpl, imgTag))
     86         return imgTag.localName();
     87     if (match(tagImpl, inputTag))
     88         return inputTag.localName();
     89     if (match(tagImpl, linkTag))
     90         return linkTag.localName();
     91     if (match(tagImpl, scriptTag))
     92         return scriptTag.localName();
     93     ASSERT_NOT_REACHED();
     94     return emptyString();
     95 }
     96 
     97 static bool mediaAttributeMatches(const MediaValues& mediaValues, const String& attributeValue)
     98 {
     99     RefPtrWillBeRawPtr<MediaQuerySet> mediaQueries = MediaQuerySet::createOffMainThread(attributeValue);
    100     MediaQueryEvaluator mediaQueryEvaluator("screen", mediaValues);
    101     return mediaQueryEvaluator.eval(mediaQueries.get());
    102 }
    103 
    104 class TokenPreloadScanner::StartTagScanner {
    105 public:
    106     StartTagScanner(const StringImpl* tagImpl, PassRefPtr<MediaValues> mediaValues)
    107         : m_tagImpl(tagImpl)
    108         , m_linkIsStyleSheet(false)
    109         , m_matchedMediaAttribute(true)
    110         , m_inputIsImage(false)
    111         , m_sourceSize(0)
    112         , m_sourceSizeSet(false)
    113         , m_isCORSEnabled(false)
    114         , m_allowCredentials(DoNotAllowStoredCredentials)
    115         , m_mediaValues(mediaValues)
    116     {
    117         if (match(m_tagImpl, imgTag)
    118             || match(m_tagImpl, sourceTag)) {
    119             if (RuntimeEnabledFeatures::pictureSizesEnabled())
    120                 m_sourceSize = SizesAttributeParser::findEffectiveSize(String(), m_mediaValues);
    121             return;
    122         }
    123         if ( !match(m_tagImpl, inputTag)
    124             && !match(m_tagImpl, linkTag)
    125             && !match(m_tagImpl, scriptTag))
    126             m_tagImpl = 0;
    127     }
    128 
    129     enum URLReplacement {
    130         AllowURLReplacement,
    131         DisallowURLReplacement
    132     };
    133 
    134     void processAttributes(const HTMLToken::AttributeList& attributes)
    135     {
    136         ASSERT(isMainThread());
    137         if (!m_tagImpl)
    138             return;
    139         for (HTMLToken::AttributeList::const_iterator iter = attributes.begin(); iter != attributes.end(); ++iter) {
    140             AtomicString attributeName(iter->name);
    141             String attributeValue = StringImpl::create8BitIfPossible(iter->value);
    142             processAttribute(attributeName, attributeValue);
    143         }
    144     }
    145 
    146     void processAttributes(const Vector<CompactHTMLToken::Attribute>& attributes)
    147     {
    148         if (!m_tagImpl)
    149             return;
    150         for (Vector<CompactHTMLToken::Attribute>::const_iterator iter = attributes.begin(); iter != attributes.end(); ++iter)
    151             processAttribute(iter->name, iter->value);
    152     }
    153 
    154     void handlePictureSourceURL(String& sourceURL)
    155     {
    156         if (match(m_tagImpl, sourceTag) && m_matchedMediaAttribute && sourceURL.isEmpty())
    157             sourceURL = m_srcsetImageCandidate.toString();
    158         else if (match(m_tagImpl, imgTag) && !sourceURL.isEmpty())
    159             setUrlToLoad(sourceURL, AllowURLReplacement);
    160     }
    161 
    162     PassOwnPtr<PreloadRequest> createPreloadRequest(const KURL& predictedBaseURL, const SegmentedString& source)
    163     {
    164         if (!shouldPreload() || !m_matchedMediaAttribute)
    165             return nullptr;
    166 
    167         TRACE_EVENT_INSTANT1("net", "PreloadRequest", "url", m_urlToLoad.ascii());
    168         TextPosition position = TextPosition(source.currentLine(), source.currentColumn());
    169         OwnPtr<PreloadRequest> request = PreloadRequest::create(initiatorFor(m_tagImpl), position, m_urlToLoad, predictedBaseURL, resourceType());
    170         if (isCORSEnabled())
    171             request->setCrossOriginEnabled(allowStoredCredentials());
    172         request->setCharset(charset());
    173         return request.release();
    174     }
    175 
    176 private:
    177     template<typename NameType>
    178     void processScriptAttribute(const NameType& attributeName, const String& attributeValue)
    179     {
    180         // FIXME - Don't set crossorigin multiple times.
    181         if (match(attributeName, srcAttr))
    182             setUrlToLoad(attributeValue, DisallowURLReplacement);
    183         else if (match(attributeName, crossoriginAttr))
    184             setCrossOriginAllowed(attributeValue);
    185     }
    186 
    187     template<typename NameType>
    188     void processImgAttribute(const NameType& attributeName, const String& attributeValue)
    189     {
    190         if (match(attributeName, srcAttr) && m_imgSrcUrl.isNull()) {
    191             m_imgSrcUrl = attributeValue;
    192             setUrlToLoad(bestFitSourceForImageAttributes(m_mediaValues->devicePixelRatio(), m_sourceSize, attributeValue, m_srcsetImageCandidate), AllowURLReplacement);
    193         } else if (match(attributeName, crossoriginAttr)) {
    194             setCrossOriginAllowed(attributeValue);
    195         } else if (match(attributeName, srcsetAttr) && m_srcsetImageCandidate.isEmpty()) {
    196             m_srcsetAttributeValue = attributeValue;
    197             m_srcsetImageCandidate = bestFitSourceForSrcsetAttribute(m_mediaValues->devicePixelRatio(), m_sourceSize, attributeValue);
    198             setUrlToLoad(bestFitSourceForImageAttributes(m_mediaValues->devicePixelRatio(), m_sourceSize, m_imgSrcUrl, m_srcsetImageCandidate), AllowURLReplacement);
    199         } else if (RuntimeEnabledFeatures::pictureSizesEnabled() && match(attributeName, sizesAttr) && !m_sourceSizeSet) {
    200             m_sourceSize = SizesAttributeParser::findEffectiveSize(attributeValue, m_mediaValues);
    201             m_sourceSizeSet = true;
    202             if (!m_srcsetImageCandidate.isEmpty()) {
    203                 m_srcsetImageCandidate = bestFitSourceForSrcsetAttribute(m_mediaValues->devicePixelRatio(), m_sourceSize, m_srcsetAttributeValue);
    204                 setUrlToLoad(bestFitSourceForImageAttributes(m_mediaValues->devicePixelRatio(), m_sourceSize, m_imgSrcUrl, m_srcsetImageCandidate), AllowURLReplacement);
    205             }
    206         }
    207     }
    208 
    209     template<typename NameType>
    210     void processLinkAttribute(const NameType& attributeName, const String& attributeValue)
    211     {
    212         // FIXME - Don't set rel/media/crossorigin multiple times.
    213         if (match(attributeName, hrefAttr))
    214             setUrlToLoad(attributeValue, DisallowURLReplacement);
    215         else if (match(attributeName, relAttr))
    216             m_linkIsStyleSheet = relAttributeIsStyleSheet(attributeValue);
    217         else if (match(attributeName, mediaAttr))
    218             m_matchedMediaAttribute = mediaAttributeMatches(*m_mediaValues, attributeValue);
    219         else if (match(attributeName, crossoriginAttr))
    220             setCrossOriginAllowed(attributeValue);
    221     }
    222 
    223     template<typename NameType>
    224     void processInputAttribute(const NameType& attributeName, const String& attributeValue)
    225     {
    226         // FIXME - Don't set type multiple times.
    227         if (match(attributeName, srcAttr))
    228             setUrlToLoad(attributeValue, DisallowURLReplacement);
    229         else if (match(attributeName, typeAttr))
    230             m_inputIsImage = equalIgnoringCase(attributeValue, InputTypeNames::image);
    231     }
    232 
    233     template<typename NameType>
    234     void processSourceAttribute(const NameType& attributeName, const String& attributeValue)
    235     {
    236         if (!RuntimeEnabledFeatures::pictureEnabled())
    237             return;
    238         if (match(attributeName, srcsetAttr) && m_srcsetImageCandidate.isEmpty()) {
    239             m_srcsetAttributeValue = attributeValue;
    240             m_srcsetImageCandidate = bestFitSourceForSrcsetAttribute(m_mediaValues->devicePixelRatio(), m_sourceSize, attributeValue);
    241         } else if (match(attributeName, sizesAttr) && !m_sourceSizeSet) {
    242             m_sourceSize = SizesAttributeParser::findEffectiveSize(attributeValue, m_mediaValues);
    243             m_sourceSizeSet = true;
    244             if (!m_srcsetImageCandidate.isEmpty()) {
    245                 m_srcsetImageCandidate = bestFitSourceForSrcsetAttribute(m_mediaValues->devicePixelRatio(), m_sourceSize, m_srcsetAttributeValue);
    246             }
    247         } else if (match(attributeName, mediaAttr)) {
    248             // FIXME - Don't match media multiple times.
    249             m_matchedMediaAttribute = mediaAttributeMatches(*m_mediaValues, attributeValue);
    250         }
    251 
    252     }
    253 
    254     template<typename NameType>
    255     void processAttribute(const NameType& attributeName, const String& attributeValue)
    256     {
    257         if (match(attributeName, charsetAttr))
    258             m_charset = attributeValue;
    259 
    260         if (match(m_tagImpl, scriptTag))
    261             processScriptAttribute(attributeName, attributeValue);
    262         else if (match(m_tagImpl, imgTag))
    263             processImgAttribute(attributeName, attributeValue);
    264         else if (match(m_tagImpl, linkTag))
    265             processLinkAttribute(attributeName, attributeValue);
    266         else if (match(m_tagImpl, inputTag))
    267             processInputAttribute(attributeName, attributeValue);
    268         else if (match(m_tagImpl, sourceTag))
    269             processSourceAttribute(attributeName, attributeValue);
    270     }
    271 
    272     static bool relAttributeIsStyleSheet(const String& attributeValue)
    273     {
    274         LinkRelAttribute rel(attributeValue);
    275         return rel.isStyleSheet() && !rel.isAlternate() && rel.iconType() == InvalidIcon && !rel.isDNSPrefetch();
    276     }
    277 
    278     void setUrlToLoad(const String& value, URLReplacement replacement)
    279     {
    280         // We only respect the first src/href, per HTML5:
    281         // http://www.whatwg.org/specs/web-apps/current-work/multipage/tokenization.html#attribute-name-state
    282         if (replacement == DisallowURLReplacement && !m_urlToLoad.isEmpty())
    283             return;
    284         String url = stripLeadingAndTrailingHTMLSpaces(value);
    285         if (url.isEmpty())
    286             return;
    287         m_urlToLoad = url;
    288     }
    289 
    290     const String& charset() const
    291     {
    292         // FIXME: Its not clear that this if is needed, the loader probably ignores charset for image requests anyway.
    293         if (match(m_tagImpl, imgTag))
    294             return emptyString();
    295         return m_charset;
    296     }
    297 
    298     Resource::Type resourceType() const
    299     {
    300         if (match(m_tagImpl, scriptTag))
    301             return Resource::Script;
    302         if (match(m_tagImpl, imgTag) || (match(m_tagImpl, inputTag) && m_inputIsImage))
    303             return Resource::Image;
    304         if (match(m_tagImpl, linkTag) && m_linkIsStyleSheet)
    305             return Resource::CSSStyleSheet;
    306         ASSERT_NOT_REACHED();
    307         return Resource::Raw;
    308     }
    309 
    310     bool shouldPreload() const
    311     {
    312         if (m_urlToLoad.isEmpty())
    313             return false;
    314         if (match(m_tagImpl, linkTag) && !m_linkIsStyleSheet)
    315             return false;
    316         if (match(m_tagImpl, inputTag) && !m_inputIsImage)
    317             return false;
    318         return true;
    319     }
    320 
    321     bool isCORSEnabled() const
    322     {
    323         return m_isCORSEnabled;
    324     }
    325 
    326     StoredCredentials allowStoredCredentials() const
    327     {
    328         return m_allowCredentials;
    329     }
    330 
    331     void setCrossOriginAllowed(const String& corsSetting)
    332     {
    333         m_isCORSEnabled = true;
    334         if (!corsSetting.isNull() && equalIgnoringCase(stripLeadingAndTrailingHTMLSpaces(corsSetting), "use-credentials"))
    335             m_allowCredentials = AllowStoredCredentials;
    336         else
    337             m_allowCredentials = DoNotAllowStoredCredentials;
    338     }
    339 
    340     const StringImpl* m_tagImpl;
    341     String m_urlToLoad;
    342     ImageCandidate m_srcsetImageCandidate;
    343     String m_charset;
    344     bool m_linkIsStyleSheet;
    345     bool m_matchedMediaAttribute;
    346     bool m_inputIsImage;
    347     String m_imgSrcUrl;
    348     String m_srcsetAttributeValue;
    349     unsigned m_sourceSize;
    350     bool m_sourceSizeSet;
    351     bool m_isCORSEnabled;
    352     StoredCredentials m_allowCredentials;
    353     RefPtr<MediaValues> m_mediaValues;
    354 };
    355 
    356 TokenPreloadScanner::TokenPreloadScanner(const KURL& documentURL, PassRefPtr<MediaValues> mediaValues)
    357     : m_documentURL(documentURL)
    358     , m_inStyle(false)
    359     , m_inPicture(false)
    360     , m_templateCount(0)
    361     , m_mediaValues(mediaValues)
    362 {
    363 }
    364 
    365 TokenPreloadScanner::~TokenPreloadScanner()
    366 {
    367 }
    368 
    369 TokenPreloadScannerCheckpoint TokenPreloadScanner::createCheckpoint()
    370 {
    371     TokenPreloadScannerCheckpoint checkpoint = m_checkpoints.size();
    372     m_checkpoints.append(Checkpoint(m_predictedBaseElementURL, m_inStyle, m_templateCount));
    373     return checkpoint;
    374 }
    375 
    376 void TokenPreloadScanner::rewindTo(TokenPreloadScannerCheckpoint checkpointIndex)
    377 {
    378     ASSERT(checkpointIndex < m_checkpoints.size()); // If this ASSERT fires, checkpointIndex is invalid.
    379     const Checkpoint& checkpoint = m_checkpoints[checkpointIndex];
    380     m_predictedBaseElementURL = checkpoint.predictedBaseElementURL;
    381     m_inStyle = checkpoint.inStyle;
    382     m_templateCount = checkpoint.templateCount;
    383     m_cssScanner.reset();
    384     m_checkpoints.clear();
    385 }
    386 
    387 void TokenPreloadScanner::scan(const HTMLToken& token, const SegmentedString& source, PreloadRequestStream& requests)
    388 {
    389     scanCommon(token, source, requests);
    390 }
    391 
    392 void TokenPreloadScanner::scan(const CompactHTMLToken& token, const SegmentedString& source, PreloadRequestStream& requests)
    393 {
    394     scanCommon(token, source, requests);
    395 }
    396 
    397 template<typename Token>
    398 void TokenPreloadScanner::scanCommon(const Token& token, const SegmentedString& source, PreloadRequestStream& requests)
    399 {
    400     switch (token.type()) {
    401     case HTMLToken::Character: {
    402         if (!m_inStyle)
    403             return;
    404         m_cssScanner.scan(token.data(), source, requests);
    405         return;
    406     }
    407     case HTMLToken::EndTag: {
    408         const StringImpl* tagImpl = tagImplFor(token.data());
    409         if (match(tagImpl, templateTag)) {
    410             if (m_templateCount)
    411                 --m_templateCount;
    412             return;
    413         }
    414         if (match(tagImpl, styleTag)) {
    415             if (m_inStyle)
    416                 m_cssScanner.reset();
    417             m_inStyle = false;
    418             return;
    419         }
    420         if (match(tagImpl, pictureTag))
    421             m_inPicture = false;
    422         return;
    423     }
    424     case HTMLToken::StartTag: {
    425         if (m_templateCount)
    426             return;
    427         const StringImpl* tagImpl = tagImplFor(token.data());
    428         if (match(tagImpl, templateTag)) {
    429             ++m_templateCount;
    430             return;
    431         }
    432         if (match(tagImpl, styleTag)) {
    433             m_inStyle = true;
    434             return;
    435         }
    436         if (match(tagImpl, baseTag)) {
    437             // The first <base> element is the one that wins.
    438             if (!m_predictedBaseElementURL.isEmpty())
    439                 return;
    440             updatePredictedBaseURL(token);
    441             return;
    442         }
    443         if (RuntimeEnabledFeatures::pictureEnabled() && (match(tagImpl, pictureTag))) {
    444             m_inPicture = true;
    445             m_pictureSourceURL = String();
    446             return;
    447         }
    448 
    449         StartTagScanner scanner(tagImpl, m_mediaValues);
    450         scanner.processAttributes(token.attributes());
    451         if (m_inPicture)
    452             scanner.handlePictureSourceURL(m_pictureSourceURL);
    453         OwnPtr<PreloadRequest> request = scanner.createPreloadRequest(m_predictedBaseElementURL, source);
    454         if (request)
    455             requests.append(request.release());
    456         return;
    457     }
    458     default: {
    459         return;
    460     }
    461     }
    462 }
    463 
    464 template<typename Token>
    465 void TokenPreloadScanner::updatePredictedBaseURL(const Token& token)
    466 {
    467     ASSERT(m_predictedBaseElementURL.isEmpty());
    468     if (const typename Token::Attribute* hrefAttribute = token.getAttributeItem(hrefAttr))
    469         m_predictedBaseElementURL = KURL(m_documentURL, stripLeadingAndTrailingHTMLSpaces(hrefAttribute->value)).copy();
    470 }
    471 
    472 HTMLPreloadScanner::HTMLPreloadScanner(const HTMLParserOptions& options, const KURL& documentURL, PassRefPtr<MediaValues> mediaValues)
    473     : m_scanner(documentURL, mediaValues)
    474     , m_tokenizer(HTMLTokenizer::create(options))
    475 {
    476 }
    477 
    478 HTMLPreloadScanner::~HTMLPreloadScanner()
    479 {
    480 }
    481 
    482 void HTMLPreloadScanner::appendToEnd(const SegmentedString& source)
    483 {
    484     m_source.append(source);
    485 }
    486 
    487 void HTMLPreloadScanner::scan(HTMLResourcePreloader* preloader, const KURL& startingBaseElementURL)
    488 {
    489     ASSERT(isMainThread()); // HTMLTokenizer::updateStateFor only works on the main thread.
    490 
    491     TRACE_EVENT1("webkit", "HTMLPreloadScanner::scan", "source_length", m_source.length());
    492 
    493     // When we start scanning, our best prediction of the baseElementURL is the real one!
    494     if (!startingBaseElementURL.isEmpty())
    495         m_scanner.setPredictedBaseElementURL(startingBaseElementURL);
    496 
    497     PreloadRequestStream requests;
    498 
    499     while (m_tokenizer->nextToken(m_source, m_token)) {
    500         if (m_token.type() == HTMLToken::StartTag)
    501             m_tokenizer->updateStateFor(attemptStaticStringCreation(m_token.name(), Likely8Bit));
    502         m_scanner.scan(m_token, m_source, requests);
    503         m_token.clear();
    504     }
    505 
    506     preloader->takeAndPreload(requests);
    507 }
    508 
    509 }
    510