Picture element initial implementation

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 67 matching lines @@
 {
     ASSERT(tagImpl);
     if (match(tagImpl, imgTag))
         return imgTag.localName();
     if (match(tagImpl, inputTag))
         return inputTag.localName();
     if (match(tagImpl, linkTag))
         return linkTag.localName();
     if (match(tagImpl, scriptTag))
         return scriptTag.localName();
+#if ENABLE(PICTURE)
+    if (match(tagImpl, sourceTag))
+        return sourceTag.localName();
+    if (match(tagImpl, pictureTag))
+        return pictureTag.localName();
+#endif
     ASSERT_NOT_REACHED();
     return "unknown";
 }
 
 class TokenPreloadScanner::StartTagScanner {
 public:
-    explicit StartTagScanner(const StringImpl* tagImpl)
+    explicit StartTagScanner(const StringImpl* tagImpl
+#if ENABLE(PICTURE)
+        , bool inPicture
+#endif
+        )
         : m_tagImpl(tagImpl)
         , m_linkIsStyleSheet(false)
         , m_inputIsImage(false)
+#if ENABLE(PICTURE)
+        , m_tagInPicture(inPicture)
+#endif
     {
         if (!match(m_tagImpl, imgTag)
             && !match(m_tagImpl, inputTag)
             && !match(m_tagImpl, linkTag)
+#if ENABLE(PICTURE)
+            && !match(m_tagImpl, pictureTag)
+            && !match(m_tagImpl, sourceTag)
+#endif
             && !match(m_tagImpl, scriptTag))
             m_tagImpl = 0;
     }
 
     void processAttributes(const HTMLToken::AttributeList& attributes)
     {
         ASSERT(isMainThread());
         if (!m_tagImpl)
             return;
         for (HTMLToken::AttributeList::const_iterator iter = attributes.begin(); iter != attributes.end(); ++iter) {
@@ skipping 15 matching lines @@
     {
         if (!shouldPreload())
             return nullptr;
 
         OwnPtr<PreloadRequest> request = PreloadRequest::create(initiatorFor(m_tagImpl), m_urlToLoad, predictedBaseURL, resourceType(), m_mediaAttribute);
         request->setCrossOriginModeAllowsCookies(crossOriginModeAllowsCookies());
         request->setCharset(charset());
         return request.release();
     }
 
+#if ENABLE(PICTURE)
+    bool inPicture() { return m_tagInPicture; }
+#endif
 private:
     template<typename NameType>
     void processAttribute(const NameType& attributeName, const String& attributeValue)
     {
         if (match(attributeName, charsetAttr))
             m_charset = attributeValue;
 
-        if (match(m_tagImpl, scriptTag) || match(m_tagImpl, imgTag)) {
+        if (match(m_tagImpl, scriptTag) 
+            || match(m_tagImpl, imgTag)
+#if ENABLE(PICTURE)
+            || match(m_tagImpl, pictureTag)
+#endif
+            ) {
+            if (match(attributeName, srcAttr)) {
+                setUrlToLoad(attributeValue);
+#if ENABLE(PICTURE)
+                m_tagInPicture = false;
+#endif
+            }
+            else if (match(attributeName, crossoriginAttr) && !attributeValue.isNull())
+                m_crossOriginMode = stripLeadingAndTrailingHTMLSpaces(attributeValue);
+#if ENABLE(PICTURE)
+        } else if (match(m_tagImpl, sourceTag) && m_tagInPicture) {
             if (match(attributeName, srcAttr))
                 setUrlToLoad(attributeValue);
-            else if (match(attributeName, crossoriginAttr) && !attributeValue.isNull())
-                m_crossOriginMode = stripLeadingAndTrailingHTMLSpaces(attributeValue);
+            else if (match(attributeName, mediaAttr))
+                m_mediaAttribute = attributeValue;
+#endif
         } else if (match(m_tagImpl, linkTag)) {
             if (match(attributeName, hrefAttr))
                 setUrlToLoad(attributeValue);
             else if (match(attributeName, relAttr))
                 m_linkIsStyleSheet = relAttributeIsStyleSheet(attributeValue);
             else if (match(attributeName, mediaAttr))
                 m_mediaAttribute = attributeValue;
         } else if (match(m_tagImpl, inputTag)) {
             if (match(attributeName, srcAttr))
                 setUrlToLoad(attributeValue);
@@ skipping 22 matching lines @@
         // FIXME: Its not clear that this if is needed, the loader probably ignores charset for image requests anyway.
         if (match(m_tagImpl, imgTag))
             return emptyString();
         return m_charset;
     }
 
     CachedResource::Type resourceType() const
     {
         if (match(m_tagImpl, scriptTag))
             return CachedResource::Script;
-        if (match(m_tagImpl, imgTag) || (match(m_tagImpl, inputTag) && m_inputIsImage))
+        if (match(m_tagImpl, imgTag) 
+            || (match(m_tagImpl, inputTag) && m_inputIsImage)
+#if ENABLE(PICTURE)
+            || (match(m_tagImpl, pictureTag))
+            || (match(m_tagImpl, sourceTag))
+#endif
+            )
             return CachedResource::ImageResource;
         if (match(m_tagImpl, linkTag) && m_linkIsStyleSheet)
             return CachedResource::CSSStyleSheet;
         ASSERT_NOT_REACHED();
         return CachedResource::RawResource;
     }
 
     bool shouldPreload()
     {
         if (m_urlToLoad.isEmpty())
@@ skipping 10 matching lines @@
         return m_crossOriginMode.isNull() || equalIgnoringCase(m_crossOriginMode, "use-credentials");
     }
 
     const StringImpl* m_tagImpl;
     String m_urlToLoad;
     String m_charset;
     String m_crossOriginMode;
     bool m_linkIsStyleSheet;
     String m_mediaAttribute;
     bool m_inputIsImage;
+#if ENABLE(PICTURE)
+    bool m_tagInPicture;
+#endif
 };
 
+static void appendBundleRequest(PreloadRequestStream& requests, bool start, bool end)
+{
+    OwnPtr<PreloadRequest> request = PreloadRequest::create(start, end);
+    if (request)
+        requests.append(request.release());
+}
+
 TokenPreloadScanner::TokenPreloadScanner(const KURL& documentURL)
     : m_documentURL(documentURL)
     , m_inStyle(false)
     , m_templateCount(0)
 {
 }
 
 TokenPreloadScanner::~TokenPreloadScanner()
 {
 }
 
 TokenPreloadScannerCheckpoint TokenPreloadScanner::createCheckpoint()
 {
     TokenPreloadScannerCheckpoint checkpoint = m_checkpoints.size();
     m_checkpoints.append(Checkpoint(m_predictedBaseElementURL, m_inStyle, m_templateCount));
     return checkpoint;
 }
 
 void TokenPreloadScanner::rewindTo(TokenPreloadScannerCheckpoint checkpointIndex)
 {
     ASSERT(checkpointIndex < m_checkpoints.size()); // If this ASSERT fires, checkpointIndex is invalid.
     const Checkpoint& checkpoint = m_checkpoints[checkpointIndex];
     m_predictedBaseElementURL = checkpoint.predictedBaseElementURL;
     m_inStyle = checkpoint.inStyle;
     m_templateCount = checkpoint.templateCount;
     m_cssScanner.reset();
     m_checkpoints.clear();
 }
 
-void TokenPreloadScanner::scan(const HTMLToken& token, Vector<OwnPtr<PreloadRequest> >& requests)
+void TokenPreloadScanner::scan(const HTMLToken& token, PreloadRequestStream& requests)
 {
     scanCommon(token, requests);
 }
 
-void TokenPreloadScanner::scan(const CompactHTMLToken& token, Vector<OwnPtr<PreloadRequest> >& requests)
+void TokenPreloadScanner::scan(const CompactHTMLToken& token, PreloadRequestStream& requests)
 {
     scanCommon(token, requests);
 }
 
 template<typename Token>
-void TokenPreloadScanner::scanCommon(const Token& token, Vector<OwnPtr<PreloadRequest> >& requests)
+void TokenPreloadScanner::scanCommon(const Token& token, PreloadRequestStream& requests)
 {
     switch (token.type()) {
     case HTMLToken::Character: {
         if (!m_inStyle)
             return;
         m_cssScanner.scan(token.data(), requests);
         return;
     }
     case HTMLToken::EndTag: {
         const StringImpl* tagImpl = tagImplFor(token.data());
         if (match(tagImpl, templateTag)) {
             if (m_templateCount)
                 --m_templateCount;
             return;
         }
         if (match(tagImpl, styleTag)) {
             if (m_inStyle)
                 m_cssScanner.reset();
             m_inStyle = false;
         }
+#if ENABLE(PICTURE)
+        else if (match(tagImpl, pictureTag)) {
+            m_inPicture = false;
+            appendBundleRequest(requests, false, true);
+        }
+#endif
         return;
     }
     case HTMLToken::StartTag: {
         if (m_templateCount)
             return;
         const StringImpl* tagImpl = tagImplFor(token.data());
         if (match(tagImpl, templateTag)) {
             ++m_templateCount;
             return;
         }
         if (match(tagImpl, styleTag)) {
             m_inStyle = true;
             return;
         }
+#if ENABLE(PICTURE)
+        if (match(tagImpl, pictureTag)) {
+            m_inPicture = true;
+            appendBundleRequest(requests, true, false);
+        }
+#endif
         if (match(tagImpl, baseTag)) {
             // The first <base> element is the one that wins.
             if (!m_predictedBaseElementURL.isEmpty())
                 return;
             updatePredictedBaseURL(token);
             return;
         }
 
-        StartTagScanner scanner(tagImpl);
+        StartTagScanner scanner(tagImpl
+#if ENABLE(PICTURE)
+                                , m_inPicture
+#endif
+                                );
         scanner.processAttributes(token.attributes());
+#if ENABLE(PICTURE)
+        m_inPicture = scanner.inPicture();
+#endif
         OwnPtr<PreloadRequest> request = scanner.createPreloadRequest(m_predictedBaseElementURL);
         if (request)
             requests.append(request.release());
         return;
     }
     default: {
         return;
     }
     }
 }
@@ skipping 35 matching lines @@
         if (m_token.type() == HTMLToken::StartTag)
             m_tokenizer->updateStateFor(AtomicString(m_token.name()));
         m_scanner.scan(m_token, requests);
         m_token.clear();
     }
 
     preloader->takeAndPreload(requests);
 }
 
 }