This patch parse the sizes attribute into vector of IntSize, also added sizes...

This patch parse the sizes attribute into vector of IntSize, also added sizes in WebIconURL, so it could be used by chromium 

BUG=349039

Review URL: https://codereview.chromium.org/196743002

git-svn-id: svn://svn.chromium.org/blink/trunk@169404 bbb929c8-8fbe-4397-9dbb-9b2b20218538

third_party/WebKit/Source/core/core.gypi

@@ -3315,6 +3315,7 @@
             'fetch/ResourceFetcherTest.cpp',
             'frame/ImageBitmapTest.cpp',
             'html/HTMLDimensionTest.cpp',
+            'html/HTMLLinkElementSizesAttributeTest.cpp',
             'html/LinkRelAttributeTest.cpp',
             'html/TimeRangesTest.cpp',
             'html/parser/HTMLParserThreadTest.cpp',

third_party/WebKit/Source/core/dom/IconURL.cpp

@@ -44,7 +44,7 @@ IconURL IconURL::defaultFavicon(const KURL& documentURL)
         url.setPort(documentURL.port());
     url.setPath("/favicon.ico");
 
-    IconURL result(url, emptyString(), emptyString(), Favicon);
+    IconURL result(url, Vector<IntSize>(), emptyString(), Favicon);
     result.m_isDefaultIcon = true;
     return result;
 }

third_party/WebKit/Source/core/dom/IconURL.h

@@ -31,6 +31,7 @@
 #ifndef IconURL_h
 #define IconURL_h
 
+#include "platform/geometry/IntSize.h"
 #include "platform/weborigin/KURL.h"
 
 namespace WebCore {
@@ -44,7 +45,7 @@ enum IconType {
 
 struct IconURL {
     IconType m_iconType;
-    String m_sizes;
+    Vector<IntSize> m_sizes;
     String m_mimeType;
     KURL m_iconURL;
     bool m_isDefaultIcon;
@@ -55,7 +56,7 @@ struct IconURL {
     {
     }
 
-    IconURL(const KURL& url, const String& sizes, const String& mimeType, IconType type)
+    IconURL(const KURL& url, const Vector<IntSize>& sizes, const String& mimeType, IconType type)
         : m_iconType(type)
         , m_sizes(sizes)
         , m_mimeType(mimeType)

third_party/WebKit/Source/core/html/HTMLLinkElement.cpp

@@ -52,12 +52,84 @@ namespace WebCore {
 
 using namespace HTMLNames;
 
+template <typename CharacterType>
+static void parseSizes(const CharacterType* value, unsigned length, Vector<IntSize>& iconSizes)
+{
+    enum State {
+        ParseStart,
+        ParseWidth,
+        ParseHeight
+    };
+    int width = 0;
+    unsigned start = 0;
+    unsigned i = 0;
+    State state = ParseStart;
+    bool invalid = false;
+    for (; i < length; ++i) {
+        if (state == ParseWidth) {
+            if (value[i] == 'x' || value[i] == 'X') {
+                if (i == start) {
+                    invalid = true;
+                    break;
+                }
+                width = charactersToInt(value + start, i - start);
+                start = i + 1;
+                state = ParseHeight;
+            } else if (value[i] < '0' || value[i] > '9') {
+                invalid = true;
+                break;
+            }
+        } else if (state == ParseHeight) {
+            if (value[i] == ' ') {
+                if (i == start) {
+                    invalid = true;
+                    break;
+                }
+                int height = charactersToInt(value + start, i - start);
+                iconSizes.append(IntSize(width, height));
+                start = i + 1;
+                state = ParseStart;
+            } else if (value[i] < '0' || value[i] > '9') {
+                invalid = true;
+                break;
+            }
+        } else if (state == ParseStart) {
+            if (value[i] >= '0' && value[i] <= '9') {
+                start = i;
+                state = ParseWidth;
+            } else if (value[i] != ' ') {
+                invalid = true;
+                break;
+            }
+        }
+    }
+    if (invalid || state == ParseWidth || (state == ParseHeight && start == i)) {
+        iconSizes.clear();
+        return;
+    }
+    if (state == ParseHeight && i > start) {
+        int height = charactersToInt(value + start, i - start);
+        iconSizes.append(IntSize(width, height));
+    }
+}
+
 static LinkEventSender& linkLoadEventSender()
 {
     DEFINE_STATIC_LOCAL(LinkEventSender, sharedLoadEventSender, (EventTypeNames::load));
     return sharedLoadEventSender;
 }
 
+void HTMLLinkElement::parseSizesAttribute(const AtomicString& value, Vector<IntSize>& iconSizes)
+{
+    ASSERT(iconSizes.isEmpty());
+    if (value.isEmpty())
+        return;
+    if (value.is8Bit())
+        parseSizes(value.characters8(), value.length(), iconSizes);
+    else
+        parseSizes(value.characters16(), value.length(), iconSizes);
+}
+
 inline HTMLLinkElement::HTMLLinkElement(Document& document, bool createdByParser)
     : HTMLElement(linkTag, document)
     , m_linkLoader(this)
@@ -96,6 +168,7 @@ void HTMLLinkElement::parseAttribute(const QualifiedName& name, const AtomicStri
         process();
     } else if (name == sizesAttr) {
         m_sizes->setValue(value);
+        parseSizesAttribute(value, m_iconSizes);
         process();
     } else if (name == mediaAttr) {
         m_media = value.string().lower();
@@ -352,9 +425,9 @@ IconType HTMLLinkElement::iconType() const
     return m_relAttribute.iconType();
 }
 
-const AtomicString& HTMLLinkElement::iconSizes() const
+const Vector<IntSize>& HTMLLinkElement::iconSizes() const
 {
-    return m_sizes->toString();
+    return m_iconSizes;
 }
 
 DOMSettableTokenList* HTMLLinkElement::sizes() const

third_party/WebKit/Source/core/html/HTMLLinkElement.h

@@ -133,8 +133,8 @@ public:
 
     IconType iconType() const;
 
-    // the icon size string as parsed from the HTML attribute
-    const AtomicString& iconSizes() const;
+    // the icon sizes as parsed from the HTML attribute
+    const Vector<IntSize>& iconSizes() const;
 
     bool async() const;
 
@@ -163,6 +163,10 @@ public:
     bool shouldProcessStyle() { return linkResourceToProcess() && linkStyle(); }
     bool isCreatedByParser() const { return m_createdByParser; }
 
+    // Parse the icon size attribute into |iconSizes|, make this method public
+    // visible for testing purpose.
+    static void parseSizesAttribute(const AtomicString& value, Vector<IntSize>& iconSizes);
+
 private:
     virtual void parseAttribute(const QualifiedName&, const AtomicString&) OVERRIDE;
 
@@ -199,6 +203,7 @@ private:
     String m_type;
     String m_media;
     RefPtr<DOMSettableTokenList> m_sizes;
+    Vector<IntSize> m_iconSizes;
     LinkRelAttribute m_relAttribute;
 
     bool m_createdByParser;

third_party/WebKit/Source/core/html/HTMLLinkElementSizesAttributeTest.cpp

+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "config.h"
+#include "core/html/HTMLLinkElement.h"
+
+#include <gtest/gtest.h>
+
+using namespace WebCore;
+
+namespace {
+
+class HTMLLinkElementSizesAttributeTest : public testing::Test {
+};
+
+TEST(HTMLLinkElementSizesAttributeTest, parseSizes)
+{
+    AtomicString sizesAttribute = "32x33";
+    Vector<IntSize> sizes;
+    HTMLLinkElement::parseSizesAttribute(sizesAttribute, sizes);
+    ASSERT_EQ(1U, sizes.size());
+    EXPECT_EQ(32, sizes[0].width());
+    EXPECT_EQ(33, sizes[0].height());
+
+    UChar attribute[] = {'3', '2', 'x', '3', '3', 0};
+    sizesAttribute = attribute;
+    sizes.clear();
+    HTMLLinkElement::parseSizesAttribute(sizesAttribute, sizes);
+    ASSERT_EQ(1U, sizes.size());
+    EXPECT_EQ(32, sizes[0].width());
+    EXPECT_EQ(33, sizes[0].height());
+
+
+    sizesAttribute = "   32x33   16X17    128x129   ";
+    sizes.clear();
+    HTMLLinkElement::parseSizesAttribute(sizesAttribute, sizes);
+    ASSERT_EQ(3U, sizes.size());
+    EXPECT_EQ(32, sizes[0].width());
+    EXPECT_EQ(33, sizes[0].height());
+    EXPECT_EQ(16, sizes[1].width());
+    EXPECT_EQ(17, sizes[1].height());
+    EXPECT_EQ(128, sizes[2].width());
+    EXPECT_EQ(129, sizes[2].height());
+
+    sizesAttribute = "any";
+    sizes.clear();
+    HTMLLinkElement::parseSizesAttribute(sizesAttribute, sizes);
+    ASSERT_EQ(0U, sizes.size());
+
+    sizesAttribute = "32x33 32";
+    sizes.clear();
+    HTMLLinkElement::parseSizesAttribute(sizesAttribute, sizes);
+    ASSERT_EQ(0U, sizes.size());
+
+    sizesAttribute = "32x33 32x";
+    sizes.clear();
+    HTMLLinkElement::parseSizesAttribute(sizesAttribute, sizes);
+    ASSERT_EQ(0U, sizes.size());
+
+    sizesAttribute = "32x33 x32";
+    sizes.clear();
+    HTMLLinkElement::parseSizesAttribute(sizesAttribute, sizes);
+    ASSERT_EQ(0U, sizes.size());
+
+    sizesAttribute = "32x33 any";
+    sizes.clear();
+    HTMLLinkElement::parseSizesAttribute(sizesAttribute, sizes);
+    ASSERT_EQ(0U, sizes.size());
+
+    sizesAttribute = "32x33, 64x64";
+    sizes.clear();
+    HTMLLinkElement::parseSizesAttribute(sizesAttribute, sizes);
+    ASSERT_EQ(0U, sizes.size());
+}
+
+} //  namespace

third_party/WebKit/public/web/WebIconURL.h

@@ -34,7 +34,9 @@
 #if BLINK_IMPLEMENTATION
 #include "core/dom/IconURL.h"
 #endif
-#include "../platform/WebURL.h"
+#include "public/platform/WebSize.h"
+#include "public/platform/WebURL.h"
+#include "public/platform/WebVector.h"
 
 namespace blink {
 
@@ -68,10 +70,16 @@ public:
         return m_iconURL;
     }
 
+    const WebVector<WebSize>& sizes() const
+    {
+        return m_sizes;
+    }
+
 #if BLINK_IMPLEMENTATION
     WebIconURL(const WebCore::IconURL& iconURL)
         : m_iconType(static_cast<Type>(iconURL.m_iconType))
         , m_iconURL(iconURL.m_iconURL)
+        , m_sizes(iconURL.m_sizes)
     {
     }
 #endif
@@ -79,6 +87,7 @@ public:
 private:
     Type m_iconType;
     WebURL m_iconURL;
+    WebVector<WebSize> m_sizes;
 };
 
 }