Hook up style invalidation for CSS Paint API.

third_party/WebKit/Source/modules/csspaint/PaintWorkletGlobalScope.cpp

 // Copyright 2016 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 "modules/csspaint/PaintWorkletGlobalScope.h"
 
 #include "bindings/core/v8/V8BindingMacros.h"
 #include "bindings/core/v8/WorkerOrWorkletScriptController.h"
+#include "core/CSSPropertyNames.h"
+#include "core/css/parser/CSSVariableParser.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/inspector/MainThreadDebugger.h"
 #include "modules/csspaint/CSSPaintDefinition.h"
 #include "modules/csspaint/CSSPaintImageGeneratorImpl.h"
 
 namespace blink {
 
 // static
 PaintWorkletGlobalScope* PaintWorkletGlobalScope::create(LocalFrame* frame, const KURL& url, const String& userAgent, PassRefPtr<SecurityOrigin> securityOrigin, v8::Isolate* isolate)
 {
@@ skipping 36 matching lines @@
     v8::Isolate* isolate = scriptController()->getScriptState()->isolate();
     v8::Local<v8::Context> context = scriptController()->context();
 
     ASSERT(ctorValue.v8Value()->IsFunction());
     v8::Local<v8::Function> constructor = v8::Local<v8::Function>::Cast(ctorValue.v8Value());
 
     v8::Local<v8::Value> inputPropertiesValue;
     if (!v8Call(constructor->Get(context, v8String(isolate, "inputProperties")), inputPropertiesValue))
         return;
 
+    Vector<CSSPropertyID> nativeInvalidationProperties;
+    Vector<AtomicString> customInvalidationProperties;
+
     if (!isUndefinedOrNull(inputPropertiesValue)) {
-        toImplArray<Vector<String>>(inputPropertiesValue, 0, isolate, exceptionState);
+        Vector<String> properties = toImplArray<Vector<String>>(inputPropertiesValue, 0, isolate, exceptionState);
 
         if (exceptionState.hadException())
             return;
 
-        // TODO(ikilpatrick): Hook up invalidation based on these inputProperties.
+        for (const auto& property : properties) {
+            CSSPropertyID propertyID = cssPropertyID(property);
+            if (propertyID == CSSPropertyInvalid) {

[chrishtr, 2016/04/27 19:52:40]

It seems weird that custom properties are identified as CSSPropertyInvalid.

[ikilpatrick, 2016/04/28 22:30:16]

Right, not sure of the history here. Would have to ask timloh@.
https://code.google.com/p/chromium/codesearch#chromium/src/third_party/WebKit...

[chrishtr, 2016/04/29 00:24:58]

Ok. Please ask him about it.

[Timothy Loh, 2016/04/29 01:20:25]

I don't recall exactly. I think it was so that while custom properties were
being implemented, callsites which weren't yet updated to handle custom
properties would just not support them (if we made it return CSSPropertyVariable
then they might error in weird or unsafe ways).

At this point I don't see any reason to not have the isValidVariableName call
inside cssPropertyID/unresolvedCSSPropertyID. I made a keep note to fix it up at
some point (just need to check all the call sites and make sure they handle the
updated function correctly).

+                if (CSSVariableParser::isValidVariableName(property))
+                    customInvalidationProperties.append(property);
+            } else {
+                // Disallow prefixes.
+                if (property[0] == '-') {
+                    addConsoleMessage(ConsoleMessage::create(JSMessageSource, WarningMessageLevel, property + " is a prefixed property which is not supported."));
+                } else {
+                    nativeInvalidationProperties.append(propertyID);
+                }
+            }
+        }
     }
 
     v8::Local<v8::Value> prototypeValue;
     if (!v8Call(constructor->Get(context, v8String(isolate, "prototype")), prototypeValue))
         return;
 
     if (isUndefinedOrNull(prototypeValue)) {
         exceptionState.throwTypeError("The 'prototype' object on the class does not exist.");
         return;
     }
@@ skipping 14 matching lines @@
         return;
     }
 
     if (!paintValue->IsFunction()) {
         exceptionState.throwTypeError("The 'paint' property on the prototype is not a function.");
         return;
     }
 
     v8::Local<v8::Function> paint = v8::Local<v8::Function>::Cast(paintValue);
 
-    CSSPaintDefinition* definition = CSSPaintDefinition::create(scriptController()->getScriptState(), constructor, paint);
+    CSSPaintDefinition* definition = CSSPaintDefinition::create(scriptController()->getScriptState(), constructor, paint, nativeInvalidationProperties, customInvalidationProperties);
     m_paintDefinitions.set(name, definition);
 
     // Set the definition on any pending generators.
     GeneratorHashSet* set = m_pendingGenerators.get(name);
     if (set) {
         for (const auto& generator : *set) {
             if (generator) {
                 generator->setDefinition(definition);
             }
         }
@@ skipping 15 matching lines @@
 }
 
 DEFINE_TRACE(PaintWorkletGlobalScope)
 {
     visitor->trace(m_paintDefinitions);
     visitor->trace(m_pendingGenerators);
     WorkletGlobalScope::trace(visitor);
 }
 
 } // namespace blink