Add console errors and usecounter when srcset candidates are dropped

Source/core/html/parser/HTMLSrcsetParser.cpp

 /*
  * Copyright (C) 2013 Apple Inc. All rights reserved.
  * Copyright (C) 2013 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 14 matching lines @@
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "core/html/parser/HTMLSrcsetParser.h"
 
+#include "core/dom/Document.h"
+#include "core/frame/FrameConsole.h"
+#include "core/frame/LocalFrame.h"
+#include "core/frame/UseCounter.h"
 #include "core/html/parser/HTMLParserIdioms.h"
+#include "core/inspector/ConsoleMessage.h"
 #include "platform/ParsingUtilities.h"
 #include "platform/RuntimeEnabledFeatures.h"
 
 namespace blink {
 
 static bool compareByDensity(const ImageCandidate& first, const ImageCandidate& second)
 {
     return first.density() < second.density();
 }
 
 enum DescriptorTokenizerState {
-    Start,
+    TokenStart,
     InParenthesis,
     AfterToken,
 };
 
 struct DescriptorToken {
     unsigned start;
     unsigned length;
 
     DescriptorToken(unsigned start, unsigned length)
         : start(start)
@@ skipping 59 matching lines @@
 {
     return position >= end;
 }
 
 template<typename CharType>
 static void tokenizeDescriptors(const CharType* attributeStart,
     const CharType*& position,
     const CharType* attributeEnd,
     Vector<DescriptorToken>& descriptors)
 {
-    DescriptorTokenizerState state = Start;
+    DescriptorTokenizerState state = TokenStart;
     const CharType* descriptorsStart = position;
     const CharType* currentDescriptorStart = descriptorsStart;
     while (true) {
         switch (state) {
-        case Start:
+        case TokenStart:
             if (isEOF(position, attributeEnd)) {
                 appendDescriptorAndReset(attributeStart, currentDescriptorStart, attributeEnd, descriptors);
                 return;
             }
             if (isComma(*position)) {
                 appendDescriptorAndReset(attributeStart, currentDescriptorStart, position, descriptors);
                 ++position;
                 return;
             }
             if (isHTMLSpace(*position)) {
                 appendDescriptorAndReset(attributeStart, currentDescriptorStart, position, descriptors);
                 currentDescriptorStart = position + 1;
                 state = AfterToken;
             } else if (*position == '(') {
                 appendCharacter(currentDescriptorStart, position);
                 state = InParenthesis;
             } else {
                 appendCharacter(currentDescriptorStart, position);
             }
             break;
         case InParenthesis:
             if (isEOF(position, attributeEnd)) {
                 appendDescriptorAndReset(attributeStart, currentDescriptorStart, attributeEnd, descriptors);
                 return;
             }
             if (*position == ')') {
                 appendCharacter(currentDescriptorStart, position);
-                state = Start;
+                state = TokenStart;
             } else {
                 appendCharacter(currentDescriptorStart, position);
             }
             break;
         case AfterToken:
             if (isEOF(position, attributeEnd))
                 return;
             if (!isHTMLSpace(*position)) {
-                state = Start;
+                state = TokenStart;
                 currentDescriptorStart = position;
                 --position;
             }
             break;
         }
         ++position;
     }
 }
 
+static void consoleMessage(Document* document, String message)
+{
+    if (document && document->frame())
+        document->frame()->console().addMessage(ConsoleMessage::create(OtherMessageSource, ErrorMessageLevel, message));
+}
+
 template<typename CharType>
-static bool parseDescriptors(const CharType* attribute, Vector<DescriptorToken>& descriptors, DescriptorParsingResult& result)
+static bool parseDescriptors(const CharType* attribute, Vector<DescriptorToken>& descriptors, DescriptorParsingResult& result, Document* document)
 {
     for (Vector<DescriptorToken>::iterator it = descriptors.begin(); it != descriptors.end(); ++it) {
         if (it->length == 0)
             continue;
         CharType c = attribute[it->lastIndex()];
         bool isValid = false;
         if (RuntimeEnabledFeatures::pictureSizesEnabled() && c == 'w') {
-            if (result.hasDensity() || result.hasWidth())
+            if (result.hasDensity() || result.hasWidth()) {
+                consoleMessage(document, "srcset has multiple 'w' descriptors or a mix of 'x' and 'w' descriptors.");
                 return false;
+            }
             int resourceWidth = it->toInt(attribute, isValid);
-            if (!isValid || resourceWidth <= 0)
+            if (!isValid || resourceWidth <= 0) {
+                consoleMessage(document, "srcset 'w' descriptor is invalid.");
                 return false;
+            }
             result.setResourceWidth(resourceWidth);
         } else if (RuntimeEnabledFeatures::pictureSizesEnabled() && c == 'h') {
             // This is here only for future compat purposes.
             // The value of the 'h' descriptor is not used.
-            if (result.hasDensity() || result.hasHeight())
+            if (result.hasDensity() || result.hasHeight()) {
+                consoleMessage(document, "srcset has multiple 'h' descriptors or a mix of 'x' and 'h' descriptors.");
                 return false;
+            }
             int resourceHeight = it->toInt(attribute, isValid);
-            if (!isValid || resourceHeight <= 0)
+            if (!isValid || resourceHeight <= 0) {
+                consoleMessage(document, "srcset 'h' descriptor is invalid.");
                 return false;
+            }
             result.setResourceHeight(resourceHeight);
         } else if (c == 'x') {
-            if (result.hasDensity() || result.hasHeight() || result.hasWidth())
+            if (result.hasDensity() || result.hasHeight() || result.hasWidth()) {
+                consoleMessage(document, "srcset has multiple 'x' descriptors or a mix of 'x' and 'w'/'h' descriptors.");
                 return false;
+            }
             float density = it->toFloat(attribute, isValid);
-            if (!isValid || density < 0)
+            if (!isValid || density < 0) {
+                consoleMessage(document, "srcset 'x' descriptor is invalid.");
                 return false;
+            }
             result.setDensity(density);
         } else {
+            consoleMessage(document, "srcset has an unknown descriptor.");
             return false;
         }
     }
-    return (!result.hasHeight() || result.hasWidth());
+    bool res = !result.hasHeight() || result.hasWidth();
+    if (!res)
+        consoleMessage(document, "srcset has an 'h' descriptor and no 'w' descriptor.");
+    return res;
 }
 
-static bool parseDescriptors(const String& attribute, Vector<DescriptorToken>& descriptors, DescriptorParsingResult& result)
+static bool parseDescriptors(const String& attribute, Vector<DescriptorToken>& descriptors, DescriptorParsingResult& result, Document* document)
 {
     // FIXME: See if StringView can't be extended to replace DescriptorToken here.
     if (attribute.is8Bit()) {
-        return parseDescriptors(attribute.characters8(), descriptors, result);
+        return parseDescriptors(attribute.characters8(), descriptors, result, document);
     }
-    return parseDescriptors(attribute.characters16(), descriptors, result);
+    return parseDescriptors(attribute.characters16(), descriptors, result, document);
 }
 
 // http://picture.responsiveimages.org/#parse-srcset-attr
 template<typename CharType>
-static void parseImageCandidatesFromSrcsetAttribute(const String& attribute, const CharType* attributeStart, unsigned length, Vector<ImageCandidate>& imageCandidates)
+static void parseImageCandidatesFromSrcsetAttribute(const String& attribute, const CharType* attributeStart, unsigned length, Vector<ImageCandidate>& imageCandidates, Document* document)
 {
     const CharType* position = attributeStart;
     const CharType* attributeEnd = position + length;
 
     while (position < attributeEnd) {
         // 4. Splitting loop: Collect a sequence of characters that are space characters or U+002C COMMA characters.
         skipWhile<CharType, isHTMLSpaceOrComma<CharType> >(position, attributeEnd);
         if (position == attributeEnd) {
             // Contrary to spec language - descriptor parsing happens on each candidate, so when we reach the attributeEnd, we can exit.
             break;
         }
         const CharType* imageURLStart = position;
+
         // 6. Collect a sequence of characters that are not space characters, and let that be url.
-
         skipUntil<CharType, isHTMLSpace<CharType> >(position, attributeEnd);
         const CharType* imageURLEnd = position;
 
         DescriptorParsingResult result;
 
         // 8. If url ends with a U+002C COMMA character (,)
         if (isComma(*(position - 1))) {
             // Remove all trailing U+002C COMMA characters from url.
             imageURLEnd = position - 1;
             reverseSkipWhile<CharType, isComma>(imageURLEnd, imageURLStart);
             ++imageURLEnd;
             // If url is empty, then jump to the step labeled splitting loop.
             if (imageURLStart == imageURLEnd)
                 continue;
         } else {
-            // Advancing position here (contrary to spec) to avoid an useless extra state machine step.
-            // Filed a spec bug: https://github.com/ResponsiveImagesCG/picture-element/issues/189
-            ++position;
+            skipWhile<CharType, isHTMLSpace<CharType> >(position, attributeEnd);
             Vector<DescriptorToken> descriptorTokens;
             tokenizeDescriptors(attributeStart, position, attributeEnd, descriptorTokens);
             // Contrary to spec language - descriptor parsing happens on each candidate.
             // This is a black-box equivalent, to avoid storing descriptor lists for each candidate.
-            if (!parseDescriptors(attribute, descriptorTokens, result))
+            if (!parseDescriptors(attribute, descriptorTokens, result, document)) {
+                if (document) {
+                    UseCounter::count(document, UseCounter::SrcsetDroppedCandidate);
+                    if (document->frame())
+                        document->frame()->console().addMessage(ConsoleMessage::create(OtherMessageSource, ErrorMessageLevel, String("Dropped srcset candidate ") + String(imageURLStart, imageURLEnd - imageURLStart)));
+                }
                 continue;
+            }
         }
 
         ASSERT(imageURLEnd > attributeStart);
         unsigned imageURLStartingPosition = imageURLStart - attributeStart;
         ASSERT(imageURLEnd > imageURLStart);
         unsigned imageURLLength = imageURLEnd - imageURLStart;
         imageCandidates.append(ImageCandidate(attribute, imageURLStartingPosition, imageURLLength, result, ImageCandidate::SrcsetOrigin));
         // 11. Return to the step labeled splitting loop.
     }
 }
 
-static void parseImageCandidatesFromSrcsetAttribute(const String& attribute, Vector<ImageCandidate>& imageCandidates)
+static void parseImageCandidatesFromSrcsetAttribute(const String& attribute, Vector<ImageCandidate>& imageCandidates, Document* document)
 {
     if (attribute.isNull())
         return;
 
     if (attribute.is8Bit())
-        parseImageCandidatesFromSrcsetAttribute<LChar>(attribute, attribute.characters8(), attribute.length(), imageCandidates);
+        parseImageCandidatesFromSrcsetAttribute<LChar>(attribute, attribute.characters8(), attribute.length(), imageCandidates, document);
     else
-        parseImageCandidatesFromSrcsetAttribute<UChar>(attribute, attribute.characters16(), attribute.length(), imageCandidates);
+        parseImageCandidatesFromSrcsetAttribute<UChar>(attribute, attribute.characters16(), attribute.length(), imageCandidates, document);
 }
 
 static ImageCandidate pickBestImageCandidate(float deviceScaleFactor, float sourceSize, Vector<ImageCandidate>& imageCandidates)
 {
     const float defaultDensityValue = 1.0;
     bool ignoreSrc = false;
     if (imageCandidates.isEmpty())
         return ImageCandidate();
 
     // http://picture.responsiveimages.org/#normalize-source-densities
@@ skipping 22 matching lines @@
 
     unsigned winner = i;
     // 16. If an entry b in candidates has the same associated ... pixel density as an earlier entry a in candidates,
     // then remove entry b
     while ((i > 0) && (imageCandidates[--i].density() == winningDensity))
         winner = i;
 
     return imageCandidates[winner];
 }
 
-ImageCandidate bestFitSourceForSrcsetAttribute(float deviceScaleFactor, float sourceSize, const String& srcsetAttribute)
+ImageCandidate bestFitSourceForSrcsetAttribute(float deviceScaleFactor, float sourceSize, const String& srcsetAttribute, Document* document)
 {
     Vector<ImageCandidate> imageCandidates;
 
-    parseImageCandidatesFromSrcsetAttribute(srcsetAttribute, imageCandidates);
+    parseImageCandidatesFromSrcsetAttribute(srcsetAttribute, imageCandidates, document);
 
     return pickBestImageCandidate(deviceScaleFactor, sourceSize, imageCandidates);
 }
 
-ImageCandidate bestFitSourceForImageAttributes(float deviceScaleFactor, float sourceSize, const String& srcAttribute, const String& srcsetAttribute)
+ImageCandidate bestFitSourceForImageAttributes(float deviceScaleFactor, float sourceSize, const String& srcAttribute, const String& srcsetAttribute, Document* document)
 {
     if (srcsetAttribute.isNull()) {
         if (srcAttribute.isNull())
             return ImageCandidate();
         return ImageCandidate(srcAttribute, 0, srcAttribute.length(), DescriptorParsingResult(), ImageCandidate::SrcOrigin);
     }
 
     Vector<ImageCandidate> imageCandidates;
 
-    parseImageCandidatesFromSrcsetAttribute(srcsetAttribute, imageCandidates);
+    parseImageCandidatesFromSrcsetAttribute(srcsetAttribute, imageCandidates, document);
 
     if (!srcAttribute.isEmpty())
         imageCandidates.append(ImageCandidate(srcAttribute, 0, srcAttribute.length(), DescriptorParsingResult(), ImageCandidate::SrcOrigin));
 
     return pickBestImageCandidate(deviceScaleFactor, sourceSize, imageCandidates);
 }
 
 String bestFitSourceForImageAttributes(float deviceScaleFactor, float sourceSize, const String& srcAttribute, ImageCandidate& srcsetImageCandidate)
 {
     if (srcsetImageCandidate.isEmpty())
         return srcAttribute;
 
     Vector<ImageCandidate> imageCandidates;
     imageCandidates.append(srcsetImageCandidate);
 
     if (!srcAttribute.isEmpty())
         imageCandidates.append(ImageCandidate(srcAttribute, 0, srcAttribute.length(), DescriptorParsingResult(), ImageCandidate::SrcOrigin));
 
     return pickBestImageCandidate(deviceScaleFactor, sourceSize, imageCandidates).toString();
 }
 
 }