Parse input argument types and store the argument types in CSSPaintDefinition.

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/CSSSyntaxDescriptor.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,
@@ skipping 76 matching lines @@
     for (const auto& property : properties) {
       CSSPropertyID propertyID = cssPropertyID(property);
       if (propertyID == CSSPropertyVariable) {
         customInvalidationProperties.push_back(property);
       } else if (propertyID != CSSPropertyInvalid) {
         nativeInvalidationProperties.push_back(propertyID);
       }
     }
   }
 
+  // Get input argument types. Parse the argument type values only when
+  // cssPaintAPIArguments is enabled.
+  Vector<CSSSyntaxDescriptor> inputArgumentTypes;
+  if (RuntimeEnabledFeatures::cssPaintAPIArgumentsEnabled()) {
+    v8::Local<v8::Value> inputArgumentTypeValues;
+    if (!v8Call(constructor->Get(context, v8String(isolate, "inputArguments")),
+                inputArgumentTypeValues))
+      return;
+
+    if (!isUndefinedOrNull(inputArgumentTypeValues)) {
+      Vector<String> argumentTypes = toImplArray<Vector<String>>(
+          inputArgumentTypeValues, 0, isolate, exceptionState);
+
+      if (exceptionState.hadException())
+        return;
+
+      for (const auto& type : argumentTypes) {
+        CSSSyntaxDescriptor syntaxDescriptor(type);
+        if (!syntaxDescriptor.isValid()) {
+          exceptionState.throwTypeError("Invalid argument types.");
+          return;
+        }
+        inputArgumentTypes.append(syntaxDescriptor);
+      }
+    }
+  }
+
   // Parse 'alpha' AKA hasAlpha property.
   v8::Local<v8::Value> alphaValue;
   if (!v8Call(constructor->Get(context, v8String(isolate, "alpha")),
               alphaValue))
     return;
   if (!isUndefinedOrNull(alphaValue) && !alphaValue->IsBoolean()) {
     exceptionState.throwTypeError(
         "The 'alpha' property on the class is not a boolean.");
     return;
   }
@@ skipping 33 matching lines @@
   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,
-      nativeInvalidationProperties, customInvalidationProperties, hasAlpha);
+      nativeInvalidationProperties, customInvalidationProperties,
+      inputArgumentTypes, hasAlpha);
   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 16 matching lines @@
   set->add(generator);
 }
 
 DEFINE_TRACE(PaintWorkletGlobalScope) {
   visitor->trace(m_paintDefinitions);
   visitor->trace(m_pendingGenerators);
   MainThreadWorkletGlobalScope::trace(visitor);
 }
 
 }  // namespace blink