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.append(property);
       } else if (propertyID != CSSPropertyInvalid) {
         nativeInvalidationProperties.append(propertyID);
       }
     }
   }
 
+  // Get input argument types.
+  v8::Local<v8::Value> inputArgumentTypeValues;

[ikilpatrick, 2017/01/12 18:17:03]

we should also only attempt to parse this if the runtime flag is enabled.

[renjieliu1, 2017/01/13 04:18:23]

Done.

+  if (!v8Call(constructor->Get(context, v8String(isolate, "inputArguments")),
+              inputArgumentTypeValues))
+    return;
+
+  Vector<CSSSyntaxDescriptor> inputArgumentTypes;
+  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())

[ikilpatrick, 2017/01/12 05:36:04]

It would be good to throw a TypeError here.

[renjieliu1, 2017/01/13 04:18:23]

Done.

+        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