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) {
+                if (CSSVariableParser::isValidVariableName(property)) {
+                    customInvalidationProperties.append(property);
+                }
+            } 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