Use C++11 features in core/html

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 178 matching lines @@
         StringBuilder errorMessage;
         errorMessage.append("Failed parsing 'srcset' attribute value since ");
         errorMessage.append(message);
         document->frame()->console().addMessage(ConsoleMessage::create(OtherMessageSource, ErrorMessageLevel, errorMessage.toString()));
     }
 }
 
 template<typename CharType>
 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)
+    for (DescriptorToken& descriptor : descriptors) {
+        if (descriptor.length == 0)
             continue;
-        CharType c = attribute[it->lastIndex()];
+        CharType c = attribute[descriptor.lastIndex()];
         bool isValid = false;
         if (RuntimeEnabledFeatures::pictureSizesEnabled() && c == 'w') {
             if (result.hasDensity() || result.hasWidth()) {
                 srcsetError(document, "it has multiple 'w' descriptors or a mix of 'x' and 'w' descriptors.");
                 return false;
             }
-            int resourceWidth = it->toInt(attribute, isValid);
+            int resourceWidth = descriptor.toInt(attribute, isValid);
             if (!isValid || resourceWidth <= 0) {
                 srcsetError(document, "its '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()) {
                 srcsetError(document, "it has multiple 'h' descriptors or a mix of 'x' and 'h' descriptors.");
                 return false;
             }
-            int resourceHeight = it->toInt(attribute, isValid);
+            int resourceHeight = descriptor.toInt(attribute, isValid);
             if (!isValid || resourceHeight <= 0) {
                 srcsetError(document, "its 'h' descriptor is invalid.");
                 return false;
             }
             result.setResourceHeight(resourceHeight);
         } else if (c == 'x') {
             if (result.hasDensity() || result.hasHeight() || result.hasWidth()) {
                 srcsetError(document, "it has multiple 'x' descriptors or a mix of 'x' and 'w'/'h' descriptors.");
                 return false;
             }
-            float density = it->toFloat(attribute, isValid);
+            float density = descriptor.toFloat(attribute, isValid);
             if (!isValid || density < 0) {
                 srcsetError(document, "its 'x' descriptor is invalid.");
                 return false;
             }
             result.setDensity(density);
         } else {
             srcsetError(document, "it has an unknown descriptor.");
             return false;
         }
     }
@@ skipping 14 matching lines @@
 
 // http://picture.responsiveimages.org/#parse-srcset-attr
 template<typename CharType>
 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);
+        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);
+        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;
@@ skipping 82 matching lines @@
 }
 
 static ImageCandidate pickBestImageCandidate(float deviceScaleFactor, float sourceSize, Vector<ImageCandidate>& imageCandidates, Document* document = nullptr)
 {
     const float defaultDensityValue = 1.0;
     bool ignoreSrc = false;
     if (imageCandidates.isEmpty())
         return ImageCandidate();
 
     // http://picture.responsiveimages.org/#normalize-source-densities
-    for (Vector<ImageCandidate>::iterator it = imageCandidates.begin(); it != imageCandidates.end(); ++it) {
-        if (it->resourceWidth() > 0) {
-            it->setDensity((float)it->resourceWidth() / sourceSize);
+    for (ImageCandidate& image : imageCandidates) {
+        if (image.resourceWidth() > 0) {
+            image.setDensity((float)image.resourceWidth() / sourceSize);
             ignoreSrc = true;
-        } else if (it->density() < 0) {
-            it->setDensity(defaultDensityValue);
+        } else if (image.density() < 0) {
+            image.setDensity(defaultDensityValue);
         }
     }
 
     std::stable_sort(imageCandidates.begin(), imageCandidates.end(), compareByDensity);
 
     unsigned winner = selectionLogic(imageCandidates, deviceScaleFactor, ignoreSrc);
     ASSERT(winner < imageCandidates.size());
     winner = avoidDownloadIfHigherDensityResourceIsInCache(imageCandidates, winner, document);
 
     float winningDensity = imageCandidates[winner].density();
@@ skipping 40 matching lines @@
     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();
 }
 
 }