Web Animations API: Start implementation of Element.animate().

Source/core/css/CSSParser-in.cpp

 /*
  * Copyright (C) 2003 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Nicholas Shanks <webkit@nickshanks.com>
  * Copyright (C) 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (C) 2012 Adobe Systems Incorporated. All rights reserved.
  * Copyright (C) 2012 Intel Corporation. All rights reserved.
  *
@@ skipping 61 matching lines @@
 #include "core/css/Pair.h"
 #include "core/css/Rect.h"
 #include "core/css/StylePropertySet.h"
 #include "core/css/StyleRule.h"
 #include "core/css/StyleRuleImport.h"
 #include "core/css/StyleSheetContents.h"
 #include "core/dom/Document.h"
 #include "core/html/parser/HTMLParserIdioms.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/page/PageConsole.h"
+#include "core/page/RuntimeCSSEnabled.h"
 #include "core/page/Settings.h"
 #include "core/rendering/RenderTheme.h"
 #include "core/svg/SVGParserUtilities.h"
 #include "platform/FloatConversion.h"
 #include "wtf/BitArray.h"
 #include "wtf/HexNumber.h"
 #include "wtf/text/StringBuffer.h"
 #include "wtf/text/StringBuilder.h"
 #include "wtf/text/StringImpl.h"
 #include "wtf/text/TextEncoding.h"
@@ skipping 10120 matching lines @@
     unsigned length = string.length();
 
     if (!length)
         return CSSPropertyInvalid;
     if (length > maxCSSPropertyNameLength)
         return CSSPropertyInvalid;
 
     return string.is8Bit() ? cssPropertyID(string.characters8(), length) : cssPropertyID(string.characters16(), length);
 }
 
+CSSPropertyID camelCaseCSSPropertyNameToID(StringImpl* propertyName)
+{
+    typedef HashMap<StringImpl*, CSSPropertyID> CSSPropertyIDMap;
+    DEFINE_STATIC_LOCAL(CSSPropertyIDMap, map, ());
+
+    CSSPropertyID id = map.get(propertyName);
+
+    if (!id) {
+        StringBuilder builder;
+        size_t position = 0;
+        size_t end;
+        while ((end = propertyName->find(isASCIIUpper, position)) != kNotFound) {
+            builder.append(propertyName->substring(position, end) + "-" + toASCIILower((*propertyName)[end]));

[esprehn, 2013/12/09 18:51:25]

You shouldn't add this, instead refactor the
V8CSSStyleDeclarationCustom::cssPropertyInfo into a shared place that takes a
const String& and use it.

[Steve Block, 2013/12/09 23:32:20]

I recommended this too, but after discussion with Renee, I'm not sure it's worth
it. cssPropertyInfo() checks 'webkit' and 'css' prefixed variants, and allows
the dashed version of names, all of which we don't need. It also builds a
CSSPropertyInfo struct, which contains information that we don't need and which
is built up by character-by-character searching. To share the function we'd have
to introduce a bunch of 'if' statements, and wouldn't be able to make use of
'find()', as we do here.

[esprehn, 2013/12/09 23:36:16]

Why is it safe to ignore the webkit prefix? It doesn't make sense to have two
tables with the exact same values in them, and two functions that do nearly the
same thing like this.

[shans, 2013/12/09 23:48:40]

We don't intend the Web Animations API to support the legacy prefixing approach
to experimental features. Prefixed properties will not be animatable using this
feature.

The two tables don't have the exact same values in them. Consider the following
keys that will populate the old table but that are not admitted into the new
table:
"webkitLength"
"margin-left"
"cssHeight"

Furthermore, the new table maps strings to CSSPropertyID values, not
CSSPropertyInfo structs.

+            position = end + 1;
+        }
+        builder.append(propertyName->substring(position));
+        // Doesn't handle prefixed properties.
+        id = cssPropertyID(builder.toString());
+        if (id != CSSPropertyInvalid && RuntimeCSSEnabled::isCSSPropertyEnabled(id))
+            map.add(propertyName, id);

[esprehn, 2013/12/09 18:51:25]

This is a memory leak, it'll just grow forever with all unknown properties that
go through this function. It seems we already have such a leak in
cssPropertyInfo (blah), so lets not add another.

[shans, 2013/12/09 23:25:57]

Invalid property names are explicitly filtered out on the line directly above
this. This map will never contain more than the 400-odd known property names.

[esprehn, 2013/12/09 23:36:16]

Awesome.

+    }
+
+    return id;
+}
+
 template <typename CharacterType>
 static CSSValueID cssValueKeywordID(const CharacterType* valueKeyword, unsigned length)
 {
     char buffer[maxCSSValueKeywordLength + 1]; // 1 for null character
 
     for (unsigned i = 0; i != length; ++i) {
         CharacterType c = valueKeyword[i];
         if (c == 0 || c >= 0x7F)
             return CSSValueInvalid; // illegal character
         buffer[i] = WTF::toASCIILower(c);
@@ skipping 174 matching lines @@
 {
     // The tokenizer checks for the construct of an+b.
     // However, since the {ident} rule precedes the {nth} rule, some of those
     // tokens are identified as string literal. Furthermore we need to accept
     // "odd" and "even" which does not match to an+b.
     return equalIgnoringCase(token, "odd") || equalIgnoringCase(token, "even")
         || equalIgnoringCase(token, "n") || equalIgnoringCase(token, "-n");
 }
 
 }