Add use counters for using Attrs as Nodes.

Source/bindings/scripts/code_generator_v8.pm

 # Copyright (C) 2005, 2006 Nikolas Zimmermann <zimmermann@kde.org>
 # Copyright (C) 2006 Anders Carlsson <andersca@mac.com>
 # Copyright (C) 2006 Samuel Weinig <sam.weinig@gmail.com>
 # Copyright (C) 2006 Alexey Proskuryakov <ap@webkit.org>
 # Copyright (C) 2006 Apple Computer, Inc.
 # Copyright (C) 2007, 2008, 2009, 2012 Google Inc.
 # Copyright (C) 2009 Cameron McCormack <cam@mcc.id.au>
 # Copyright (C) Research In Motion Limited 2010. All rights reserved.
 # Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
 # Copyright (C) 2012 Ericsson AB. All rights reserved.
@@ skipping 1408 matching lines @@
 
     if ($exposeJSAccessors) {
         $code .= "static void ${attrName}AttributeGetterCallback${forMainWorldSuffix}(const v8::FunctionCallbackInfo<v8::Value>& info)\n";
     } else {
         $code .= "static void ${attrName}AttributeGetterCallback${forMainWorldSuffix}(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)\n";
     }
     $code .= "{\n";
     $code .= "    TRACE_EVENT_SET_SAMPLING_STATE(\"Blink\", \"DOMGetter\");\n";
     $code .= GenerateFeatureObservation($attrExt->{"MeasureAs"});
     $code .= GenerateDeprecationNotification($attrExt->{"DeprecateAs"});
+    $code .= GenerateAttrUsedAsNodeReceiverCheck($interface);
     if (HasActivityLogging($forMainWorldSuffix, $attrExt, "Getter")) {
         $code .= GenerateActivityLogging("Getter", $interface, "${attrName}");
     }
     if (HasCustomGetter($attrExt)) {
         $code .= "    ${v8ClassName}::${attrName}AttributeGetterCustom(info);\n";
     } else {
         $code .= "    ${implClassName}V8Internal::${attrName}AttributeGetter${forMainWorldSuffix}(info);\n";
     }
     $code .= "    TRACE_EVENT_SET_SAMPLING_STATE(\"V8\", \"V8Execution\");\n";
     $code .= "}\n";
@@ skipping 442 matching lines @@
         $code .= "static void ${attrName}AttributeSetterCallback${forMainWorldSuffix}(const v8::FunctionCallbackInfo<v8::Value>& info)\n";
         $code .= "{\n";
         $code .= "    v8::Local<v8::Value> jsValue = info[0];\n";
     } else {
         $code .= "static void ${attrName}AttributeSetterCallback${forMainWorldSuffix}(v8::Local<v8::String>, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info)\n";
         $code .= "{\n";
     }
     $code .= "    TRACE_EVENT_SET_SAMPLING_STATE(\"Blink\", \"DOMSetter\");\n";
     $code .= GenerateFeatureObservation($attrExt->{"MeasureAs"});
     $code .= GenerateDeprecationNotification($attrExt->{"DeprecateAs"});
+    $code .= GenerateAttrUsedAsNodeReceiverCheck($interface);
+    $code .= GenerateAttrUsedAsNodeParameterCheckForSetter($attribute->type);
     if (HasActivityLogging($forMainWorldSuffix, $attrExt, "Setter")) {
         $code .= GenerateActivityLogging("Setter", $interface, "${attrName}");
     }
     $code .= GenerateCustomElementInvocationScopeIfNeeded($attrExt);
     if (HasCustomSetter($attribute)) {
         $code .= "    ${v8ClassName}::${attrName}AttributeSetterCustom(jsValue, info);\n";
     } else {
         $code .= "    ${implClassName}V8Internal::${attrName}AttributeSetter${forMainWorldSuffix}(jsValue, info);\n";
     }
     $code .= "    TRACE_EVENT_SET_SAMPLING_STATE(\"V8\", \"V8Execution\");\n";
@@ skipping 349 matching lines @@
             last;
         }
         $numParameters++;
     }
     if (!$hasVariadic) {
         push(@orExpression, GenerateParametersCheckExpression($numParameters, $function));
     }
     return ($numMandatoryParams, join(" || ", @orExpression));
 }
 
+sub GenerateAttrUsedAsNodeReceiverCheck
+{
+    my $interface = shift;
+
+    if ($interface->name eq "Node") {
+        AddToImplIncludes("core/frame/UseCounter.h");
+        AddToImplIncludes("V8Attr.h");
+        return <<END;
+    if (V8DOMWrapper::isWrapperOfType(info.Holder(), &V8Attr::wrapperTypeInfo))
+        UseCounter::count(activeExecutionContext(), UseCounter::AttrUsedAsNodeReceiver);
+END
+    }
+
+    return "";
+}
+
+sub GenerateAttrUsedAsNodeParameterCheck
+{
+    my $function = shift;
+
+    my $code = "";
+    my $paramIndex = 0;
+
+    foreach my $parameter (@{$function->parameters}) {
+        if ($parameter->type eq "Node") {
+            $code .= "    if (V8DOMWrapper::isWrapperOfType(info[$paramIndex], &V8Attr::wrapperTypeInfo))\n";
+            $code .= "        UseCounter::count(activeExecutionContext(), UseCounter::AttrUsedAsNodeParameter);\n";
+        }
+
+        $paramIndex += 1;
+    }
+
+    if ($code) {
+        AddToImplIncludes("core/frame/UseCounter.h");
+        AddToImplIncludes("V8Attr.h");
+    }
+
+    return $code;
+}
+
+sub GenerateAttrUsedAsNodeParameterCheckForSetter
+{
+    my $type = shift;
+
+    if ($type eq "Node") {
+        AddToImplIncludes("core/frame/UseCounter.h");
+        AddToImplIncludes("V8Attr.h");
+        return <<END;
+    if (V8DOMWrapper::isWrapperOfType(jsValue, &V8Attr::wrapperTypeInfo))
+        UseCounter::count(activeExecutionContext(), UseCounter::AttrUsedAsNodeParameter);
+END
+    }
+
+    return "";
+}
+
 sub GenerateOverloadedFunction
 {
     my $function = shift;
     my $interface = shift;
     my $forMainWorldSuffix = shift;
 
     # Generate code for choosing the correct overload to call. Overloads are
     # chosen based on the total number of arguments passed and the type of
     # values passed in non-primitive argument slots. When more than a single
     # overload is applicable, precedence is given according to the order of
     # declaration in the IDL.
 
     my $name = $function->name;
     my $interfaceName = $interface->name;
     my $implClassName = GetImplName($interface);
 
     my $conditionalString = GenerateConditionalString($function);
     my $leastNumMandatoryParams = 255;
 
     my $code = "";
     $code .= "#if ${conditionalString}\n\n" if $conditionalString;
     $code .= <<END;
 static void ${name}Method${forMainWorldSuffix}(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
 END
     $code .= GenerateFeatureObservation($function->extendedAttributes->{"MeasureAs"});
     $code .= GenerateDeprecationNotification($function->extendedAttributes->{"DeprecateAs"});
+    $code .= GenerateAttrUsedAsNodeReceiverCheck($interface);
 
     foreach my $overload (@{$function->{overloads}}) {
+        $code .= GenerateAttrUsedAsNodeParameterCheck($overload);
         my ($numMandatoryParams, $parametersCheck) = GenerateFunctionParametersCheck($overload);
         $leastNumMandatoryParams = $numMandatoryParams if ($numMandatoryParams < $leastNumMandatoryParams);
         $code .= "    if ($parametersCheck) {\n";
         my $overloadedIndexString = $overload->{overloadIndex};
         $code .= "        ${name}${overloadedIndexString}Method${forMainWorldSuffix}(info);\n";
         $code .= "        return;\n";
         $code .= "    }\n";
     }
     if ($leastNumMandatoryParams >= 1) {
         $code .= "    ExceptionState exceptionState(ExceptionState::ExecutionContext, \"${name}\", \"${interfaceName}\", info.Holder(), info.GetIsolate());\n";
@@ skipping 33 matching lines @@
     my $conditionalString = GenerateConditionalString($function);
     my $code = "";
     $code .= "#if ${conditionalString}\n" if $conditionalString;
     $code .= <<END;
 static void ${name}MethodCallback${forMainWorldSuffix}(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
 END
     $code .= "    TRACE_EVENT_SET_SAMPLING_STATE(\"Blink\", \"DOMMethod\");\n";
     $code .= GenerateFeatureObservation($function->extendedAttributes->{"MeasureAs"});
     $code .= GenerateDeprecationNotification($function->extendedAttributes->{"DeprecateAs"});
+    $code .= GenerateAttrUsedAsNodeReceiverCheck($interface);
+    $code .= GenerateAttrUsedAsNodeParameterCheck($function);
     if (HasActivityLogging($forMainWorldSuffix, $function->extendedAttributes, "Access")) {
         $code .= GenerateActivityLogging("Method", $interface, "${name}");
     }
     if (HasCustomMethod($function->extendedAttributes)) {
         $code .= "    ${v8ClassName}::${name}MethodCustom(info);\n";
     } else {
         $code .= "    ${implClassName}V8Internal::${name}Method${forMainWorldSuffix}(info);\n";
     }
     $code .= "    TRACE_EVENT_SET_SAMPLING_STATE(\"V8\", \"V8Execution\");\n";
     $code .= "}\n";
@@ skipping 1376 matching lines @@
     my $methodName = GetImplName($indexedSetterFunction);
     my $interfaceName = $interface->name;
 
     my $type = $indexedSetterFunction->parameters->[1]->type;
     my $raisesExceptions = $indexedSetterFunction->extendedAttributes->{"RaisesException"};
     my $treatNullAs = $indexedSetterFunction->parameters->[1]->extendedAttributes->{"TreatNullAs"};
     my $treatUndefinedAs = $indexedSetterFunction->parameters->[1]->extendedAttributes->{"TreatUndefinedAs"};
 
     my $code = "static void indexedPropertySetter(uint32_t index, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<v8::Value>& info)\n";
     $code .= "{\n";
+    $code .= GenerateAttrUsedAsNodeParameterCheckForSetter($type);
 
     my $extraArguments = "";
     if ($raisesExceptions || IsIntegerType($type)) {
         $code .= "    ExceptionState exceptionState(info.Holder(), info.GetIsolate());\n";
         if ($raisesExceptions) {
             $extraArguments = ", exceptionState";
         }
     }
 
     my $asSetterValue = 0;
@@ skipping 290 matching lines @@
     my $methodName = GetImplName($namedSetterFunction);
     my $interfaceName = $interface->name;
 
     my $type = $namedSetterFunction->parameters->[1]->type;
     my $raisesExceptions = $namedSetterFunction->extendedAttributes->{"RaisesException"};
     my $treatNullAs = $namedSetterFunction->parameters->[1]->extendedAttributes->{"TreatNullAs"};
     my $treatUndefinedAs = $namedSetterFunction->parameters->[1]->extendedAttributes->{"TreatUndefinedAs"};
 
     my $code = "static void namedPropertySetter(v8::Local<v8::String> name, v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<v8::Value>& info)\n";
     $code .= "{\n";
+    $code .= GenerateAttrUsedAsNodeParameterCheckForSetter($type);
     if (!$namedSetterFunction->extendedAttributes->{"OverrideBuiltins"}) {
         $code .= "    if (!info.Holder()->GetRealNamedPropertyInPrototypeChain(name).IsEmpty())\n";
         $code .= "        return;\n";
         $code .= "    if (info.Holder()->HasRealNamedCallbackProperty(name))\n";
         $code .= "        return;\n";
         $code .= "    if (info.Holder()->HasRealNamedProperty(name))\n";
         $code .= "        return;\n";
     }
 
     my $extraArguments = "";
@@ skipping 2333 matching lines @@
         if ($parameter->type eq "SerializedScriptValue") {
             return 1;
         } elsif (IsIntegerType($parameter->type)) {
             return 1;
         }
     }
     return 0;
 }
 
 1;