src/third_party/WebKit/Source/bindings/tests/results/V8TestObjectPython.cpp

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 // This file has been auto-generated by code_generator_v8.py. DO NOT MODIFY!
   6
   7 #include "config.h"
   8 #include "V8TestObjectPython.h"
   9
  10 #include "HTMLNames.h"
  11 #include "RuntimeEnabledFeatures.h"
  12 #include "V8Attr.h"
  13 #include "V8Document.h"
  14 #include "V8DocumentFragment.h"
  15 #include "V8DocumentType.h"
  16 #include "V8Element.h"
  17 #include "V8EventTarget.h"
  18 #include "V8HTMLCollection.h"
  19 #include "V8HTMLElement.h"
  20 #include "V8Node.h"
  21 #include "V8NodeFilter.h"
  22 #include "V8ShadowRoot.h"
  23 #include "V8TestCallbackInterface.h"
  24 #include "V8TestInterface.h"
  25 #include "V8TestInterfaceEmpty.h"
  26 #include "V8TestInterfacePython.h"
  27 #include "V8TestInterfaceWillBeGarbageCollected.h"
  28 #include "V8TestNode.h"
  29 #include "V8TestObjectA.h"
  30 #include "V8Window.h"
  31 #include "V8XPathNSResolver.h"
  32 #include "bindings/v8/BindingSecurity.h"
  33 #include "bindings/v8/Dictionary.h"
  34 #include "bindings/v8/ExceptionState.h"
  35 #include "bindings/v8/ScriptCallStackFactory.h"
  36 #include "bindings/v8/ScriptPromise.h"
  37 #include "bindings/v8/ScriptState.h"
  38 #include "bindings/v8/ScriptValue.h"
  39 #include "bindings/v8/SerializedScriptValue.h"
  40 #include "bindings/v8/V8AbstractEventListener.h"
  41 #include "bindings/v8/V8DOMActivityLogger.h"
  42 #include "bindings/v8/V8DOMConfiguration.h"
  43 #include "bindings/v8/V8EventListenerList.h"
  44 #include "bindings/v8/V8HiddenValue.h"
  45 #include "bindings/v8/V8ObjectConstructor.h"
  46 #include "bindings/v8/custom/V8ArrayBufferCustom.h"
  47 #include "bindings/v8/custom/V8ArrayBufferViewCustom.h"
  48 #include "bindings/v8/custom/V8Float32ArrayCustom.h"
  49 #include "bindings/v8/custom/V8Int32ArrayCustom.h"
  50 #include "bindings/v8/custom/V8Uint8ArrayCustom.h"
  51 #include "core/css/MediaQueryListListener.h"
  52 #include "core/dom/ContextFeatures.h"
  53 #include "core/dom/Document.h"
  54 #include "core/dom/custom/CustomElementCallbackDispatcher.h"
  55 #include "core/frame/DOMWindow.h"
  56 #include "core/frame/UseCounter.h"
  57 #include "core/inspector/ScriptArguments.h"
  58 #include "platform/TraceEvent.h"
  59 #include "wtf/GetPtr.h"
  60 #include "wtf/RefPtr.h"
  61
  62 namespace WebCore {
  63
  64 static void initializeScriptWrappableForInterface(TestObjectPython* object)
  65 {
  66     if (ScriptWrappable::wrapperCanBeStoredInObject(object))
  67         ScriptWrappable::setTypeInfoInObject(object, &V8TestObjectPython::wrapperTypeInfo);
  68     else
  69         ASSERT_NOT_REACHED();
  70 }
  71
  72 } // namespace WebCore
  73
  74 void webCoreInitializeScriptWrappableForInterface(WebCore::TestObjectPython* object)
  75 {
  76     WebCore::initializeScriptWrappableForInterface(object);
  77 }
  78
  79 namespace WebCore {
  80 const WrapperTypeInfo V8TestObjectPython::wrapperTypeInfo = { gin::kEmbedderBlink, V8TestObjectPython::domTemplate, V8TestObjectPython::derefObject, 0, 0, 0, V8TestObjectPython::installPerContextEnabledMethods, 0, WrapperTypeObjectPrototype, false };
  81
  82 namespace TestObjectPythonV8Internal {
  83
  84 template <typename T> void V8_USE(T) { }
  85
  86 static void readonlyStringAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
  87 {
  88     v8::Handle<v8::Object> holder = info.Holder();
  89     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
  90     v8SetReturnValueString(info, impl->readonlyStringAttribute(), info.GetIsolate());
  91 }
  92
  93 static void readonlyStringAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
  94 {
  95     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
  96     TestObjectPythonV8Internal::readonlyStringAttributeAttributeGetter(info);
  97     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
  98 }
  99
 100 static void readonlyTestInterfaceEmptyAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
 101 {
 102     v8::Handle<v8::Object> holder = info.Holder();
 103     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 104     RefPtr<TestInterfaceEmpty> result(impl->readonlyTestInterfaceEmptyAttribute());
 105     if (result && DOMDataStore::setReturnValueFromWrapper<V8TestInterfaceEmpty>(info.GetReturnValue(), result.get()))
 106         return;
 107     v8::Handle<v8::Value> wrapper = toV8(result.get(), holder, info.GetIsolate());
 108     if (!wrapper.IsEmpty()) {
 109         V8HiddenValue::setHiddenValue(info.GetIsolate(), holder, v8AtomicString(info.GetIsolate(), "readonlyTestInterfaceEmptyAttribute"), wrapper);
 110         v8SetReturnValue(info, wrapper);
 111     }
 112 }
 113
 114 static void readonlyTestInterfaceEmptyAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
 115 {
 116     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
 117     TestObjectPythonV8Internal::readonlyTestInterfaceEmptyAttributeAttributeGetter(info);
 118     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 119 }
 120
 121 static void readonlyLongAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
 122 {
 123     v8::Handle<v8::Object> holder = info.Holder();
 124     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 125     v8SetReturnValueInt(info, impl->readonlyLongAttribute());
 126 }
 127
 128 static void readonlyLongAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
 129 {
 130     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
 131     TestObjectPythonV8Internal::readonlyLongAttributeAttributeGetter(info);
 132     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 133 }
 134
 135 static void dateAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
 136 {
 137     v8::Handle<v8::Object> holder = info.Holder();
 138     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 139     v8SetReturnValue(info, v8DateOrNull(impl->dateAttribute(), info.GetIsolate()));
 140 }
 141
 142 static void dateAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
 143 {
 144     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
 145     TestObjectPythonV8Internal::dateAttributeAttributeGetter(info);
 146     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 147 }
 148
 149 static void dateAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 150 {
 151     v8::Handle<v8::Object> holder = info.Holder();
 152     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 153     V8TRYCATCH_VOID(double, cppValue, toCoreDate(v8Value));
 154     impl->setDateAttribute(cppValue);
 155 }
 156
 157 static void dateAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 158 {
 159     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
 160     TestObjectPythonV8Internal::dateAttributeAttributeSetter(v8Value, info);
 161     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 162 }
 163
 164 static void stringAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
 165 {
 166     v8::Handle<v8::Object> holder = info.Holder();
 167     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 168     v8SetReturnValueString(info, impl->stringAttribute(), info.GetIsolate());
 169 }
 170
 171 static void stringAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
 172 {
 173     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
 174     TestObjectPythonV8Internal::stringAttributeAttributeGetter(info);
 175     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 176 }
 177
 178 static void stringAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 179 {
 180     v8::Handle<v8::Object> holder = info.Holder();
 181     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 182     V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, cppValue, v8Value);
 183     impl->setStringAttribute(cppValue);
 184 }
 185
 186 static void stringAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 187 {
 188     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
 189     TestObjectPythonV8Internal::stringAttributeAttributeSetter(v8Value, info);
 190     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 191 }
 192
 193 static void readonlyDOMTimeStampAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
 194 {
 195     v8::Handle<v8::Object> holder = info.Holder();
 196     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 197     v8SetReturnValue(info, static_cast<double>(impl->readonlyDOMTimeStampAttribute()));
 198 }
 199
 200 static void readonlyDOMTimeStampAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
 201 {
 202     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
 203     TestObjectPythonV8Internal::readonlyDOMTimeStampAttributeAttributeGetter(info);
 204     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 205 }
 206
 207 static void booleanAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
 208 {
 209     v8::Handle<v8::Object> holder = info.Holder();
 210     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 211     v8SetReturnValueBool(info, impl->booleanAttribute());
 212 }
 213
 214 static void booleanAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
 215 {
 216     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
 217     TestObjectPythonV8Internal::booleanAttributeAttributeGetter(info);
 218     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 219 }
 220
 221 static void booleanAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 222 {
 223     v8::Handle<v8::Object> holder = info.Holder();
 224     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 225     V8TRYCATCH_VOID(bool, cppValue, v8Value->BooleanValue());
 226     impl->setBooleanAttribute(cppValue);
 227 }
 228
 229 static void booleanAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 230 {
 231     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
 232     TestObjectPythonV8Internal::booleanAttributeAttributeSetter(v8Value, info);
 233     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 234 }
 235
 236 static void byteAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
 237 {
 238     v8::Handle<v8::Object> holder = info.Holder();
 239     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 240     v8SetReturnValueInt(info, impl->byteAttribute());
 241 }
 242
 243 static void byteAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
 244 {
 245     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
 246     TestObjectPythonV8Internal::byteAttributeAttributeGetter(info);
 247     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 248 }
 249
 250 static void byteAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 251 {
 252     v8::Handle<v8::Object> holder = info.Holder();
 253     ExceptionState exceptionState(ExceptionState::SetterContext, "byteAttribute", "TestObjectPython", holder, info.GetIsolate());
 254     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 255     V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt8(v8Value, exceptionState), exceptionState);
 256     impl->setByteAttribute(cppValue);
 257 }
 258
 259 static void byteAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 260 {
 261     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
 262     TestObjectPythonV8Internal::byteAttributeAttributeSetter(v8Value, info);
 263     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 264 }
 265
 266 static void doubleAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
 267 {
 268     v8::Handle<v8::Object> holder = info.Holder();
 269     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 270     v8SetReturnValue(info, impl->doubleAttribute());
 271 }
 272
 273 static void doubleAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
 274 {
 275     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
 276     TestObjectPythonV8Internal::doubleAttributeAttributeGetter(info);
 277     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 278 }
 279
 280 static void doubleAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 281 {
 282     v8::Handle<v8::Object> holder = info.Holder();
 283     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 284     V8TRYCATCH_VOID(double, cppValue, static_cast<double>(v8Value->NumberValue()));
 285     impl->setDoubleAttribute(cppValue);
 286 }
 287
 288 static void doubleAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 289 {
 290     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
 291     TestObjectPythonV8Internal::doubleAttributeAttributeSetter(v8Value, info);
 292     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 293 }
 294
 295 static void floatAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
 296 {
 297     v8::Handle<v8::Object> holder = info.Holder();
 298     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 299     v8SetReturnValue(info, impl->floatAttribute());
 300 }
 301
 302 static void floatAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
 303 {
 304     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
 305     TestObjectPythonV8Internal::floatAttributeAttributeGetter(info);
 306     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 307 }
 308
 309 static void floatAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 310 {
 311     v8::Handle<v8::Object> holder = info.Holder();
 312     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 313     V8TRYCATCH_VOID(float, cppValue, static_cast<float>(v8Value->NumberValue()));
 314     impl->setFloatAttribute(cppValue);
 315 }
 316
 317 static void floatAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 318 {
 319     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
 320     TestObjectPythonV8Internal::floatAttributeAttributeSetter(v8Value, info);
 321     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 322 }
 323
 324 static void longAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
 325 {
 326     v8::Handle<v8::Object> holder = info.Holder();
 327     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 328     v8SetReturnValueInt(info, impl->longAttribute());
 329 }
 330
 331 static void longAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
 332 {
 333     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
 334     TestObjectPythonV8Internal::longAttributeAttributeGetter(info);
 335     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 336 }
 337
 338 static void longAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 339 {
 340     v8::Handle<v8::Object> holder = info.Holder();
 341     ExceptionState exceptionState(ExceptionState::SetterContext, "longAttribute", "TestObjectPython", holder, info.GetIsolate());
 342     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 343     V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(v8Value, exceptionState), exceptionState);
 344     impl->setLongAttribute(cppValue);
 345 }
 346
 347 static void longAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 348 {
 349     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
 350     TestObjectPythonV8Internal::longAttributeAttributeSetter(v8Value, info);
 351     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 352 }
 353
 354 static void longLongAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
 355 {
 356     v8::Handle<v8::Object> holder = info.Holder();
 357     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 358     v8SetReturnValue(info, static_cast<double>(impl->longLongAttribute()));
 359 }
 360
 361 static void longLongAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
 362 {
 363     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
 364     TestObjectPythonV8Internal::longLongAttributeAttributeGetter(info);
 365     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 366 }
 367
 368 static void longLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 369 {
 370     v8::Handle<v8::Object> holder = info.Holder();
 371     ExceptionState exceptionState(ExceptionState::SetterContext, "longLongAttribute", "TestObjectPython", holder, info.GetIsolate());
 372     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 373     V8TRYCATCH_EXCEPTION_VOID(long long, cppValue, toInt64(v8Value, exceptionState), exceptionState);
 374     impl->setLongLongAttribute(cppValue);
 375 }
 376
 377 static void longLongAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 378 {
 379     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
 380     TestObjectPythonV8Internal::longLongAttributeAttributeSetter(v8Value, info);
 381     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 382 }
 383
 384 static void octetAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
 385 {
 386     v8::Handle<v8::Object> holder = info.Holder();
 387     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 388     v8SetReturnValueUnsigned(info, impl->octetAttribute());
 389 }
 390
 391 static void octetAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
 392 {
 393     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
 394     TestObjectPythonV8Internal::octetAttributeAttributeGetter(info);
 395     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 396 }
 397
 398 static void octetAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 399 {
 400     v8::Handle<v8::Object> holder = info.Holder();
 401     ExceptionState exceptionState(ExceptionState::SetterContext, "octetAttribute", "TestObjectPython", holder, info.GetIsolate());
 402     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 403     V8TRYCATCH_EXCEPTION_VOID(unsigned, cppValue, toUInt8(v8Value, exceptionState), exceptionState);
 404     impl->setOctetAttribute(cppValue);
 405 }
 406
 407 static void octetAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 408 {
 409     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
 410     TestObjectPythonV8Internal::octetAttributeAttributeSetter(v8Value, info);
 411     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 412 }
 413
 414 static void shortAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
 415 {
 416     v8::Handle<v8::Object> holder = info.Holder();
 417     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 418     v8SetReturnValueInt(info, impl->shortAttribute());
 419 }
 420
 421 static void shortAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
 422 {
 423     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
 424     TestObjectPythonV8Internal::shortAttributeAttributeGetter(info);
 425     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 426 }
 427
 428 static void shortAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 429 {
 430     v8::Handle<v8::Object> holder = info.Holder();
 431     ExceptionState exceptionState(ExceptionState::SetterContext, "shortAttribute", "TestObjectPython", holder, info.GetIsolate());
 432     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 433     V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt16(v8Value, exceptionState), exceptionState);
 434     impl->setShortAttribute(cppValue);
 435 }
 436
 437 static void shortAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 438 {
 439     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
 440     TestObjectPythonV8Internal::shortAttributeAttributeSetter(v8Value, info);
 441     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 442 }
 443
 444 static void unsignedLongAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
 445 {
 446     v8::Handle<v8::Object> holder = info.Holder();
 447     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 448     v8SetReturnValueUnsigned(info, impl->unsignedLongAttribute());
 449 }
 450
 451 static void unsignedLongAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
 452 {
 453     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
 454     TestObjectPythonV8Internal::unsignedLongAttributeAttributeGetter(info);
 455     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 456 }
 457
 458 static void unsignedLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 459 {
 460     v8::Handle<v8::Object> holder = info.Holder();
 461     ExceptionState exceptionState(ExceptionState::SetterContext, "unsignedLongAttribute", "TestObjectPython", holder, info.GetIsolate());
 462     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 463     V8TRYCATCH_EXCEPTION_VOID(unsigned, cppValue, toUInt32(v8Value, exceptionState), exceptionState);
 464     impl->setUnsignedLongAttribute(cppValue);
 465 }
 466
 467 static void unsignedLongAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 468 {
 469     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
 470     TestObjectPythonV8Internal::unsignedLongAttributeAttributeSetter(v8Value, info);
 471     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 472 }
 473
 474 static void unsignedLongLongAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
 475 {
 476     v8::Handle<v8::Object> holder = info.Holder();
 477     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 478     v8SetReturnValue(info, static_cast<double>(impl->unsignedLongLongAttribute()));
 479 }
 480
 481 static void unsignedLongLongAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
 482 {
 483     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
 484     TestObjectPythonV8Internal::unsignedLongLongAttributeAttributeGetter(info);
 485     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 486 }
 487
 488 static void unsignedLongLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 489 {
 490     v8::Handle<v8::Object> holder = info.Holder();
 491     ExceptionState exceptionState(ExceptionState::SetterContext, "unsignedLongLongAttribute", "TestObjectPython", holder, info.GetIsolate());
 492     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 493     V8TRYCATCH_EXCEPTION_VOID(unsigned long long, cppValue, toUInt64(v8Value, exceptionState), exceptionState);
 494     impl->setUnsignedLongLongAttribute(cppValue);
 495 }
 496
 497 static void unsignedLongLongAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 498 {
 499     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
 500     TestObjectPythonV8Internal::unsignedLongLongAttributeAttributeSetter(v8Value, info);
 501     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 502 }
 503
 504 static void unsignedShortAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
 505 {
 506     v8::Handle<v8::Object> holder = info.Holder();
 507     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 508     v8SetReturnValueUnsigned(info, impl->unsignedShortAttribute());
 509 }
 510
 511 static void unsignedShortAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
 512 {
 513     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
 514     TestObjectPythonV8Internal::unsignedShortAttributeAttributeGetter(info);
 515     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 516 }
 517
 518 static void unsignedShortAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 519 {
 520     v8::Handle<v8::Object> holder = info.Holder();
 521     ExceptionState exceptionState(ExceptionState::SetterContext, "unsignedShortAttribute", "TestObjectPython", holder, info.GetIsolate());
 522     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 523     V8TRYCATCH_EXCEPTION_VOID(unsigned, cppValue, toUInt16(v8Value, exceptionState), exceptionState);
 524     impl->setUnsignedShortAttribute(cppValue);
 525 }
 526
 527 static void unsignedShortAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 528 {
 529     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
 530     TestObjectPythonV8Internal::unsignedShortAttributeAttributeSetter(v8Value, info);
 531     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 532 }
 533
 534 static void testInterfaceEmptyAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
 535 {
 536     v8::Handle<v8::Object> holder = info.Holder();
 537     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 538     v8SetReturnValueFast(info, WTF::getPtr(impl->testInterfaceEmptyAttribute()), impl);
 539 }
 540
 541 static void testInterfaceEmptyAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
 542 {
 543     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
 544     TestObjectPythonV8Internal::testInterfaceEmptyAttributeAttributeGetter(info);
 545     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 546 }
 547
 548 static void testInterfaceEmptyAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 549 {
 550     v8::Handle<v8::Object> holder = info.Holder();
 551     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 552     V8TRYCATCH_VOID(TestInterfaceEmpty*, cppValue, V8TestInterfaceEmpty::toNativeWithTypeCheck(info.GetIsolate(), v8Value));
 553     impl->setTestInterfaceEmptyAttribute(WTF::getPtr(cppValue));
 554 }
 555
 556 static void testInterfaceEmptyAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 557 {
 558     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
 559     TestObjectPythonV8Internal::testInterfaceEmptyAttributeAttributeSetter(v8Value, info);
 560     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 561 }
 562
 563 static void testObjectPythonAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
 564 {
 565     v8::Handle<v8::Object> holder = info.Holder();
 566     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 567     v8SetReturnValueFast(info, WTF::getPtr(impl->testObjectPythonAttribute()), impl);
 568 }
 569
 570 static void testObjectPythonAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
 571 {
 572     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
 573     TestObjectPythonV8Internal::testObjectPythonAttributeAttributeGetter(info);
 574     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 575 }
 576
 577 static void testObjectPythonAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 578 {
 579     v8::Handle<v8::Object> holder = info.Holder();
 580     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 581     V8TRYCATCH_VOID(TestObjectPython*, cppValue, V8TestObjectPython::toNativeWithTypeCheck(info.GetIsolate(), v8Value));
 582     impl->setTestObjectPythonAttribute(WTF::getPtr(cppValue));
 583 }
 584
 585 static void testObjectPythonAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 586 {
 587     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
 588     TestObjectPythonV8Internal::testObjectPythonAttributeAttributeSetter(v8Value, info);
 589     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 590 }
 591
 592 static void voidCallbackFunctionAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
 593 {
 594     v8::Handle<v8::Object> holder = info.Holder();
 595     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 596     v8SetReturnValue(info, impl->voidCallbackFunctionAttribute().v8Value());
 597 }
 598
 599 static void voidCallbackFunctionAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
 600 {
 601     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
 602     TestObjectPythonV8Internal::voidCallbackFunctionAttributeAttributeGetter(info);
 603     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 604 }
 605
 606 static void voidCallbackFunctionAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 607 {
 608     v8::Handle<v8::Object> holder = info.Holder();
 609     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 610     V8TRYCATCH_VOID(ScriptValue, cppValue, ScriptValue(v8Value, info.GetIsolate()));
 611     impl->setVoidCallbackFunctionAttribute(cppValue);
 612 }
 613
 614 static void voidCallbackFunctionAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 615 {
 616     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
 617     TestObjectPythonV8Internal::voidCallbackFunctionAttributeAttributeSetter(v8Value, info);
 618     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 619 }
 620
 621 static void anyCallbackFunctionOptionalAnyArgAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
 622 {
 623     v8::Handle<v8::Object> holder = info.Holder();
 624     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 625     v8SetReturnValue(info, impl->anyCallbackFunctionOptionalAnyArgAttribute().v8Value());
 626 }
 627
 628 static void anyCallbackFunctionOptionalAnyArgAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
 629 {
 630     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
 631     TestObjectPythonV8Internal::anyCallbackFunctionOptionalAnyArgAttributeAttributeGetter(info);
 632     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 633 }
 634
 635 static void anyCallbackFunctionOptionalAnyArgAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 636 {
 637     v8::Handle<v8::Object> holder = info.Holder();
 638     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 639     V8TRYCATCH_VOID(ScriptValue, cppValue, ScriptValue(v8Value, info.GetIsolate()));
 640     impl->setAnyCallbackFunctionOptionalAnyArgAttribute(cppValue);
 641 }
 642
 643 static void anyCallbackFunctionOptionalAnyArgAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 644 {
 645     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
 646     TestObjectPythonV8Internal::anyCallbackFunctionOptionalAnyArgAttributeAttributeSetter(v8Value, info);
 647     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 648 }
 649
 650 static void cssAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
 651 {
 652     v8::Handle<v8::Object> holder = info.Holder();
 653     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 654     v8SetReturnValueInt(info, impl->cssAttribute());
 655 }
 656
 657 static void cssAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
 658 {
 659     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
 660     TestObjectPythonV8Internal::cssAttributeAttributeGetter(info);
 661     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 662 }
 663
 664 static void cssAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 665 {
 666     v8::Handle<v8::Object> holder = info.Holder();
 667     ExceptionState exceptionState(ExceptionState::SetterContext, "cssAttribute", "TestObjectPython", holder, info.GetIsolate());
 668     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 669     V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(v8Value, exceptionState), exceptionState);
 670     impl->setCSSAttribute(cppValue);
 671 }
 672
 673 static void cssAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 674 {
 675     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
 676     TestObjectPythonV8Internal::cssAttributeAttributeSetter(v8Value, info);
 677     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 678 }
 679
 680 static void imeAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
 681 {
 682     v8::Handle<v8::Object> holder = info.Holder();
 683     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 684     v8SetReturnValueInt(info, impl->imeAttribute());
 685 }
 686
 687 static void imeAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
 688 {
 689     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
 690     TestObjectPythonV8Internal::imeAttributeAttributeGetter(info);
 691     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 692 }
 693
 694 static void imeAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 695 {
 696     v8::Handle<v8::Object> holder = info.Holder();
 697     ExceptionState exceptionState(ExceptionState::SetterContext, "imeAttribute", "TestObjectPython", holder, info.GetIsolate());
 698     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 699     V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(v8Value, exceptionState), exceptionState);
 700     impl->setIMEAttribute(cppValue);
 701 }
 702
 703 static void imeAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 704 {
 705     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
 706     TestObjectPythonV8Internal::imeAttributeAttributeSetter(v8Value, info);
 707     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 708 }
 709
 710 static void svgAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
 711 {
 712     v8::Handle<v8::Object> holder = info.Holder();
 713     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 714     v8SetReturnValueInt(info, impl->svgAttribute());
 715 }
 716
 717 static void svgAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
 718 {
 719     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
 720     TestObjectPythonV8Internal::svgAttributeAttributeGetter(info);
 721     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 722 }
 723
 724 static void svgAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 725 {
 726     v8::Handle<v8::Object> holder = info.Holder();
 727     ExceptionState exceptionState(ExceptionState::SetterContext, "svgAttribute", "TestObjectPython", holder, info.GetIsolate());
 728     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 729     V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(v8Value, exceptionState), exceptionState);
 730     impl->setSVGAttribute(cppValue);
 731 }
 732
 733 static void svgAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 734 {
 735     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
 736     TestObjectPythonV8Internal::svgAttributeAttributeSetter(v8Value, info);
 737     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 738 }
 739
 740 static void xmlAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
 741 {
 742     v8::Handle<v8::Object> holder = info.Holder();
 743     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 744     v8SetReturnValueInt(info, impl->xmlAttribute());
 745 }
 746
 747 static void xmlAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
 748 {
 749     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
 750     TestObjectPythonV8Internal::xmlAttributeAttributeGetter(info);
 751     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 752 }
 753
 754 static void xmlAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 755 {
 756     v8::Handle<v8::Object> holder = info.Holder();
 757     ExceptionState exceptionState(ExceptionState::SetterContext, "xmlAttribute", "TestObjectPython", holder, info.GetIsolate());
 758     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 759     V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(v8Value, exceptionState), exceptionState);
 760     impl->setXMLAttribute(cppValue);
 761 }
 762
 763 static void xmlAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 764 {
 765     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
 766     TestObjectPythonV8Internal::xmlAttributeAttributeSetter(v8Value, info);
 767     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 768 }
 769
 770 static void nodeFilterAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
 771 {
 772     v8::Handle<v8::Object> holder = info.Holder();
 773     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 774     v8SetReturnValueFast(info, WTF::getPtr(impl->nodeFilterAttribute()), impl);
 775 }
 776
 777 static void nodeFilterAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
 778 {
 779     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
 780     TestObjectPythonV8Internal::nodeFilterAttributeAttributeGetter(info);
 781     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 782 }
 783
 784 static void nodeFilterAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 785 {
 786     v8::Handle<v8::Object> holder = info.Holder();
 787     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 788     V8TRYCATCH_VOID(RefPtr<NodeFilter>, cppValue, toNodeFilter(v8Value, info.GetIsolate()));
 789     impl->setNodeFilterAttribute(WTF::getPtr(cppValue));
 790 }
 791
 792 static void nodeFilterAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 793 {
 794     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
 795     TestObjectPythonV8Internal::nodeFilterAttributeAttributeSetter(v8Value, info);
 796     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 797 }
 798
 799 static void serializedScriptValueAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
 800 {
 801     v8::Handle<v8::Object> holder = info.Holder();
 802     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 803     v8SetReturnValue(info, impl->serializedScriptValueAttribute() ? impl->serializedScriptValueAttribute()->deserialize() : v8::Handle<v8::Value>(v8::Null(info.GetIsolate())));
 804 }
 805
 806 static void serializedScriptValueAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
 807 {
 808     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
 809     TestObjectPythonV8Internal::serializedScriptValueAttributeAttributeGetter(info);
 810     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 811 }
 812
 813 static void serializedScriptValueAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 814 {
 815     v8::Handle<v8::Object> holder = info.Holder();
 816     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 817     V8TRYCATCH_VOID(RefPtr<SerializedScriptValue>, cppValue, SerializedScriptValue::create(v8Value, info.GetIsolate()));
 818     impl->setSerializedScriptValueAttribute(WTF::getPtr(cppValue));
 819 }
 820
 821 static void serializedScriptValueAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 822 {
 823     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
 824     TestObjectPythonV8Internal::serializedScriptValueAttributeAttributeSetter(v8Value, info);
 825     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 826 }
 827
 828 static void anyAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
 829 {
 830     v8::Handle<v8::Object> holder = info.Holder();
 831     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 832     v8SetReturnValue(info, impl->anyAttribute().v8Value());
 833 }
 834
 835 static void anyAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
 836 {
 837     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
 838     TestObjectPythonV8Internal::anyAttributeAttributeGetter(info);
 839     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 840 }
 841
 842 static void anyAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 843 {
 844     v8::Handle<v8::Object> holder = info.Holder();
 845     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 846     V8TRYCATCH_VOID(ScriptValue, cppValue, ScriptValue(v8Value, info.GetIsolate()));
 847     impl->setAnyAttribute(cppValue);
 848 }
 849
 850 static void anyAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 851 {
 852     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
 853     TestObjectPythonV8Internal::anyAttributeAttributeSetter(v8Value, info);
 854     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 855 }
 856
 857 static void promiseAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
 858 {
 859     v8::Handle<v8::Object> holder = info.Holder();
 860     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 861     v8SetReturnValue(info, impl->promiseAttribute().v8Value());
 862 }
 863
 864 static void promiseAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
 865 {
 866     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
 867     TestObjectPythonV8Internal::promiseAttributeAttributeGetter(info);
 868     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 869 }
 870
 871 static void promiseAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 872 {
 873     v8::Handle<v8::Object> holder = info.Holder();
 874     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 875     V8TRYCATCH_VOID(ScriptPromise, cppValue, ScriptPromise(v8Value, info.GetIsolate()));
 876     impl->setPromiseAttribute(cppValue);
 877 }
 878
 879 static void promiseAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 880 {
 881     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
 882     TestObjectPythonV8Internal::promiseAttributeAttributeSetter(v8Value, info);
 883     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 884 }
 885
 886 static void windowAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
 887 {
 888     v8::Handle<v8::Object> holder = info.Holder();
 889     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 890     v8SetReturnValueFast(info, WTF::getPtr(impl->windowAttribute()), impl);
 891 }
 892
 893 static void windowAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
 894 {
 895     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
 896     TestObjectPythonV8Internal::windowAttributeAttributeGetter(info);
 897     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 898 }
 899
 900 static void windowAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 901 {
 902     v8::Handle<v8::Object> holder = info.Holder();
 903     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 904     V8TRYCATCH_VOID(DOMWindow*, cppValue, toDOMWindow(v8Value, info.GetIsolate()));
 905     impl->setWindowAttribute(WTF::getPtr(cppValue));
 906 }
 907
 908 static void windowAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 909 {
 910     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
 911     TestObjectPythonV8Internal::windowAttributeAttributeSetter(v8Value, info);
 912     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 913 }
 914
 915 static void documentAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
 916 {
 917     v8::Handle<v8::Object> holder = info.Holder();
 918     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 919     v8SetReturnValueFast(info, WTF::getPtr(impl->documentAttribute()), impl);
 920 }
 921
 922 static void documentAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
 923 {
 924     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
 925     TestObjectPythonV8Internal::documentAttributeAttributeGetter(info);
 926     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 927 }
 928
 929 static void documentAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 930 {
 931     v8::Handle<v8::Object> holder = info.Holder();
 932     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 933     V8TRYCATCH_VOID(Document*, cppValue, V8Document::toNativeWithTypeCheck(info.GetIsolate(), v8Value));
 934     impl->setDocumentAttribute(WTF::getPtr(cppValue));
 935 }
 936
 937 static void documentAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 938 {
 939     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
 940     TestObjectPythonV8Internal::documentAttributeAttributeSetter(v8Value, info);
 941     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 942 }
 943
 944 static void documentFragmentAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
 945 {
 946     v8::Handle<v8::Object> holder = info.Holder();
 947     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 948     v8SetReturnValueFast(info, WTF::getPtr(impl->documentFragmentAttribute()), impl);
 949 }
 950
 951 static void documentFragmentAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
 952 {
 953     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
 954     TestObjectPythonV8Internal::documentFragmentAttributeAttributeGetter(info);
 955     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 956 }
 957
 958 static void documentFragmentAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 959 {
 960     v8::Handle<v8::Object> holder = info.Holder();
 961     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 962     V8TRYCATCH_VOID(DocumentFragment*, cppValue, V8DocumentFragment::toNativeWithTypeCheck(info.GetIsolate(), v8Value));
 963     impl->setDocumentFragmentAttribute(WTF::getPtr(cppValue));
 964 }
 965
 966 static void documentFragmentAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 967 {
 968     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
 969     TestObjectPythonV8Internal::documentFragmentAttributeAttributeSetter(v8Value, info);
 970     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 971 }
 972
 973 static void documentTypeAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
 974 {
 975     v8::Handle<v8::Object> holder = info.Holder();
 976     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 977     v8SetReturnValueFast(info, WTF::getPtr(impl->documentTypeAttribute()), impl);
 978 }
 979
 980 static void documentTypeAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
 981 {
 982     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
 983     TestObjectPythonV8Internal::documentTypeAttributeAttributeGetter(info);
 984     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
 985 }
 986
 987 static void documentTypeAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 988 {
 989     v8::Handle<v8::Object> holder = info.Holder();
 990     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
 991     V8TRYCATCH_VOID(DocumentType*, cppValue, V8DocumentType::toNativeWithTypeCheck(info.GetIsolate(), v8Value));
 992     impl->setDocumentTypeAttribute(WTF::getPtr(cppValue));
 993 }
 994
 995 static void documentTypeAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
 996 {
 997     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
 998     TestObjectPythonV8Internal::documentTypeAttributeAttributeSetter(v8Value, info);
 999     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1000 }
1001
1002 static void elementAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
1003 {
1004     v8::Handle<v8::Object> holder = info.Holder();
1005     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
1006     v8SetReturnValueFast(info, WTF::getPtr(impl->elementAttribute()), impl);
1007 }
1008
1009 static void elementAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
1010 {
1011     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
1012     TestObjectPythonV8Internal::elementAttributeAttributeGetter(info);
1013     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1014 }
1015
1016 static void elementAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
1017 {
1018     v8::Handle<v8::Object> holder = info.Holder();
1019     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
1020     V8TRYCATCH_VOID(Element*, cppValue, V8Element::toNativeWithTypeCheck(info.GetIsolate(), v8Value));
1021     impl->setElementAttribute(WTF::getPtr(cppValue));
1022 }
1023
1024 static void elementAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
1025 {
1026     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
1027     TestObjectPythonV8Internal::elementAttributeAttributeSetter(v8Value, info);
1028     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1029 }
1030
1031 static void nodeAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
1032 {
1033     v8::Handle<v8::Object> holder = info.Holder();
1034     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
1035     v8SetReturnValueFast(info, WTF::getPtr(impl->nodeAttribute()), impl);
1036 }
1037
1038 static void nodeAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
1039 {
1040     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
1041     TestObjectPythonV8Internal::nodeAttributeAttributeGetter(info);
1042     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1043 }
1044
1045 static void nodeAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
1046 {
1047     v8::Handle<v8::Object> holder = info.Holder();
1048     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
1049     V8TRYCATCH_VOID(Node*, cppValue, V8Node::toNativeWithTypeCheck(info.GetIsolate(), v8Value));
1050     impl->setNodeAttribute(WTF::getPtr(cppValue));
1051 }
1052
1053 static void nodeAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
1054 {
1055     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
1056     TestObjectPythonV8Internal::nodeAttributeAttributeSetter(v8Value, info);
1057     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1058 }
1059
1060 static void shadowRootAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
1061 {
1062     v8::Handle<v8::Object> holder = info.Holder();
1063     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
1064     v8SetReturnValueFast(info, WTF::getPtr(impl->shadowRootAttribute()), impl);
1065 }
1066
1067 static void shadowRootAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
1068 {
1069     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
1070     TestObjectPythonV8Internal::shadowRootAttributeAttributeGetter(info);
1071     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1072 }
1073
1074 static void shadowRootAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
1075 {
1076     v8::Handle<v8::Object> holder = info.Holder();
1077     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
1078     V8TRYCATCH_VOID(ShadowRoot*, cppValue, V8ShadowRoot::toNativeWithTypeCheck(info.GetIsolate(), v8Value));
1079     impl->setShadowRootAttribute(WTF::getPtr(cppValue));
1080 }
1081
1082 static void shadowRootAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
1083 {
1084     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
1085     TestObjectPythonV8Internal::shadowRootAttributeAttributeSetter(v8Value, info);
1086     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1087 }
1088
1089 static void arrayBufferAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
1090 {
1091     v8::Handle<v8::Object> holder = info.Holder();
1092     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
1093     v8SetReturnValueFast(info, WTF::getPtr(impl->arrayBufferAttribute()), impl);
1094 }
1095
1096 static void arrayBufferAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
1097 {
1098     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
1099     TestObjectPythonV8Internal::arrayBufferAttributeAttributeGetter(info);
1100     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1101 }
1102
1103 static void arrayBufferAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
1104 {
1105     v8::Handle<v8::Object> holder = info.Holder();
1106     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
1107     V8TRYCATCH_VOID(ArrayBuffer*, cppValue, v8Value->IsArrayBuffer() ? V8ArrayBuffer::toNative(v8::Handle<v8::ArrayBuffer>::Cast(v8Value)) : 0);
1108     impl->setArrayBufferAttribute(WTF::getPtr(cppValue));
1109 }
1110
1111 static void arrayBufferAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
1112 {
1113     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
1114     TestObjectPythonV8Internal::arrayBufferAttributeAttributeSetter(v8Value, info);
1115     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1116 }
1117
1118 static void float32ArrayAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
1119 {
1120     v8::Handle<v8::Object> holder = info.Holder();
1121     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
1122     v8SetReturnValueFast(info, WTF::getPtr(impl->float32ArrayAttribute()), impl);
1123 }
1124
1125 static void float32ArrayAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
1126 {
1127     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
1128     TestObjectPythonV8Internal::float32ArrayAttributeAttributeGetter(info);
1129     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1130 }
1131
1132 static void float32ArrayAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
1133 {
1134     v8::Handle<v8::Object> holder = info.Holder();
1135     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
1136     V8TRYCATCH_VOID(Float32Array*, cppValue, v8Value->IsFloat32Array() ? V8Float32Array::toNative(v8::Handle<v8::Float32Array>::Cast(v8Value)) : 0);
1137     impl->setFloat32ArrayAttribute(WTF::getPtr(cppValue));
1138 }
1139
1140 static void float32ArrayAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
1141 {
1142     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
1143     TestObjectPythonV8Internal::float32ArrayAttributeAttributeSetter(v8Value, info);
1144     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1145 }
1146
1147 static void uint8ArrayAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
1148 {
1149     v8::Handle<v8::Object> holder = info.Holder();
1150     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
1151     v8SetReturnValueFast(info, WTF::getPtr(impl->uint8ArrayAttribute()), impl);
1152 }
1153
1154 static void uint8ArrayAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
1155 {
1156     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
1157     TestObjectPythonV8Internal::uint8ArrayAttributeAttributeGetter(info);
1158     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1159 }
1160
1161 static void uint8ArrayAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
1162 {
1163     v8::Handle<v8::Object> holder = info.Holder();
1164     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
1165     V8TRYCATCH_VOID(Uint8Array*, cppValue, v8Value->IsUint8Array() ? V8Uint8Array::toNative(v8::Handle<v8::Uint8Array>::Cast(v8Value)) : 0);
1166     impl->setUint8ArrayAttribute(WTF::getPtr(cppValue));
1167 }
1168
1169 static void uint8ArrayAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
1170 {
1171     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
1172     TestObjectPythonV8Internal::uint8ArrayAttributeAttributeSetter(v8Value, info);
1173     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1174 }
1175
1176 static void selfAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
1177 {
1178     v8::Handle<v8::Object> holder = info.Holder();
1179     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
1180     v8SetReturnValueFast(info, WTF::getPtr(impl->self()), impl);
1181 }
1182
1183 static void selfAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
1184 {
1185     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
1186     TestObjectPythonV8Internal::selfAttributeGetter(info);
1187     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1188 }
1189
1190 static void readonlyEventTargetAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
1191 {
1192     v8::Handle<v8::Object> holder = info.Holder();
1193     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
1194     v8SetReturnValueFast(info, WTF::getPtr(impl->readonlyEventTargetAttribute()), impl);
1195 }
1196
1197 static void readonlyEventTargetAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
1198 {
1199     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
1200     TestObjectPythonV8Internal::readonlyEventTargetAttributeAttributeGetter(info);
1201     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1202 }
1203
1204 static void readonlyEventTargetOrNullAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
1205 {
1206     v8::Handle<v8::Object> holder = info.Holder();
1207     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
1208     bool isNull = false;
1209     RefPtr<EventTarget> v8Value = impl->readonlyEventTargetOrNullAttribute(isNull);
1210     if (isNull) {
1211         v8SetReturnValueNull(info);
1212         return;
1213     }
1214     v8SetReturnValueFast(info, WTF::getPtr(v8Value.release()), impl);
1215 }
1216
1217 static void readonlyEventTargetOrNullAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
1218 {
1219     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
1220     TestObjectPythonV8Internal::readonlyEventTargetOrNullAttributeAttributeGetter(info);
1221     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1222 }
1223
1224 static void readonlyWindowAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
1225 {
1226     v8::Handle<v8::Object> holder = info.Holder();
1227     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
1228     v8SetReturnValueFast(info, WTF::getPtr(impl->readonlyWindowAttribute()), impl);
1229 }
1230
1231 static void readonlyWindowAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
1232 {
1233     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
1234     TestObjectPythonV8Internal::readonlyWindowAttributeAttributeGetter(info);
1235     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1236 }
1237
1238 static void htmlCollectionAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
1239 {
1240     v8::Handle<v8::Object> holder = info.Holder();
1241     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
1242     v8SetReturnValueFast(info, WTF::getPtr(impl->htmlCollectionAttribute()), impl);
1243 }
1244
1245 static void htmlCollectionAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
1246 {
1247     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
1248     TestObjectPythonV8Internal::htmlCollectionAttributeAttributeGetter(info);
1249     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1250 }
1251
1252 static void htmlElementAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
1253 {
1254     v8::Handle<v8::Object> holder = info.Holder();
1255     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
1256     v8SetReturnValueFast(info, WTF::getPtr(impl->htmlElementAttribute()), impl);
1257 }
1258
1259 static void htmlElementAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
1260 {
1261     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
1262     TestObjectPythonV8Internal::htmlElementAttributeAttributeGetter(info);
1263     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1264 }
1265
1266 static void stringArrayAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
1267 {
1268     v8::Handle<v8::Object> holder = info.Holder();
1269     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
1270     v8SetReturnValue(info, v8Array(impl->stringArrayAttribute(), info.GetIsolate()));
1271 }
1272
1273 static void stringArrayAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
1274 {
1275     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
1276     TestObjectPythonV8Internal::stringArrayAttributeAttributeGetter(info);
1277     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1278 }
1279
1280 static void stringArrayAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
1281 {
1282     v8::Handle<v8::Object> holder = info.Holder();
1283     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
1284     V8TRYCATCH_VOID(Vector<String>, cppValue, toNativeArray<String>(v8Value, 0, info.GetIsolate()));
1285     impl->setStringArrayAttribute(cppValue);
1286 }
1287
1288 static void stringArrayAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
1289 {
1290     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
1291     TestObjectPythonV8Internal::stringArrayAttributeAttributeSetter(v8Value, info);
1292     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1293 }
1294
1295 static void testInterfaceEmptyArrayAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
1296 {
1297     v8::Handle<v8::Object> holder = info.Holder();
1298     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
1299     v8SetReturnValue(info, v8Array(impl->testInterfaceEmptyArrayAttribute(), info.GetIsolate()));
1300 }
1301
1302 static void testInterfaceEmptyArrayAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
1303 {
1304     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
1305     TestObjectPythonV8Internal::testInterfaceEmptyArrayAttributeAttributeGetter(info);
1306     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1307 }
1308
1309 static void testInterfaceEmptyArrayAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
1310 {
1311     v8::Handle<v8::Object> holder = info.Holder();
1312     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
1313     V8TRYCATCH_VOID(Vector<RefPtr<TestInterfaceEmpty> >, cppValue, (toRefPtrNativeArray<TestInterfaceEmpty, V8TestInterfaceEmpty>(v8Value, 0, info.GetIsolate())));
1314     impl->setTestInterfaceEmptyArrayAttribute(cppValue);
1315 }
1316
1317 static void testInterfaceEmptyArrayAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
1318 {
1319     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
1320     TestObjectPythonV8Internal::testInterfaceEmptyArrayAttributeAttributeSetter(v8Value, info);
1321     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1322 }
1323
1324 static void floatArrayAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
1325 {
1326     v8::Handle<v8::Object> holder = info.Holder();
1327     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
1328     v8SetReturnValue(info, v8Array(impl->floatArrayAttribute(), info.GetIsolate()));
1329 }
1330
1331 static void floatArrayAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
1332 {
1333     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
1334     TestObjectPythonV8Internal::floatArrayAttributeAttributeGetter(info);
1335     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1336 }
1337
1338 static void floatArrayAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
1339 {
1340     v8::Handle<v8::Object> holder = info.Holder();
1341     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
1342     V8TRYCATCH_VOID(Vector<float>, cppValue, toNativeArray<float>(v8Value, 0, info.GetIsolate()));
1343     impl->setFloatArrayAttribute(cppValue);
1344 }
1345
1346 static void floatArrayAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
1347 {
1348     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
1349     TestObjectPythonV8Internal::floatArrayAttributeAttributeSetter(v8Value, info);
1350     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1351 }
1352
1353 static void stringOrNullAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
1354 {
1355     v8::Handle<v8::Object> holder = info.Holder();
1356     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
1357     bool isNull = false;
1358     String v8Value = impl->stringOrNullAttribute(isNull);
1359     if (isNull) {
1360         v8SetReturnValueNull(info);
1361         return;
1362     }
1363     v8SetReturnValueString(info, v8Value, info.GetIsolate());
1364 }
1365
1366 static void stringOrNullAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
1367 {
1368     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
1369     TestObjectPythonV8Internal::stringOrNullAttributeAttributeGetter(info);
1370     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1371 }
1372
1373 static void stringOrNullAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
1374 {
1375     v8::Handle<v8::Object> holder = info.Holder();
1376     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
1377     V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, cppValue, v8Value);
1378     impl->setStringOrNullAttribute(cppValue);
1379 }
1380
1381 static void stringOrNullAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
1382 {
1383     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
1384     TestObjectPythonV8Internal::stringOrNullAttributeAttributeSetter(v8Value, info);
1385     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1386 }
1387
1388 static void longOrNullAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
1389 {
1390     v8::Handle<v8::Object> holder = info.Holder();
1391     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
1392     bool isNull = false;
1393     int v8Value = impl->longOrNullAttribute(isNull);
1394     if (isNull) {
1395         v8SetReturnValueNull(info);
1396         return;
1397     }
1398     v8SetReturnValueInt(info, v8Value);
1399 }
1400
1401 static void longOrNullAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
1402 {
1403     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
1404     TestObjectPythonV8Internal::longOrNullAttributeAttributeGetter(info);
1405     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1406 }
1407
1408 static void longOrNullAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
1409 {
1410     v8::Handle<v8::Object> holder = info.Holder();
1411     ExceptionState exceptionState(ExceptionState::SetterContext, "longOrNullAttribute", "TestObjectPython", holder, info.GetIsolate());
1412     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
1413     V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(v8Value, exceptionState), exceptionState);
1414     impl->setLongOrNullAttribute(cppValue);
1415 }
1416
1417 static void longOrNullAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
1418 {
1419     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
1420     TestObjectPythonV8Internal::longOrNullAttributeAttributeSetter(v8Value, info);
1421     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1422 }
1423
1424 static void testInterfaceOrNullAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
1425 {
1426     v8::Handle<v8::Object> holder = info.Holder();
1427     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
1428     bool isNull = false;
1429     RefPtr<TestInterface> v8Value = impl->testInterfaceOrNullAttribute(isNull);
1430     if (isNull) {
1431         v8SetReturnValueNull(info);
1432         return;
1433     }
1434     v8SetReturnValueFast(info, WTF::getPtr(v8Value.release()), impl);
1435 }
1436
1437 static void testInterfaceOrNullAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
1438 {
1439     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
1440     TestObjectPythonV8Internal::testInterfaceOrNullAttributeAttributeGetter(info);
1441     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1442 }
1443
1444 static void testInterfaceOrNullAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
1445 {
1446     v8::Handle<v8::Object> holder = info.Holder();
1447     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
1448     V8TRYCATCH_VOID(TestInterface*, cppValue, V8TestInterface::toNativeWithTypeCheck(info.GetIsolate(), v8Value));
1449     impl->setTestInterfaceOrNullAttribute(WTF::getPtr(cppValue));
1450 }
1451
1452 static void testInterfaceOrNullAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
1453 {
1454     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
1455     TestObjectPythonV8Internal::testInterfaceOrNullAttributeAttributeSetter(v8Value, info);
1456     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1457 }
1458
1459 static void testEnumAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
1460 {
1461     v8::Handle<v8::Object> holder = info.Holder();
1462     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
1463     v8SetReturnValueString(info, impl->testEnumAttribute(), info.GetIsolate());
1464 }
1465
1466 static void testEnumAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
1467 {
1468     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
1469     TestObjectPythonV8Internal::testEnumAttributeAttributeGetter(info);
1470     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1471 }
1472
1473 static void testEnumAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
1474 {
1475     v8::Handle<v8::Object> holder = info.Holder();
1476     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
1477     V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, cppValue, v8Value);
1478     String string = cppValue;
1479     if (!(string == "" || string == "EnumValue1" || string == "EnumValue2" || string == "EnumValue3"))
1480         return;
1481     impl->setTestEnumAttribute(cppValue);
1482 }
1483
1484 static void testEnumAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
1485 {
1486     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
1487     TestObjectPythonV8Internal::testEnumAttributeAttributeSetter(v8Value, info);
1488     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1489 }
1490
1491 static void staticStringAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
1492 {
1493     v8SetReturnValueString(info, TestObjectPython::staticStringAttribute(), info.GetIsolate());
1494 }
1495
1496 static void staticStringAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
1497 {
1498     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
1499     TestObjectPythonV8Internal::staticStringAttributeAttributeGetter(info);
1500     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1501 }
1502
1503 static void staticStringAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
1504 {
1505     V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, cppValue, v8Value);
1506     TestObjectPython::setStaticStringAttribute(cppValue);
1507 }
1508
1509 static void staticStringAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
1510 {
1511     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
1512     TestObjectPythonV8Internal::staticStringAttributeAttributeSetter(v8Value, info);
1513     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1514 }
1515
1516 static void staticLongAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
1517 {
1518     v8SetReturnValueInt(info, TestObjectPython::staticLongAttribute());
1519 }
1520
1521 static void staticLongAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
1522 {
1523     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
1524     TestObjectPythonV8Internal::staticLongAttributeAttributeGetter(info);
1525     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1526 }
1527
1528 static void staticLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
1529 {
1530     ExceptionState exceptionState(ExceptionState::SetterContext, "staticLongAttribute", "TestObjectPython", holder, info.GetIsolate());
1531     V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(v8Value, exceptionState), exceptionState);
1532     TestObjectPython::setStaticLongAttribute(cppValue);
1533 }
1534
1535 static void staticLongAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
1536 {
1537     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
1538     TestObjectPythonV8Internal::staticLongAttributeAttributeSetter(v8Value, info);
1539     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1540 }
1541
1542 static void eventHandlerAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
1543 {
1544     v8::Handle<v8::Object> holder = info.Holder();
1545     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
1546     EventListener* v8Value = impl->eventHandlerAttribute();
1547     v8SetReturnValue(info, v8Value ? v8::Handle<v8::Value>(V8AbstractEventListener::cast(v8Value)->getListenerObject(impl->executionContext())) : v8::Handle<v8::Value>(v8::Null(info.GetIsolate())));
1548 }
1549
1550 static void eventHandlerAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
1551 {
1552     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
1553     TestObjectPythonV8Internal::eventHandlerAttributeAttributeGetter(info);
1554     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1555 }
1556
1557 static void eventHandlerAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
1558 {
1559     v8::Handle<v8::Object> holder = info.Holder();
1560     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
1561     moveEventListenerToNewWrapper(holder, impl->eventHandlerAttribute(), v8Value, V8TestObjectPython::eventListenerCacheIndex, info.GetIsolate());
1562     impl->setEventHandlerAttribute(V8EventListenerList::getEventListener(v8Value, true, ListenerFindOrCreate));
1563 }
1564
1565 static void eventHandlerAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
1566 {
1567     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
1568     TestObjectPythonV8Internal::eventHandlerAttributeAttributeSetter(v8Value, info);
1569     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1570 }
1571
1572 static void activityLoggingAccessForAllWorldsLongAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
1573 {
1574     v8::Handle<v8::Object> holder = info.Holder();
1575     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
1576     v8SetReturnValueInt(info, impl->activityLoggingAccessForAllWorldsLongAttribute());
1577 }
1578
1579 static void activityLoggingAccessForAllWorldsLongAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
1580 {
1581     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
1582     V8PerContextData* contextData = V8PerContextData::from(info.GetIsolate()->GetCurrentContext());
1583     if (contextData && contextData->activityLogger())
1584         contextData->activityLogger()->log("TestObjectPython.activityLoggingAccessForAllWorldsLongAttribute", 0, 0, "Getter");
1585     TestObjectPythonV8Internal::activityLoggingAccessForAllWorldsLongAttributeAttributeGetter(info);
1586     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1587 }
1588
1589 static void activityLoggingAccessForAllWorldsLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
1590 {
1591     v8::Handle<v8::Object> holder = info.Holder();
1592     ExceptionState exceptionState(ExceptionState::SetterContext, "activityLoggingAccessForAllWorldsLongAttribute", "TestObjectPython", holder, info.GetIsolate());
1593     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
1594     V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(v8Value, exceptionState), exceptionState);
1595     impl->setActivityLoggingAccessForAllWorldsLongAttribute(cppValue);
1596 }
1597
1598 static void activityLoggingAccessForAllWorldsLongAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
1599 {
1600     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
1601     V8PerContextData* contextData = V8PerContextData::from(info.GetIsolate()->GetCurrentContext());
1602     if (contextData && contextData->activityLogger()) {
1603         v8::Handle<v8::Value> loggerArg[] = { v8Value };
1604         contextData->activityLogger()->log("TestObjectPython.activityLoggingAccessForAllWorldsLongAttribute", 1, &loggerArg[0], "Setter");
1605     }
1606     TestObjectPythonV8Internal::activityLoggingAccessForAllWorldsLongAttributeAttributeSetter(v8Value, info);
1607     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1608 }
1609
1610 static void activityLoggingGetterForAllWorldsLongAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
1611 {
1612     v8::Handle<v8::Object> holder = info.Holder();
1613     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
1614     v8SetReturnValueInt(info, impl->activityLoggingGetterForAllWorldsLongAttribute());
1615 }
1616
1617 static void activityLoggingGetterForAllWorldsLongAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
1618 {
1619     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
1620     V8PerContextData* contextData = V8PerContextData::from(info.GetIsolate()->GetCurrentContext());
1621     if (contextData && contextData->activityLogger())
1622         contextData->activityLogger()->log("TestObjectPython.activityLoggingGetterForAllWorldsLongAttribute", 0, 0, "Getter");
1623     TestObjectPythonV8Internal::activityLoggingGetterForAllWorldsLongAttributeAttributeGetter(info);
1624     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1625 }
1626
1627 static void activityLoggingGetterForAllWorldsLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
1628 {
1629     v8::Handle<v8::Object> holder = info.Holder();
1630     ExceptionState exceptionState(ExceptionState::SetterContext, "activityLoggingGetterForAllWorldsLongAttribute", "TestObjectPython", holder, info.GetIsolate());
1631     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
1632     V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(v8Value, exceptionState), exceptionState);
1633     impl->setActivityLoggingGetterForAllWorldsLongAttribute(cppValue);
1634 }
1635
1636 static void activityLoggingGetterForAllWorldsLongAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
1637 {
1638     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
1639     TestObjectPythonV8Internal::activityLoggingGetterForAllWorldsLongAttributeAttributeSetter(v8Value, info);
1640     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1641 }
1642
1643 static void activityLoggingSetterForAllWorldsLongAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
1644 {
1645     v8::Handle<v8::Object> holder = info.Holder();
1646     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
1647     v8SetReturnValueInt(info, impl->activityLoggingSetterForAllWorldsLongAttribute());
1648 }
1649
1650 static void activityLoggingSetterForAllWorldsLongAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
1651 {
1652     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
1653     TestObjectPythonV8Internal::activityLoggingSetterForAllWorldsLongAttributeAttributeGetter(info);
1654     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1655 }
1656
1657 static void activityLoggingSetterForAllWorldsLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
1658 {
1659     v8::Handle<v8::Object> holder = info.Holder();
1660     ExceptionState exceptionState(ExceptionState::SetterContext, "activityLoggingSetterForAllWorldsLongAttribute", "TestObjectPython", holder, info.GetIsolate());
1661     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
1662     V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(v8Value, exceptionState), exceptionState);
1663     impl->setActivityLoggingSetterForAllWorldsLongAttribute(cppValue);
1664 }
1665
1666 static void activityLoggingSetterForAllWorldsLongAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
1667 {
1668     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
1669     V8PerContextData* contextData = V8PerContextData::from(info.GetIsolate()->GetCurrentContext());
1670     if (contextData && contextData->activityLogger()) {
1671         v8::Handle<v8::Value> loggerArg[] = { v8Value };
1672         contextData->activityLogger()->log("TestObjectPython.activityLoggingSetterForAllWorldsLongAttribute", 1, &loggerArg[0], "Setter");
1673     }
1674     TestObjectPythonV8Internal::activityLoggingSetterForAllWorldsLongAttributeAttributeSetter(v8Value, info);
1675     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1676 }
1677
1678 static void cachedAttributeAnyAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
1679 {
1680     v8::Handle<v8::Object> holder = info.Holder();
1681     v8::Handle<v8::String> propertyName = v8AtomicString(info.GetIsolate(), "cachedAttributeAnyAttribute");
1682     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
1683     if (!impl->isValueDirty()) {
1684         v8::Handle<v8::Value> v8Value = V8HiddenValue::getHiddenValue(info.GetIsolate(), holder, propertyName);
1685         if (!v8Value.IsEmpty()) {
1686             v8SetReturnValue(info, v8Value);
1687             return;
1688         }
1689     }
1690     ScriptValue v8Value = impl->cachedAttributeAnyAttribute();
1691     V8HiddenValue::setHiddenValue(info.GetIsolate(), holder, propertyName, v8Value.v8Value());
1692     v8SetReturnValue(info, v8Value.v8Value());
1693 }
1694
1695 static void cachedAttributeAnyAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
1696 {
1697     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
1698     TestObjectPythonV8Internal::cachedAttributeAnyAttributeAttributeGetter(info);
1699     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1700 }
1701
1702 static void cachedAttributeAnyAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
1703 {
1704     v8::Handle<v8::Object> holder = info.Holder();
1705     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
1706     V8TRYCATCH_VOID(ScriptValue, cppValue, ScriptValue(v8Value, info.GetIsolate()));
1707     impl->setCachedAttributeAnyAttribute(cppValue);
1708     V8HiddenValue::deleteHiddenValue(info.GetIsolate(), holder, v8AtomicString(info.GetIsolate(), "cachedAttributeAnyAttribute")); // Invalidate the cached value.
1709 }
1710
1711 static void cachedAttributeAnyAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
1712 {
1713     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
1714     TestObjectPythonV8Internal::cachedAttributeAnyAttributeAttributeSetter(v8Value, info);
1715     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1716 }
1717
1718 static void callWithExecutionContextAnyAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
1719 {
1720     v8::Handle<v8::Object> holder = info.Holder();
1721     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
1722     ExecutionContext* scriptContext = currentExecutionContext(info.GetIsolate());
1723     v8SetReturnValue(info, impl->callWithExecutionContextAnyAttribute(scriptContext).v8Value());
1724 }
1725
1726 static void callWithExecutionContextAnyAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
1727 {
1728     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
1729     TestObjectPythonV8Internal::callWithExecutionContextAnyAttributeAttributeGetter(info);
1730     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1731 }
1732
1733 static void callWithExecutionContextAnyAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
1734 {
1735     v8::Handle<v8::Object> holder = info.Holder();
1736     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
1737     V8TRYCATCH_VOID(ScriptValue, cppValue, ScriptValue(v8Value, info.GetIsolate()));
1738     ExecutionContext* scriptContext = currentExecutionContext(info.GetIsolate());
1739     impl->setCallWithExecutionContextAnyAttribute(scriptContext, cppValue);
1740 }
1741
1742 static void callWithExecutionContextAnyAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
1743 {
1744     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
1745     TestObjectPythonV8Internal::callWithExecutionContextAnyAttributeAttributeSetter(v8Value, info);
1746     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1747 }
1748
1749 static void checkSecurityForNodeReadonlyDocumentAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
1750 {
1751     v8::Handle<v8::Object> holder = info.Holder();
1752     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
1753     ExceptionState exceptionState(ExceptionState::GetterContext, "checkSecurityForNodeReadonlyDocumentAttribute", "TestObjectPython", holder, info.GetIsolate());
1754     if (!BindingSecurity::shouldAllowAccessToNode(info.GetIsolate(), impl->checkSecurityForNodeReadonlyDocumentAttribute(), exceptionState)) {
1755         v8SetReturnValueNull(info);
1756         exceptionState.throwIfNeeded();
1757         return;
1758     }
1759     v8SetReturnValueFast(info, WTF::getPtr(impl->checkSecurityForNodeReadonlyDocumentAttribute()), impl);
1760 }
1761
1762 static void checkSecurityForNodeReadonlyDocumentAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
1763 {
1764     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
1765     TestObjectPythonV8Internal::checkSecurityForNodeReadonlyDocumentAttributeAttributeGetter(info);
1766     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1767 }
1768
1769 #if ENABLE(CONDITION)
1770 static void conditionalLongAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
1771 {
1772     v8::Handle<v8::Object> holder = info.Holder();
1773     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
1774     v8SetReturnValueInt(info, impl->conditionalLongAttribute());
1775 }
1776 #endif // ENABLE(CONDITION)
1777
1778 #if ENABLE(CONDITION)
1779 static void conditionalLongAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
1780 {
1781     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
1782     TestObjectPythonV8Internal::conditionalLongAttributeAttributeGetter(info);
1783     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1784 }
1785 #endif // ENABLE(CONDITION)
1786
1787 #if ENABLE(CONDITION)
1788 static void conditionalLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
1789 {
1790     v8::Handle<v8::Object> holder = info.Holder();
1791     ExceptionState exceptionState(ExceptionState::SetterContext, "conditionalLongAttribute", "TestObjectPython", holder, info.GetIsolate());
1792     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
1793     V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(v8Value, exceptionState), exceptionState);
1794     impl->setConditionalLongAttribute(cppValue);
1795 }
1796 #endif // ENABLE(CONDITION)
1797
1798 #if ENABLE(CONDITION)
1799 static void conditionalLongAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
1800 {
1801     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
1802     TestObjectPythonV8Internal::conditionalLongAttributeAttributeSetter(v8Value, info);
1803     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1804 }
1805 #endif // ENABLE(CONDITION)
1806
1807 #if ENABLE(CONDITION_1) && ENABLE(CONDITION_2)
1808 static void conditionalAndLongAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
1809 {
1810     v8::Handle<v8::Object> holder = info.Holder();
1811     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
1812     v8SetReturnValueInt(info, impl->conditionalAndLongAttribute());
1813 }
1814 #endif // ENABLE(CONDITION_1) && ENABLE(CONDITION_2)
1815
1816 #if ENABLE(CONDITION_1) && ENABLE(CONDITION_2)
1817 static void conditionalAndLongAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
1818 {
1819     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
1820     TestObjectPythonV8Internal::conditionalAndLongAttributeAttributeGetter(info);
1821     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1822 }
1823 #endif // ENABLE(CONDITION_1) && ENABLE(CONDITION_2)
1824
1825 #if ENABLE(CONDITION_1) && ENABLE(CONDITION_2)
1826 static void conditionalAndLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
1827 {
1828     v8::Handle<v8::Object> holder = info.Holder();
1829     ExceptionState exceptionState(ExceptionState::SetterContext, "conditionalAndLongAttribute", "TestObjectPython", holder, info.GetIsolate());
1830     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
1831     V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(v8Value, exceptionState), exceptionState);
1832     impl->setConditionalAndLongAttribute(cppValue);
1833 }
1834 #endif // ENABLE(CONDITION_1) && ENABLE(CONDITION_2)
1835
1836 #if ENABLE(CONDITION_1) && ENABLE(CONDITION_2)
1837 static void conditionalAndLongAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
1838 {
1839     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
1840     TestObjectPythonV8Internal::conditionalAndLongAttributeAttributeSetter(v8Value, info);
1841     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1842 }
1843 #endif // ENABLE(CONDITION_1) && ENABLE(CONDITION_2)
1844
1845 #if ENABLE(CONDITION_1) || ENABLE(CONDITION_2)
1846 static void conditionalOrLongAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
1847 {
1848     v8::Handle<v8::Object> holder = info.Holder();
1849     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
1850     v8SetReturnValueInt(info, impl->conditionalOrLongAttribute());
1851 }
1852 #endif // ENABLE(CONDITION_1) || ENABLE(CONDITION_2)
1853
1854 #if ENABLE(CONDITION_1) || ENABLE(CONDITION_2)
1855 static void conditionalOrLongAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
1856 {
1857     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
1858     TestObjectPythonV8Internal::conditionalOrLongAttributeAttributeGetter(info);
1859     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1860 }
1861 #endif // ENABLE(CONDITION_1) || ENABLE(CONDITION_2)
1862
1863 #if ENABLE(CONDITION_1) || ENABLE(CONDITION_2)
1864 static void conditionalOrLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
1865 {
1866     v8::Handle<v8::Object> holder = info.Holder();
1867     ExceptionState exceptionState(ExceptionState::SetterContext, "conditionalOrLongAttribute", "TestObjectPython", holder, info.GetIsolate());
1868     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
1869     V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(v8Value, exceptionState), exceptionState);
1870     impl->setConditionalOrLongAttribute(cppValue);
1871 }
1872 #endif // ENABLE(CONDITION_1) || ENABLE(CONDITION_2)
1873
1874 #if ENABLE(CONDITION_1) || ENABLE(CONDITION_2)
1875 static void conditionalOrLongAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
1876 {
1877     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
1878     TestObjectPythonV8Internal::conditionalOrLongAttributeAttributeSetter(v8Value, info);
1879     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1880 }
1881 #endif // ENABLE(CONDITION_1) || ENABLE(CONDITION_2)
1882
1883 static void customObjectAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
1884 {
1885     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
1886     V8TestObjectPython::customObjectAttributeAttributeGetterCustom(info);
1887     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1888 }
1889
1890 static void customObjectAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
1891 {
1892     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
1893     V8TestObjectPython::customObjectAttributeAttributeSetterCustom(v8Value, info);
1894     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1895 }
1896
1897 static void customGetterLongAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
1898 {
1899     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
1900     V8TestObjectPython::customGetterLongAttributeAttributeGetterCustom(info);
1901     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1902 }
1903
1904 static void customGetterLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
1905 {
1906     v8::Handle<v8::Object> holder = info.Holder();
1907     ExceptionState exceptionState(ExceptionState::SetterContext, "customGetterLongAttribute", "TestObjectPython", holder, info.GetIsolate());
1908     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
1909     V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(v8Value, exceptionState), exceptionState);
1910     impl->setCustomGetterLongAttribute(cppValue);
1911 }
1912
1913 static void customGetterLongAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
1914 {
1915     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
1916     TestObjectPythonV8Internal::customGetterLongAttributeAttributeSetter(v8Value, info);
1917     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1918 }
1919
1920 static void customGetterReadonlyObjectAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
1921 {
1922     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
1923     V8TestObjectPython::customGetterReadonlyObjectAttributeAttributeGetterCustom(info);
1924     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1925 }
1926
1927 static void customSetterLongAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
1928 {
1929     v8::Handle<v8::Object> holder = info.Holder();
1930     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
1931     v8SetReturnValueInt(info, impl->customSetterLongAttribute());
1932 }
1933
1934 static void customSetterLongAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
1935 {
1936     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
1937     TestObjectPythonV8Internal::customSetterLongAttributeAttributeGetter(info);
1938     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1939 }
1940
1941 static void customSetterLongAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
1942 {
1943     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
1944     V8TestObjectPython::customSetterLongAttributeAttributeSetterCustom(v8Value, info);
1945     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1946 }
1947
1948 #if ENABLE(CONDITION)
1949 static void customLongAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
1950 {
1951     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
1952     V8TestObjectPython::customLongAttributeAttributeGetterCustom(info);
1953     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1954 }
1955 #endif // ENABLE(CONDITION)
1956
1957 #if ENABLE(CONDITION)
1958 static void customLongAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
1959 {
1960     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
1961     V8TestObjectPython::customLongAttributeAttributeSetterCustom(v8Value, info);
1962     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1963 }
1964 #endif // ENABLE(CONDITION)
1965
1966 static void customElementsCallbacksReadonlyLongAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
1967 {
1968     v8::Handle<v8::Object> holder = info.Holder();
1969     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
1970     v8SetReturnValueInt(info, impl->customElementsCallbacksReadonlyLongAttribute());
1971 }
1972
1973 static void customElementsCallbacksReadonlyLongAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
1974 {
1975     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
1976     TestObjectPythonV8Internal::customElementsCallbacksReadonlyLongAttributeAttributeGetter(info);
1977     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1978 }
1979
1980 static void deprecatedLongAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
1981 {
1982     v8::Handle<v8::Object> holder = info.Holder();
1983     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
1984     v8SetReturnValueInt(info, impl->deprecatedLongAttribute());
1985 }
1986
1987 static void deprecatedLongAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
1988 {
1989     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
1990     UseCounter::countDeprecation(callingExecutionContext(info.GetIsolate()), UseCounter::LongAttribute);
1991     TestObjectPythonV8Internal::deprecatedLongAttributeAttributeGetter(info);
1992     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
1993 }
1994
1995 static void deprecatedLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
1996 {
1997     v8::Handle<v8::Object> holder = info.Holder();
1998     ExceptionState exceptionState(ExceptionState::SetterContext, "deprecatedLongAttribute", "TestObjectPython", holder, info.GetIsolate());
1999     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
2000     V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(v8Value, exceptionState), exceptionState);
2001     impl->setDeprecatedLongAttribute(cppValue);
2002 }
2003
2004 static void deprecatedLongAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
2005 {
2006     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
2007     UseCounter::countDeprecation(callingExecutionContext(info.GetIsolate()), UseCounter::LongAttribute);
2008     TestObjectPythonV8Internal::deprecatedLongAttributeAttributeSetter(v8Value, info);
2009     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2010 }
2011
2012 static void enforceRangeLongAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
2013 {
2014     v8::Handle<v8::Object> holder = info.Holder();
2015     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
2016     v8SetReturnValueInt(info, impl->enforceRangeLongAttribute());
2017 }
2018
2019 static void enforceRangeLongAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
2020 {
2021     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
2022     TestObjectPythonV8Internal::enforceRangeLongAttributeAttributeGetter(info);
2023     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2024 }
2025
2026 static void enforceRangeLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
2027 {
2028     v8::Handle<v8::Object> holder = info.Holder();
2029     ExceptionState exceptionState(ExceptionState::SetterContext, "enforceRangeLongAttribute", "TestObjectPython", holder, info.GetIsolate());
2030     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
2031     V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(v8Value, EnforceRange, exceptionState), exceptionState);
2032     impl->setEnforceRangeLongAttribute(cppValue);
2033 }
2034
2035 static void enforceRangeLongAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
2036 {
2037     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
2038     TestObjectPythonV8Internal::enforceRangeLongAttributeAttributeSetter(v8Value, info);
2039     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2040 }
2041
2042 static void exposeJSAccessorsLongAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info)
2043 {
2044     v8::Handle<v8::Object> holder = info.Holder();
2045     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
2046     v8SetReturnValueInt(info, impl->exposeJSAccessorsLongAttribute());
2047 }
2048
2049 static void exposeJSAccessorsLongAttributeAttributeGetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
2050 {
2051     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
2052     TestObjectPythonV8Internal::exposeJSAccessorsLongAttributeAttributeGetter(info);
2053     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2054 }
2055
2056 static void exposeJSAccessorsLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::FunctionCallbackInfo<v8::Value>& info)
2057 {
2058     v8::Handle<v8::Object> holder = info.Holder();
2059     ExceptionState exceptionState(ExceptionState::SetterContext, "exposeJSAccessorsLongAttribute", "TestObjectPython", holder, info.GetIsolate());
2060     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
2061     V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(v8Value, exceptionState), exceptionState);
2062     impl->setExposeJSAccessorsLongAttribute(cppValue);
2063 }
2064
2065 static void exposeJSAccessorsLongAttributeAttributeSetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
2066 {
2067     v8::Local<v8::Value> v8Value = info[0];
2068     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
2069     TestObjectPythonV8Internal::exposeJSAccessorsLongAttributeAttributeSetter(v8Value, info);
2070     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2071 }
2072
2073 static void implementedAsLongAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
2074 {
2075     v8::Handle<v8::Object> holder = info.Holder();
2076     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
2077     v8SetReturnValueInt(info, impl->implementedAsName());
2078 }
2079
2080 static void implementedAsLongAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
2081 {
2082     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
2083     TestObjectPythonV8Internal::implementedAsLongAttributeAttributeGetter(info);
2084     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2085 }
2086
2087 static void implementedAsLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
2088 {
2089     v8::Handle<v8::Object> holder = info.Holder();
2090     ExceptionState exceptionState(ExceptionState::SetterContext, "implementedAsLongAttribute", "TestObjectPython", holder, info.GetIsolate());
2091     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
2092     V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(v8Value, exceptionState), exceptionState);
2093     impl->setImplementedAsName(cppValue);
2094 }
2095
2096 static void implementedAsLongAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
2097 {
2098     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
2099     TestObjectPythonV8Internal::implementedAsLongAttributeAttributeSetter(v8Value, info);
2100     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2101 }
2102
2103 static void customImplementedAsLongAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
2104 {
2105     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
2106     V8TestObjectPython::customImplementedAsLongAttributeAttributeGetterCustom(info);
2107     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2108 }
2109
2110 static void customImplementedAsLongAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
2111 {
2112     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
2113     V8TestObjectPython::customImplementedAsLongAttributeAttributeSetterCustom(v8Value, info);
2114     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2115 }
2116
2117 static void customGetterImplementedAsLongAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
2118 {
2119     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
2120     V8TestObjectPython::customGetterImplementedAsLongAttributeAttributeGetterCustom(info);
2121     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2122 }
2123
2124 static void customGetterImplementedAsLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
2125 {
2126     v8::Handle<v8::Object> holder = info.Holder();
2127     ExceptionState exceptionState(ExceptionState::SetterContext, "customGetterImplementedAsLongAttribute", "TestObjectPython", holder, info.GetIsolate());
2128     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
2129     V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(v8Value, exceptionState), exceptionState);
2130     impl->setImplementedAsNameWithCustomGetter(cppValue);
2131 }
2132
2133 static void customGetterImplementedAsLongAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
2134 {
2135     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
2136     TestObjectPythonV8Internal::customGetterImplementedAsLongAttributeAttributeSetter(v8Value, info);
2137     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2138 }
2139
2140 static void customSetterImplementedAsLongAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
2141 {
2142     v8::Handle<v8::Object> holder = info.Holder();
2143     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
2144     v8SetReturnValueInt(info, impl->implementedAsNameWithCustomGetter());
2145 }
2146
2147 static void customSetterImplementedAsLongAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
2148 {
2149     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
2150     TestObjectPythonV8Internal::customSetterImplementedAsLongAttributeAttributeGetter(info);
2151     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2152 }
2153
2154 static void customSetterImplementedAsLongAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
2155 {
2156     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
2157     V8TestObjectPython::customSetterImplementedAsLongAttributeAttributeSetterCustom(v8Value, info);
2158     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2159 }
2160
2161 static void measureAsLongAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
2162 {
2163     v8::Handle<v8::Object> holder = info.Holder();
2164     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
2165     v8SetReturnValueInt(info, impl->measureAsLongAttribute());
2166 }
2167
2168 static void measureAsLongAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
2169 {
2170     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
2171     UseCounter::count(callingExecutionContext(info.GetIsolate()), UseCounter::TestFeature);
2172     TestObjectPythonV8Internal::measureAsLongAttributeAttributeGetter(info);
2173     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2174 }
2175
2176 static void measureAsLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
2177 {
2178     v8::Handle<v8::Object> holder = info.Holder();
2179     ExceptionState exceptionState(ExceptionState::SetterContext, "measureAsLongAttribute", "TestObjectPython", holder, info.GetIsolate());
2180     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
2181     V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(v8Value, exceptionState), exceptionState);
2182     impl->setMeasureAsLongAttribute(cppValue);
2183 }
2184
2185 static void measureAsLongAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
2186 {
2187     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
2188     UseCounter::count(callingExecutionContext(info.GetIsolate()), UseCounter::TestFeature);
2189     TestObjectPythonV8Internal::measureAsLongAttributeAttributeSetter(v8Value, info);
2190     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2191 }
2192
2193 static void notEnumerableLongAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
2194 {
2195     v8::Handle<v8::Object> holder = info.Holder();
2196     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
2197     v8SetReturnValueInt(info, impl->notEnumerableLongAttribute());
2198 }
2199
2200 static void notEnumerableLongAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
2201 {
2202     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
2203     TestObjectPythonV8Internal::notEnumerableLongAttributeAttributeGetter(info);
2204     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2205 }
2206
2207 static void notEnumerableLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
2208 {
2209     v8::Handle<v8::Object> holder = info.Holder();
2210     ExceptionState exceptionState(ExceptionState::SetterContext, "notEnumerableLongAttribute", "TestObjectPython", holder, info.GetIsolate());
2211     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
2212     V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(v8Value, exceptionState), exceptionState);
2213     impl->setNotEnumerableLongAttribute(cppValue);
2214 }
2215
2216 static void notEnumerableLongAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
2217 {
2218     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
2219     TestObjectPythonV8Internal::notEnumerableLongAttributeAttributeSetter(v8Value, info);
2220     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2221 }
2222
2223 static void perContextEnabledLongAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
2224 {
2225     v8::Handle<v8::Object> holder = info.Holder();
2226     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
2227     v8SetReturnValueInt(info, impl->perContextEnabledLongAttribute());
2228 }
2229
2230 static void perContextEnabledLongAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
2231 {
2232     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
2233     TestObjectPythonV8Internal::perContextEnabledLongAttributeAttributeGetter(info);
2234     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2235 }
2236
2237 static void perContextEnabledLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
2238 {
2239     v8::Handle<v8::Object> holder = info.Holder();
2240     ExceptionState exceptionState(ExceptionState::SetterContext, "perContextEnabledLongAttribute", "TestObjectPython", holder, info.GetIsolate());
2241     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
2242     V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(v8Value, exceptionState), exceptionState);
2243     impl->setPerContextEnabledLongAttribute(cppValue);
2244 }
2245
2246 static void perContextEnabledLongAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
2247 {
2248     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
2249     TestObjectPythonV8Internal::perContextEnabledLongAttributeAttributeSetter(v8Value, info);
2250     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2251 }
2252
2253 static void perWorldBindingsLongAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
2254 {
2255     v8::Handle<v8::Object> holder = info.Holder();
2256     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
2257     v8SetReturnValueInt(info, impl->perWorldBindingsLongAttribute());
2258 }
2259
2260 static void perWorldBindingsLongAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
2261 {
2262     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
2263     TestObjectPythonV8Internal::perWorldBindingsLongAttributeAttributeGetter(info);
2264     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2265 }
2266
2267 static void perWorldBindingsLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
2268 {
2269     v8::Handle<v8::Object> holder = info.Holder();
2270     ExceptionState exceptionState(ExceptionState::SetterContext, "perWorldBindingsLongAttribute", "TestObjectPython", holder, info.GetIsolate());
2271     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
2272     V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(v8Value, exceptionState), exceptionState);
2273     impl->setPerWorldBindingsLongAttribute(cppValue);
2274 }
2275
2276 static void perWorldBindingsLongAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
2277 {
2278     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
2279     TestObjectPythonV8Internal::perWorldBindingsLongAttributeAttributeSetter(v8Value, info);
2280     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2281 }
2282
2283 static void perWorldBindingsLongAttributeAttributeGetterForMainWorld(const v8::PropertyCallbackInfo<v8::Value>& info)
2284 {
2285     v8::Handle<v8::Object> holder = info.Holder();
2286     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
2287     v8SetReturnValueInt(info, impl->perWorldBindingsLongAttribute());
2288 }
2289
2290 static void perWorldBindingsLongAttributeAttributeGetterCallbackForMainWorld(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
2291 {
2292     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
2293     TestObjectPythonV8Internal::perWorldBindingsLongAttributeAttributeGetterForMainWorld(info);
2294     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2295 }
2296
2297 static void perWorldBindingsLongAttributeAttributeSetterForMainWorld(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
2298 {
2299     v8::Handle<v8::Object> holder = info.Holder();
2300     ExceptionState exceptionState(ExceptionState::SetterContext, "perWorldBindingsLongAttribute", "TestObjectPython", holder, info.GetIsolate());
2301     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
2302     V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(v8Value, exceptionState), exceptionState);
2303     impl->setPerWorldBindingsLongAttribute(cppValue);
2304 }
2305
2306 static void perWorldBindingsLongAttributeAttributeSetterCallbackForMainWorld(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
2307 {
2308     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
2309     TestObjectPythonV8Internal::perWorldBindingsLongAttributeAttributeSetterForMainWorld(v8Value, info);
2310     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2311 }
2312
2313 static void perWorldBindingsReadonlyLongAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
2314 {
2315     v8::Handle<v8::Object> holder = info.Holder();
2316     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
2317     v8SetReturnValueInt(info, impl->perWorldBindingsReadonlyLongAttribute());
2318 }
2319
2320 static void perWorldBindingsReadonlyLongAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
2321 {
2322     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
2323     TestObjectPythonV8Internal::perWorldBindingsReadonlyLongAttributeAttributeGetter(info);
2324     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2325 }
2326
2327 static void perWorldBindingsReadonlyLongAttributeAttributeGetterForMainWorld(const v8::PropertyCallbackInfo<v8::Value>& info)
2328 {
2329     v8::Handle<v8::Object> holder = info.Holder();
2330     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
2331     v8SetReturnValueInt(info, impl->perWorldBindingsReadonlyLongAttribute());
2332 }
2333
2334 static void perWorldBindingsReadonlyLongAttributeAttributeGetterCallbackForMainWorld(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
2335 {
2336     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
2337     TestObjectPythonV8Internal::perWorldBindingsReadonlyLongAttributeAttributeGetterForMainWorld(info);
2338     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2339 }
2340
2341 static void perWorldBindingsReadonlyTestInterfaceEmptyAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
2342 {
2343     v8::Handle<v8::Object> holder = info.Holder();
2344     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
2345     RefPtr<TestInterfaceEmpty> result(impl->perWorldBindingsReadonlyTestInterfaceEmptyAttribute());
2346     if (result && DOMDataStore::setReturnValueFromWrapper<V8TestInterfaceEmpty>(info.GetReturnValue(), result.get()))
2347         return;
2348     v8::Handle<v8::Value> wrapper = toV8(result.get(), holder, info.GetIsolate());
2349     if (!wrapper.IsEmpty()) {
2350         V8HiddenValue::setHiddenValue(info.GetIsolate(), holder, v8AtomicString(info.GetIsolate(), "perWorldBindingsReadonlyTestInterfaceEmptyAttribute"), wrapper);
2351         v8SetReturnValue(info, wrapper);
2352     }
2353 }
2354
2355 static void perWorldBindingsReadonlyTestInterfaceEmptyAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
2356 {
2357     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
2358     TestObjectPythonV8Internal::perWorldBindingsReadonlyTestInterfaceEmptyAttributeAttributeGetter(info);
2359     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2360 }
2361
2362 static void perWorldBindingsReadonlyTestInterfaceEmptyAttributeAttributeGetterForMainWorld(const v8::PropertyCallbackInfo<v8::Value>& info)
2363 {
2364     v8::Handle<v8::Object> holder = info.Holder();
2365     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
2366     RefPtr<TestInterfaceEmpty> result(impl->perWorldBindingsReadonlyTestInterfaceEmptyAttribute());
2367     if (result && DOMDataStore::setReturnValueFromWrapperForMainWorld<V8TestInterfaceEmpty>(info.GetReturnValue(), result.get()))
2368         return;
2369     v8::Handle<v8::Value> wrapper = toV8(result.get(), holder, info.GetIsolate());
2370     if (!wrapper.IsEmpty()) {
2371         V8HiddenValue::setHiddenValue(info.GetIsolate(), holder, v8AtomicString(info.GetIsolate(), "perWorldBindingsReadonlyTestInterfaceEmptyAttribute"), wrapper);
2372         v8SetReturnValue(info, wrapper);
2373     }
2374 }
2375
2376 static void perWorldBindingsReadonlyTestInterfaceEmptyAttributeAttributeGetterCallbackForMainWorld(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
2377 {
2378     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
2379     TestObjectPythonV8Internal::perWorldBindingsReadonlyTestInterfaceEmptyAttributeAttributeGetterForMainWorld(info);
2380     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2381 }
2382
2383 static void activityLoggingAccessPerWorldBindingsLongAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
2384 {
2385     v8::Handle<v8::Object> holder = info.Holder();
2386     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
2387     v8SetReturnValueInt(info, impl->activityLoggingAccessPerWorldBindingsLongAttribute());
2388 }
2389
2390 static void activityLoggingAccessPerWorldBindingsLongAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
2391 {
2392     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
2393     V8PerContextData* contextData = V8PerContextData::from(info.GetIsolate()->GetCurrentContext());
2394     if (contextData && contextData->activityLogger())
2395         contextData->activityLogger()->log("TestObjectPython.activityLoggingAccessPerWorldBindingsLongAttribute", 0, 0, "Getter");
2396     TestObjectPythonV8Internal::activityLoggingAccessPerWorldBindingsLongAttributeAttributeGetter(info);
2397     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2398 }
2399
2400 static void activityLoggingAccessPerWorldBindingsLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
2401 {
2402     v8::Handle<v8::Object> holder = info.Holder();
2403     ExceptionState exceptionState(ExceptionState::SetterContext, "activityLoggingAccessPerWorldBindingsLongAttribute", "TestObjectPython", holder, info.GetIsolate());
2404     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
2405     V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(v8Value, exceptionState), exceptionState);
2406     impl->setActivityLoggingAccessPerWorldBindingsLongAttribute(cppValue);
2407 }
2408
2409 static void activityLoggingAccessPerWorldBindingsLongAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
2410 {
2411     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
2412     V8PerContextData* contextData = V8PerContextData::from(info.GetIsolate()->GetCurrentContext());
2413     if (contextData && contextData->activityLogger()) {
2414         v8::Handle<v8::Value> loggerArg[] = { v8Value };
2415         contextData->activityLogger()->log("TestObjectPython.activityLoggingAccessPerWorldBindingsLongAttribute", 1, &loggerArg[0], "Setter");
2416     }
2417     TestObjectPythonV8Internal::activityLoggingAccessPerWorldBindingsLongAttributeAttributeSetter(v8Value, info);
2418     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2419 }
2420
2421 static void activityLoggingAccessPerWorldBindingsLongAttributeAttributeGetterForMainWorld(const v8::PropertyCallbackInfo<v8::Value>& info)
2422 {
2423     v8::Handle<v8::Object> holder = info.Holder();
2424     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
2425     v8SetReturnValueInt(info, impl->activityLoggingAccessPerWorldBindingsLongAttribute());
2426 }
2427
2428 static void activityLoggingAccessPerWorldBindingsLongAttributeAttributeGetterCallbackForMainWorld(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
2429 {
2430     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
2431     V8PerContextData* contextData = V8PerContextData::from(info.GetIsolate()->GetCurrentContext());
2432     if (contextData && contextData->activityLogger())
2433         contextData->activityLogger()->log("TestObjectPython.activityLoggingAccessPerWorldBindingsLongAttribute", 0, 0, "Getter");
2434     TestObjectPythonV8Internal::activityLoggingAccessPerWorldBindingsLongAttributeAttributeGetterForMainWorld(info);
2435     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2436 }
2437
2438 static void activityLoggingAccessPerWorldBindingsLongAttributeAttributeSetterForMainWorld(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
2439 {
2440     v8::Handle<v8::Object> holder = info.Holder();
2441     ExceptionState exceptionState(ExceptionState::SetterContext, "activityLoggingAccessPerWorldBindingsLongAttribute", "TestObjectPython", holder, info.GetIsolate());
2442     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
2443     V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(v8Value, exceptionState), exceptionState);
2444     impl->setActivityLoggingAccessPerWorldBindingsLongAttribute(cppValue);
2445 }
2446
2447 static void activityLoggingAccessPerWorldBindingsLongAttributeAttributeSetterCallbackForMainWorld(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
2448 {
2449     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
2450     V8PerContextData* contextData = V8PerContextData::from(info.GetIsolate()->GetCurrentContext());
2451     if (contextData && contextData->activityLogger()) {
2452         v8::Handle<v8::Value> loggerArg[] = { v8Value };
2453         contextData->activityLogger()->log("TestObjectPython.activityLoggingAccessPerWorldBindingsLongAttribute", 1, &loggerArg[0], "Setter");
2454     }
2455     TestObjectPythonV8Internal::activityLoggingAccessPerWorldBindingsLongAttributeAttributeSetterForMainWorld(v8Value, info);
2456     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2457 }
2458
2459 static void activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
2460 {
2461     v8::Handle<v8::Object> holder = info.Holder();
2462     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
2463     v8SetReturnValueInt(info, impl->activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttribute());
2464 }
2465
2466 static void activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
2467 {
2468     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
2469     V8PerContextData* contextData = V8PerContextData::from(info.GetIsolate()->GetCurrentContext());
2470     if (contextData && contextData->activityLogger())
2471         contextData->activityLogger()->log("TestObjectPython.activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttribute", 0, 0, "Getter");
2472     TestObjectPythonV8Internal::activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttributeAttributeGetter(info);
2473     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2474 }
2475
2476 static void activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
2477 {
2478     v8::Handle<v8::Object> holder = info.Holder();
2479     ExceptionState exceptionState(ExceptionState::SetterContext, "activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttribute", "TestObjectPython", holder, info.GetIsolate());
2480     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
2481     V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(v8Value, exceptionState), exceptionState);
2482     impl->setActivityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttribute(cppValue);
2483 }
2484
2485 static void activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
2486 {
2487     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
2488     V8PerContextData* contextData = V8PerContextData::from(info.GetIsolate()->GetCurrentContext());
2489     if (contextData && contextData->activityLogger()) {
2490         v8::Handle<v8::Value> loggerArg[] = { v8Value };
2491         contextData->activityLogger()->log("TestObjectPython.activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttribute", 1, &loggerArg[0], "Setter");
2492     }
2493     TestObjectPythonV8Internal::activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttributeAttributeSetter(v8Value, info);
2494     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2495 }
2496
2497 static void activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttributeAttributeGetterForMainWorld(const v8::PropertyCallbackInfo<v8::Value>& info)
2498 {
2499     v8::Handle<v8::Object> holder = info.Holder();
2500     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
2501     v8SetReturnValueInt(info, impl->activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttribute());
2502 }
2503
2504 static void activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttributeAttributeGetterCallbackForMainWorld(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
2505 {
2506     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
2507     TestObjectPythonV8Internal::activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttributeAttributeGetterForMainWorld(info);
2508     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2509 }
2510
2511 static void activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttributeAttributeSetterForMainWorld(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
2512 {
2513     v8::Handle<v8::Object> holder = info.Holder();
2514     ExceptionState exceptionState(ExceptionState::SetterContext, "activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttribute", "TestObjectPython", holder, info.GetIsolate());
2515     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
2516     V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(v8Value, exceptionState), exceptionState);
2517     impl->setActivityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttribute(cppValue);
2518 }
2519
2520 static void activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttributeAttributeSetterCallbackForMainWorld(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
2521 {
2522     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
2523     TestObjectPythonV8Internal::activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttributeAttributeSetterForMainWorld(v8Value, info);
2524     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2525 }
2526
2527 static void activityLoggingGetterPerWorldBindingsLongAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
2528 {
2529     v8::Handle<v8::Object> holder = info.Holder();
2530     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
2531     v8SetReturnValueInt(info, impl->activityLoggingGetterPerWorldBindingsLongAttribute());
2532 }
2533
2534 static void activityLoggingGetterPerWorldBindingsLongAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
2535 {
2536     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
2537     V8PerContextData* contextData = V8PerContextData::from(info.GetIsolate()->GetCurrentContext());
2538     if (contextData && contextData->activityLogger())
2539         contextData->activityLogger()->log("TestObjectPython.activityLoggingGetterPerWorldBindingsLongAttribute", 0, 0, "Getter");
2540     TestObjectPythonV8Internal::activityLoggingGetterPerWorldBindingsLongAttributeAttributeGetter(info);
2541     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2542 }
2543
2544 static void activityLoggingGetterPerWorldBindingsLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
2545 {
2546     v8::Handle<v8::Object> holder = info.Holder();
2547     ExceptionState exceptionState(ExceptionState::SetterContext, "activityLoggingGetterPerWorldBindingsLongAttribute", "TestObjectPython", holder, info.GetIsolate());
2548     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
2549     V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(v8Value, exceptionState), exceptionState);
2550     impl->setActivityLoggingGetterPerWorldBindingsLongAttribute(cppValue);
2551 }
2552
2553 static void activityLoggingGetterPerWorldBindingsLongAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
2554 {
2555     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
2556     TestObjectPythonV8Internal::activityLoggingGetterPerWorldBindingsLongAttributeAttributeSetter(v8Value, info);
2557     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2558 }
2559
2560 static void activityLoggingGetterPerWorldBindingsLongAttributeAttributeGetterForMainWorld(const v8::PropertyCallbackInfo<v8::Value>& info)
2561 {
2562     v8::Handle<v8::Object> holder = info.Holder();
2563     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
2564     v8SetReturnValueInt(info, impl->activityLoggingGetterPerWorldBindingsLongAttribute());
2565 }
2566
2567 static void activityLoggingGetterPerWorldBindingsLongAttributeAttributeGetterCallbackForMainWorld(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
2568 {
2569     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
2570     V8PerContextData* contextData = V8PerContextData::from(info.GetIsolate()->GetCurrentContext());
2571     if (contextData && contextData->activityLogger())
2572         contextData->activityLogger()->log("TestObjectPython.activityLoggingGetterPerWorldBindingsLongAttribute", 0, 0, "Getter");
2573     TestObjectPythonV8Internal::activityLoggingGetterPerWorldBindingsLongAttributeAttributeGetterForMainWorld(info);
2574     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2575 }
2576
2577 static void activityLoggingGetterPerWorldBindingsLongAttributeAttributeSetterForMainWorld(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
2578 {
2579     v8::Handle<v8::Object> holder = info.Holder();
2580     ExceptionState exceptionState(ExceptionState::SetterContext, "activityLoggingGetterPerWorldBindingsLongAttribute", "TestObjectPython", holder, info.GetIsolate());
2581     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
2582     V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(v8Value, exceptionState), exceptionState);
2583     impl->setActivityLoggingGetterPerWorldBindingsLongAttribute(cppValue);
2584 }
2585
2586 static void activityLoggingGetterPerWorldBindingsLongAttributeAttributeSetterCallbackForMainWorld(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
2587 {
2588     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
2589     TestObjectPythonV8Internal::activityLoggingGetterPerWorldBindingsLongAttributeAttributeSetterForMainWorld(v8Value, info);
2590     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2591 }
2592
2593 static void activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
2594 {
2595     v8::Handle<v8::Object> holder = info.Holder();
2596     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
2597     v8SetReturnValueInt(info, impl->activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttribute());
2598 }
2599
2600 static void activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
2601 {
2602     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
2603     V8PerContextData* contextData = V8PerContextData::from(info.GetIsolate()->GetCurrentContext());
2604     if (contextData && contextData->activityLogger())
2605         contextData->activityLogger()->log("TestObjectPython.activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttribute", 0, 0, "Getter");
2606     TestObjectPythonV8Internal::activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttributeAttributeGetter(info);
2607     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2608 }
2609
2610 static void activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
2611 {
2612     v8::Handle<v8::Object> holder = info.Holder();
2613     ExceptionState exceptionState(ExceptionState::SetterContext, "activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttribute", "TestObjectPython", holder, info.GetIsolate());
2614     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
2615     V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(v8Value, exceptionState), exceptionState);
2616     impl->setActivityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttribute(cppValue);
2617 }
2618
2619 static void activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
2620 {
2621     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
2622     TestObjectPythonV8Internal::activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttributeAttributeSetter(v8Value, info);
2623     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2624 }
2625
2626 static void activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttributeAttributeGetterForMainWorld(const v8::PropertyCallbackInfo<v8::Value>& info)
2627 {
2628     v8::Handle<v8::Object> holder = info.Holder();
2629     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
2630     v8SetReturnValueInt(info, impl->activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttribute());
2631 }
2632
2633 static void activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttributeAttributeGetterCallbackForMainWorld(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
2634 {
2635     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
2636     TestObjectPythonV8Internal::activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttributeAttributeGetterForMainWorld(info);
2637     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2638 }
2639
2640 static void activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttributeAttributeSetterForMainWorld(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
2641 {
2642     v8::Handle<v8::Object> holder = info.Holder();
2643     ExceptionState exceptionState(ExceptionState::SetterContext, "activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttribute", "TestObjectPython", holder, info.GetIsolate());
2644     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
2645     V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(v8Value, exceptionState), exceptionState);
2646     impl->setActivityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttribute(cppValue);
2647 }
2648
2649 static void activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttributeAttributeSetterCallbackForMainWorld(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
2650 {
2651     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
2652     TestObjectPythonV8Internal::activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttributeAttributeSetterForMainWorld(v8Value, info);
2653     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2654 }
2655
2656 static void locationAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
2657 {
2658     v8::Handle<v8::Object> holder = info.Holder();
2659     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
2660     v8SetReturnValueFast(info, WTF::getPtr(impl->location()), impl);
2661 }
2662
2663 static void locationAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
2664 {
2665     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
2666     TestObjectPythonV8Internal::locationAttributeGetter(info);
2667     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2668 }
2669
2670 static void locationAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
2671 {
2672     v8::Handle<v8::Object> holder = info.Holder();
2673     TestObjectPython* proxyImpl = V8TestObjectPython::toNative(holder);
2674     RefPtr<TestNode> impl = WTF::getPtr(proxyImpl->location());
2675     if (!impl)
2676         return;
2677     V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, cppValue, v8Value);
2678     impl->setHref(cppValue);
2679 }
2680
2681 static void locationAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
2682 {
2683     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
2684     TestObjectPythonV8Internal::locationAttributeSetter(v8Value, info);
2685     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2686 }
2687
2688 static void locationWithExceptionAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
2689 {
2690     v8::Handle<v8::Object> holder = info.Holder();
2691     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
2692     v8SetReturnValueFast(info, WTF::getPtr(impl->locationWithException()), impl);
2693 }
2694
2695 static void locationWithExceptionAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
2696 {
2697     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
2698     TestObjectPythonV8Internal::locationWithExceptionAttributeGetter(info);
2699     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2700 }
2701
2702 static void locationWithExceptionAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
2703 {
2704     v8::Handle<v8::Object> holder = info.Holder();
2705     TestObjectPython* proxyImpl = V8TestObjectPython::toNative(holder);
2706     RefPtr<TestNode> impl = WTF::getPtr(proxyImpl->locationWithException());
2707     if (!impl)
2708         return;
2709     V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, cppValue, v8Value);
2710     impl->setHrefThrows(cppValue);
2711 }
2712
2713 static void locationWithExceptionAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
2714 {
2715     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
2716     TestObjectPythonV8Internal::locationWithExceptionAttributeSetter(v8Value, info);
2717     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2718 }
2719
2720 static void locationWithCallWithAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
2721 {
2722     v8::Handle<v8::Object> holder = info.Holder();
2723     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
2724     v8SetReturnValueFast(info, WTF::getPtr(impl->locationWithCallWith()), impl);
2725 }
2726
2727 static void locationWithCallWithAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
2728 {
2729     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
2730     TestObjectPythonV8Internal::locationWithCallWithAttributeGetter(info);
2731     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2732 }
2733
2734 static void locationWithCallWithAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
2735 {
2736     v8::Handle<v8::Object> holder = info.Holder();
2737     TestObjectPython* proxyImpl = V8TestObjectPython::toNative(holder);
2738     RefPtr<TestNode> impl = WTF::getPtr(proxyImpl->locationWithCallWith());
2739     if (!impl)
2740         return;
2741     V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, cppValue, v8Value);
2742     impl->setHrefCallWith(callingDOMWindow(info.GetIsolate()), enteredDOMWindow(info.GetIsolate()), cppValue);
2743 }
2744
2745 static void locationWithCallWithAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
2746 {
2747     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
2748     TestObjectPythonV8Internal::locationWithCallWithAttributeSetter(v8Value, info);
2749     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2750 }
2751
2752 static void locationWithPerWorldBindingsAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
2753 {
2754     v8::Handle<v8::Object> holder = info.Holder();
2755     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
2756     v8SetReturnValueFast(info, WTF::getPtr(impl->locationWithPerWorldBindings()), impl);
2757 }
2758
2759 static void locationWithPerWorldBindingsAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
2760 {
2761     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
2762     TestObjectPythonV8Internal::locationWithPerWorldBindingsAttributeGetter(info);
2763     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2764 }
2765
2766 static void locationWithPerWorldBindingsAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
2767 {
2768     v8::Handle<v8::Object> holder = info.Holder();
2769     TestObjectPython* proxyImpl = V8TestObjectPython::toNative(holder);
2770     RefPtr<TestNode> impl = WTF::getPtr(proxyImpl->locationWithPerWorldBindings());
2771     if (!impl)
2772         return;
2773     V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, cppValue, v8Value);
2774     impl->setHref(cppValue);
2775 }
2776
2777 static void locationWithPerWorldBindingsAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
2778 {
2779     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
2780     TestObjectPythonV8Internal::locationWithPerWorldBindingsAttributeSetter(v8Value, info);
2781     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2782 }
2783
2784 static void locationWithPerWorldBindingsAttributeGetterForMainWorld(const v8::PropertyCallbackInfo<v8::Value>& info)
2785 {
2786     v8::Handle<v8::Object> holder = info.Holder();
2787     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
2788     v8SetReturnValueForMainWorld(info, WTF::getPtr(impl->locationWithPerWorldBindings()));
2789 }
2790
2791 static void locationWithPerWorldBindingsAttributeGetterCallbackForMainWorld(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
2792 {
2793     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
2794     TestObjectPythonV8Internal::locationWithPerWorldBindingsAttributeGetterForMainWorld(info);
2795     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2796 }
2797
2798 static void locationWithPerWorldBindingsAttributeSetterForMainWorld(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
2799 {
2800     v8::Handle<v8::Object> holder = info.Holder();
2801     TestObjectPython* proxyImpl = V8TestObjectPython::toNative(holder);
2802     RefPtr<TestNode> impl = WTF::getPtr(proxyImpl->locationWithPerWorldBindings());
2803     if (!impl)
2804         return;
2805     V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, cppValue, v8Value);
2806     impl->setHref(cppValue);
2807 }
2808
2809 static void locationWithPerWorldBindingsAttributeSetterCallbackForMainWorld(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
2810 {
2811     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
2812     TestObjectPythonV8Internal::locationWithPerWorldBindingsAttributeSetterForMainWorld(v8Value, info);
2813     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2814 }
2815
2816 static void locationWillBeGarbageCollectedAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
2817 {
2818     v8::Handle<v8::Object> holder = info.Holder();
2819     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
2820     RefPtrWillBeRawPtr<TestInterfaceWillBeGarbageCollected> result(impl->locationWillBeGarbageCollected());
2821     if (result && DOMDataStore::setReturnValueFromWrapper<V8TestInterfaceWillBeGarbageCollected>(info.GetReturnValue(), result.get()))
2822         return;
2823     v8::Handle<v8::Value> wrapper = toV8(result.get(), holder, info.GetIsolate());
2824     if (!wrapper.IsEmpty()) {
2825         V8HiddenValue::setHiddenValue(info.GetIsolate(), holder, v8AtomicString(info.GetIsolate(), "locationWillBeGarbageCollected"), wrapper);
2826         v8SetReturnValue(info, wrapper);
2827     }
2828 }
2829
2830 static void locationWillBeGarbageCollectedAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
2831 {
2832     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
2833     TestObjectPythonV8Internal::locationWillBeGarbageCollectedAttributeGetter(info);
2834     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2835 }
2836
2837 static void locationWillBeGarbageCollectedAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
2838 {
2839     v8::Handle<v8::Object> holder = info.Holder();
2840     TestObjectPython* proxyImpl = V8TestObjectPython::toNative(holder);
2841     RefPtrWillBeRawPtr<TestInterfaceWillBeGarbageCollected> impl = WTF::getPtr(proxyImpl->locationWillBeGarbageCollected());
2842     if (!impl)
2843         return;
2844     V8TRYCATCH_VOID(TestInterfaceWillBeGarbageCollected*, cppValue, V8TestInterfaceWillBeGarbageCollected::toNativeWithTypeCheck(info.GetIsolate(), v8Value));
2845     impl->setAttr1(WTF::getPtr(cppValue));
2846 }
2847
2848 static void locationWillBeGarbageCollectedAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
2849 {
2850     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
2851     TestObjectPythonV8Internal::locationWillBeGarbageCollectedAttributeSetter(v8Value, info);
2852     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2853 }
2854
2855 static void raisesExceptionLongAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
2856 {
2857     v8::Handle<v8::Object> holder = info.Holder();
2858     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
2859     ExceptionState exceptionState(ExceptionState::GetterContext, "raisesExceptionLongAttribute", "TestObjectPython", holder, info.GetIsolate());
2860     int v8Value = impl->raisesExceptionLongAttribute(exceptionState);
2861     if (UNLIKELY(exceptionState.throwIfNeeded()))
2862         return;
2863     v8SetReturnValueInt(info, v8Value);
2864 }
2865
2866 static void raisesExceptionLongAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
2867 {
2868     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
2869     TestObjectPythonV8Internal::raisesExceptionLongAttributeAttributeGetter(info);
2870     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2871 }
2872
2873 static void raisesExceptionLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
2874 {
2875     v8::Handle<v8::Object> holder = info.Holder();
2876     ExceptionState exceptionState(ExceptionState::SetterContext, "raisesExceptionLongAttribute", "TestObjectPython", holder, info.GetIsolate());
2877     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
2878     V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(v8Value, exceptionState), exceptionState);
2879     impl->setRaisesExceptionLongAttribute(cppValue, exceptionState);
2880     exceptionState.throwIfNeeded();
2881 }
2882
2883 static void raisesExceptionLongAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
2884 {
2885     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
2886     TestObjectPythonV8Internal::raisesExceptionLongAttributeAttributeSetter(v8Value, info);
2887     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2888 }
2889
2890 static void raisesExceptionGetterLongAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
2891 {
2892     v8::Handle<v8::Object> holder = info.Holder();
2893     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
2894     ExceptionState exceptionState(ExceptionState::GetterContext, "raisesExceptionGetterLongAttribute", "TestObjectPython", holder, info.GetIsolate());
2895     int v8Value = impl->raisesExceptionGetterLongAttribute(exceptionState);
2896     if (UNLIKELY(exceptionState.throwIfNeeded()))
2897         return;
2898     v8SetReturnValueInt(info, v8Value);
2899 }
2900
2901 static void raisesExceptionGetterLongAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
2902 {
2903     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
2904     TestObjectPythonV8Internal::raisesExceptionGetterLongAttributeAttributeGetter(info);
2905     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2906 }
2907
2908 static void raisesExceptionGetterLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
2909 {
2910     v8::Handle<v8::Object> holder = info.Holder();
2911     ExceptionState exceptionState(ExceptionState::SetterContext, "raisesExceptionGetterLongAttribute", "TestObjectPython", holder, info.GetIsolate());
2912     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
2913     V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(v8Value, exceptionState), exceptionState);
2914     impl->setRaisesExceptionGetterLongAttribute(cppValue);
2915 }
2916
2917 static void raisesExceptionGetterLongAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
2918 {
2919     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
2920     TestObjectPythonV8Internal::raisesExceptionGetterLongAttributeAttributeSetter(v8Value, info);
2921     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2922 }
2923
2924 static void setterRaisesExceptionLongAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
2925 {
2926     v8::Handle<v8::Object> holder = info.Holder();
2927     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
2928     v8SetReturnValueInt(info, impl->setterRaisesExceptionLongAttribute());
2929 }
2930
2931 static void setterRaisesExceptionLongAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
2932 {
2933     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
2934     TestObjectPythonV8Internal::setterRaisesExceptionLongAttributeAttributeGetter(info);
2935     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2936 }
2937
2938 static void setterRaisesExceptionLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
2939 {
2940     v8::Handle<v8::Object> holder = info.Holder();
2941     ExceptionState exceptionState(ExceptionState::SetterContext, "setterRaisesExceptionLongAttribute", "TestObjectPython", holder, info.GetIsolate());
2942     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
2943     V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(v8Value, exceptionState), exceptionState);
2944     impl->setSetterRaisesExceptionLongAttribute(cppValue, exceptionState);
2945     exceptionState.throwIfNeeded();
2946 }
2947
2948 static void setterRaisesExceptionLongAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
2949 {
2950     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
2951     TestObjectPythonV8Internal::setterRaisesExceptionLongAttributeAttributeSetter(v8Value, info);
2952     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2953 }
2954
2955 static void raisesExceptionTestInterfaceEmptyAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
2956 {
2957     v8::Handle<v8::Object> holder = info.Holder();
2958     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
2959     ExceptionState exceptionState(ExceptionState::GetterContext, "raisesExceptionTestInterfaceEmptyAttribute", "TestObjectPython", holder, info.GetIsolate());
2960     RefPtr<TestInterfaceEmpty> v8Value = impl->raisesExceptionTestInterfaceEmptyAttribute(exceptionState);
2961     if (UNLIKELY(exceptionState.throwIfNeeded()))
2962         return;
2963     v8SetReturnValueFast(info, WTF::getPtr(v8Value.release()), impl);
2964 }
2965
2966 static void raisesExceptionTestInterfaceEmptyAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
2967 {
2968     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
2969     TestObjectPythonV8Internal::raisesExceptionTestInterfaceEmptyAttributeAttributeGetter(info);
2970     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2971 }
2972
2973 static void raisesExceptionTestInterfaceEmptyAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
2974 {
2975     v8::Handle<v8::Object> holder = info.Holder();
2976     ExceptionState exceptionState(ExceptionState::SetterContext, "raisesExceptionTestInterfaceEmptyAttribute", "TestObjectPython", holder, info.GetIsolate());
2977     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
2978     V8TRYCATCH_VOID(TestInterfaceEmpty*, cppValue, V8TestInterfaceEmpty::toNativeWithTypeCheck(info.GetIsolate(), v8Value));
2979     impl->setRaisesExceptionTestInterfaceEmptyAttribute(WTF::getPtr(cppValue), exceptionState);
2980     exceptionState.throwIfNeeded();
2981 }
2982
2983 static void raisesExceptionTestInterfaceEmptyAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
2984 {
2985     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
2986     TestObjectPythonV8Internal::raisesExceptionTestInterfaceEmptyAttributeAttributeSetter(v8Value, info);
2987     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
2988 }
2989
2990 static void cachedAttributeRaisesExceptionGetterAnyAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
2991 {
2992     v8::Handle<v8::Object> holder = info.Holder();
2993     v8::Handle<v8::String> propertyName = v8AtomicString(info.GetIsolate(), "cachedAttributeRaisesExceptionGetterAnyAttribute");
2994     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
2995     if (!impl->isValueDirty()) {
2996         v8::Handle<v8::Value> v8Value = V8HiddenValue::getHiddenValue(info.GetIsolate(), holder, propertyName);
2997         if (!v8Value.IsEmpty()) {
2998             v8SetReturnValue(info, v8Value);
2999             return;
3000         }
3001     }
3002     ExceptionState exceptionState(ExceptionState::GetterContext, "cachedAttributeRaisesExceptionGetterAnyAttribute", "TestObjectPython", holder, info.GetIsolate());
3003     ScriptValue v8Value = impl->cachedAttributeRaisesExceptionGetterAnyAttribute(exceptionState);
3004     if (UNLIKELY(exceptionState.throwIfNeeded()))
3005         return;
3006     V8HiddenValue::setHiddenValue(info.GetIsolate(), holder, propertyName, v8Value.v8Value());
3007     v8SetReturnValue(info, v8Value.v8Value());
3008 }
3009
3010 static void cachedAttributeRaisesExceptionGetterAnyAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
3011 {
3012     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
3013     TestObjectPythonV8Internal::cachedAttributeRaisesExceptionGetterAnyAttributeAttributeGetter(info);
3014     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3015 }
3016
3017 static void cachedAttributeRaisesExceptionGetterAnyAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
3018 {
3019     v8::Handle<v8::Object> holder = info.Holder();
3020     ExceptionState exceptionState(ExceptionState::SetterContext, "cachedAttributeRaisesExceptionGetterAnyAttribute", "TestObjectPython", holder, info.GetIsolate());
3021     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3022     V8TRYCATCH_VOID(ScriptValue, cppValue, ScriptValue(v8Value, info.GetIsolate()));
3023     impl->setCachedAttributeRaisesExceptionGetterAnyAttribute(cppValue, exceptionState);
3024     exceptionState.throwIfNeeded();
3025     V8HiddenValue::deleteHiddenValue(info.GetIsolate(), holder, v8AtomicString(info.GetIsolate(), "cachedAttributeRaisesExceptionGetterAnyAttribute")); // Invalidate the cached value.
3026 }
3027
3028 static void cachedAttributeRaisesExceptionGetterAnyAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
3029 {
3030     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
3031     TestObjectPythonV8Internal::cachedAttributeRaisesExceptionGetterAnyAttributeAttributeSetter(v8Value, info);
3032     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3033 }
3034
3035 static void reflectTestInterfaceAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
3036 {
3037     v8::Handle<v8::Object> holder = info.Holder();
3038     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3039     v8SetReturnValueFast(info, WTF::getPtr(impl->fastGetAttribute(HTMLNames::reflecttestinterfaceattributeAttr)), impl);
3040 }
3041
3042 static void reflectTestInterfaceAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
3043 {
3044     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
3045     TestObjectPythonV8Internal::reflectTestInterfaceAttributeAttributeGetter(info);
3046     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3047 }
3048
3049 static void reflectTestInterfaceAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
3050 {
3051     v8::Handle<v8::Object> holder = info.Holder();
3052     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3053     V8TRYCATCH_VOID(TestInterface*, cppValue, V8TestInterface::toNativeWithTypeCheck(info.GetIsolate(), v8Value));
3054     CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope;
3055     impl->setAttribute(HTMLNames::reflecttestinterfaceattributeAttr, WTF::getPtr(cppValue));
3056 }
3057
3058 static void reflectTestInterfaceAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
3059 {
3060     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
3061     CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope;
3062     TestObjectPythonV8Internal::reflectTestInterfaceAttributeAttributeSetter(v8Value, info);
3063     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3064 }
3065
3066 static void reflectReflectedNameAttributeTestAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
3067 {
3068     v8::Handle<v8::Object> holder = info.Holder();
3069     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3070     v8SetReturnValueFast(info, WTF::getPtr(impl->fastGetAttribute(HTMLNames::reflectedNameAttributeAttr)), impl);
3071 }
3072
3073 static void reflectReflectedNameAttributeTestAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
3074 {
3075     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
3076     TestObjectPythonV8Internal::reflectReflectedNameAttributeTestAttributeAttributeGetter(info);
3077     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3078 }
3079
3080 static void reflectReflectedNameAttributeTestAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
3081 {
3082     v8::Handle<v8::Object> holder = info.Holder();
3083     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3084     V8TRYCATCH_VOID(TestInterface*, cppValue, V8TestInterface::toNativeWithTypeCheck(info.GetIsolate(), v8Value));
3085     CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope;
3086     impl->setAttribute(HTMLNames::reflectedNameAttributeAttr, WTF::getPtr(cppValue));
3087 }
3088
3089 static void reflectReflectedNameAttributeTestAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
3090 {
3091     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
3092     CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope;
3093     TestObjectPythonV8Internal::reflectReflectedNameAttributeTestAttributeAttributeSetter(v8Value, info);
3094     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3095 }
3096
3097 static void reflectBooleanAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
3098 {
3099     v8::Handle<v8::Object> holder = info.Holder();
3100     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3101     v8SetReturnValueBool(info, impl->fastHasAttribute(HTMLNames::reflectbooleanattributeAttr));
3102 }
3103
3104 static void reflectBooleanAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
3105 {
3106     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
3107     TestObjectPythonV8Internal::reflectBooleanAttributeAttributeGetter(info);
3108     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3109 }
3110
3111 static void reflectBooleanAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
3112 {
3113     v8::Handle<v8::Object> holder = info.Holder();
3114     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3115     V8TRYCATCH_VOID(bool, cppValue, v8Value->BooleanValue());
3116     CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope;
3117     impl->setBooleanAttribute(HTMLNames::reflectbooleanattributeAttr, cppValue);
3118 }
3119
3120 static void reflectBooleanAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
3121 {
3122     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
3123     CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope;
3124     TestObjectPythonV8Internal::reflectBooleanAttributeAttributeSetter(v8Value, info);
3125     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3126 }
3127
3128 static void reflectLongAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
3129 {
3130     v8::Handle<v8::Object> holder = info.Holder();
3131     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3132     v8SetReturnValueInt(info, impl->getIntegralAttribute(HTMLNames::reflectlongattributeAttr));
3133 }
3134
3135 static void reflectLongAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
3136 {
3137     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
3138     TestObjectPythonV8Internal::reflectLongAttributeAttributeGetter(info);
3139     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3140 }
3141
3142 static void reflectLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
3143 {
3144     v8::Handle<v8::Object> holder = info.Holder();
3145     ExceptionState exceptionState(ExceptionState::SetterContext, "reflectLongAttribute", "TestObjectPython", holder, info.GetIsolate());
3146     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3147     V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(v8Value, exceptionState), exceptionState);
3148     CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope;
3149     impl->setIntegralAttribute(HTMLNames::reflectlongattributeAttr, cppValue);
3150 }
3151
3152 static void reflectLongAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
3153 {
3154     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
3155     CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope;
3156     TestObjectPythonV8Internal::reflectLongAttributeAttributeSetter(v8Value, info);
3157     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3158 }
3159
3160 static void reflectUnsignedShortAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
3161 {
3162     v8::Handle<v8::Object> holder = info.Holder();
3163     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3164     v8SetReturnValueUnsigned(info, std::max(0, impl->fastGetAttribute(HTMLNames::reflectunsignedshortattributeAttr)));
3165 }
3166
3167 static void reflectUnsignedShortAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
3168 {
3169     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
3170     TestObjectPythonV8Internal::reflectUnsignedShortAttributeAttributeGetter(info);
3171     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3172 }
3173
3174 static void reflectUnsignedShortAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
3175 {
3176     v8::Handle<v8::Object> holder = info.Holder();
3177     ExceptionState exceptionState(ExceptionState::SetterContext, "reflectUnsignedShortAttribute", "TestObjectPython", holder, info.GetIsolate());
3178     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3179     V8TRYCATCH_EXCEPTION_VOID(unsigned, cppValue, toUInt16(v8Value, exceptionState), exceptionState);
3180     CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope;
3181     impl->setAttribute(HTMLNames::reflectunsignedshortattributeAttr, cppValue);
3182 }
3183
3184 static void reflectUnsignedShortAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
3185 {
3186     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
3187     CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope;
3188     TestObjectPythonV8Internal::reflectUnsignedShortAttributeAttributeSetter(v8Value, info);
3189     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3190 }
3191
3192 static void reflectUnsignedLongAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
3193 {
3194     v8::Handle<v8::Object> holder = info.Holder();
3195     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3196     v8SetReturnValueUnsigned(info, std::max(0, impl->getIntegralAttribute(HTMLNames::reflectunsignedlongattributeAttr)));
3197 }
3198
3199 static void reflectUnsignedLongAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
3200 {
3201     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
3202     TestObjectPythonV8Internal::reflectUnsignedLongAttributeAttributeGetter(info);
3203     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3204 }
3205
3206 static void reflectUnsignedLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
3207 {
3208     v8::Handle<v8::Object> holder = info.Holder();
3209     ExceptionState exceptionState(ExceptionState::SetterContext, "reflectUnsignedLongAttribute", "TestObjectPython", holder, info.GetIsolate());
3210     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3211     V8TRYCATCH_EXCEPTION_VOID(unsigned, cppValue, toUInt32(v8Value, exceptionState), exceptionState);
3212     CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope;
3213     impl->setUnsignedIntegralAttribute(HTMLNames::reflectunsignedlongattributeAttr, cppValue);
3214 }
3215
3216 static void reflectUnsignedLongAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
3217 {
3218     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
3219     CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope;
3220     TestObjectPythonV8Internal::reflectUnsignedLongAttributeAttributeSetter(v8Value, info);
3221     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3222 }
3223
3224 static void idAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
3225 {
3226     v8::Handle<v8::Object> holder = info.Holder();
3227     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3228     v8SetReturnValueString(info, impl->getIdAttribute(), info.GetIsolate());
3229 }
3230
3231 static void idAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
3232 {
3233     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
3234     TestObjectPythonV8Internal::idAttributeGetter(info);
3235     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3236 }
3237
3238 static void idAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
3239 {
3240     v8::Handle<v8::Object> holder = info.Holder();
3241     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3242     V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, cppValue, v8Value);
3243     CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope;
3244     impl->setAttribute(HTMLNames::idAttr, cppValue);
3245 }
3246
3247 static void idAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
3248 {
3249     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
3250     CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope;
3251     TestObjectPythonV8Internal::idAttributeSetter(v8Value, info);
3252     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3253 }
3254
3255 static void nameAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
3256 {
3257     v8::Handle<v8::Object> holder = info.Holder();
3258     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3259     v8SetReturnValueString(info, impl->getNameAttribute(), info.GetIsolate());
3260 }
3261
3262 static void nameAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
3263 {
3264     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
3265     TestObjectPythonV8Internal::nameAttributeGetter(info);
3266     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3267 }
3268
3269 static void nameAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
3270 {
3271     v8::Handle<v8::Object> holder = info.Holder();
3272     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3273     V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, cppValue, v8Value);
3274     CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope;
3275     impl->setAttribute(HTMLNames::nameAttr, cppValue);
3276 }
3277
3278 static void nameAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
3279 {
3280     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
3281     CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope;
3282     TestObjectPythonV8Internal::nameAttributeSetter(v8Value, info);
3283     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3284 }
3285
3286 static void classAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
3287 {
3288     v8::Handle<v8::Object> holder = info.Holder();
3289     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3290     v8SetReturnValueString(info, impl->getClassAttribute(), info.GetIsolate());
3291 }
3292
3293 static void classAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
3294 {
3295     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
3296     TestObjectPythonV8Internal::classAttributeGetter(info);
3297     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3298 }
3299
3300 static void classAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
3301 {
3302     v8::Handle<v8::Object> holder = info.Holder();
3303     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3304     V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, cppValue, v8Value);
3305     CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope;
3306     impl->setAttribute(HTMLNames::classAttr, cppValue);
3307 }
3308
3309 static void classAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
3310 {
3311     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
3312     CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope;
3313     TestObjectPythonV8Internal::classAttributeSetter(v8Value, info);
3314     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3315 }
3316
3317 static void reflectedIdAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
3318 {
3319     v8::Handle<v8::Object> holder = info.Holder();
3320     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3321     v8SetReturnValueString(info, impl->getIdAttribute(), info.GetIsolate());
3322 }
3323
3324 static void reflectedIdAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
3325 {
3326     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
3327     TestObjectPythonV8Internal::reflectedIdAttributeGetter(info);
3328     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3329 }
3330
3331 static void reflectedIdAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
3332 {
3333     v8::Handle<v8::Object> holder = info.Holder();
3334     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3335     V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, cppValue, v8Value);
3336     CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope;
3337     impl->setAttribute(HTMLNames::idAttr, cppValue);
3338 }
3339
3340 static void reflectedIdAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
3341 {
3342     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
3343     CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope;
3344     TestObjectPythonV8Internal::reflectedIdAttributeSetter(v8Value, info);
3345     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3346 }
3347
3348 static void reflectedNameAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
3349 {
3350     v8::Handle<v8::Object> holder = info.Holder();
3351     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3352     v8SetReturnValueString(info, impl->getNameAttribute(), info.GetIsolate());
3353 }
3354
3355 static void reflectedNameAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
3356 {
3357     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
3358     TestObjectPythonV8Internal::reflectedNameAttributeGetter(info);
3359     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3360 }
3361
3362 static void reflectedNameAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
3363 {
3364     v8::Handle<v8::Object> holder = info.Holder();
3365     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3366     V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, cppValue, v8Value);
3367     CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope;
3368     impl->setAttribute(HTMLNames::nameAttr, cppValue);
3369 }
3370
3371 static void reflectedNameAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
3372 {
3373     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
3374     CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope;
3375     TestObjectPythonV8Internal::reflectedNameAttributeSetter(v8Value, info);
3376     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3377 }
3378
3379 static void reflectedClassAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
3380 {
3381     v8::Handle<v8::Object> holder = info.Holder();
3382     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3383     v8SetReturnValueString(info, impl->getClassAttribute(), info.GetIsolate());
3384 }
3385
3386 static void reflectedClassAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
3387 {
3388     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
3389     TestObjectPythonV8Internal::reflectedClassAttributeGetter(info);
3390     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3391 }
3392
3393 static void reflectedClassAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
3394 {
3395     v8::Handle<v8::Object> holder = info.Holder();
3396     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3397     V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, cppValue, v8Value);
3398     CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope;
3399     impl->setAttribute(HTMLNames::classAttr, cppValue);
3400 }
3401
3402 static void reflectedClassAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
3403 {
3404     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
3405     CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope;
3406     TestObjectPythonV8Internal::reflectedClassAttributeSetter(v8Value, info);
3407     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3408 }
3409
3410 static void limitedToOnlyOneAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
3411 {
3412     v8::Handle<v8::Object> holder = info.Holder();
3413     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3414     String v8Value = impl->fastGetAttribute(HTMLNames::limitedtoonlyoneattributeAttr);
3415     if (v8Value.isEmpty()) {
3416         ;
3417     } else if (equalIgnoringCase(v8Value, "unique")) {
3418         v8Value = "unique";
3419     } else {
3420         v8Value = "";
3421     }
3422     v8SetReturnValueString(info, v8Value, info.GetIsolate());
3423 }
3424
3425 static void limitedToOnlyOneAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
3426 {
3427     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
3428     TestObjectPythonV8Internal::limitedToOnlyOneAttributeAttributeGetter(info);
3429     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3430 }
3431
3432 static void limitedToOnlyOneAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
3433 {
3434     v8::Handle<v8::Object> holder = info.Holder();
3435     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3436     V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, cppValue, v8Value);
3437     CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope;
3438     impl->setAttribute(HTMLNames::limitedtoonlyoneattributeAttr, cppValue);
3439 }
3440
3441 static void limitedToOnlyOneAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
3442 {
3443     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
3444     CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope;
3445     TestObjectPythonV8Internal::limitedToOnlyOneAttributeAttributeSetter(v8Value, info);
3446     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3447 }
3448
3449 static void limitedToOnlyAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
3450 {
3451     v8::Handle<v8::Object> holder = info.Holder();
3452     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3453     String v8Value = impl->fastGetAttribute(HTMLNames::limitedtoonlyattributeAttr);
3454     if (v8Value.isEmpty()) {
3455         ;
3456     } else if (equalIgnoringCase(v8Value, "Per")) {
3457         v8Value = "Per";
3458     } else if (equalIgnoringCase(v8Value, "Paal")) {
3459         v8Value = "Paal";
3460     } else if (equalIgnoringCase(v8Value, "Espen")) {
3461         v8Value = "Espen";
3462     } else {
3463         v8Value = "";
3464     }
3465     v8SetReturnValueString(info, v8Value, info.GetIsolate());
3466 }
3467
3468 static void limitedToOnlyAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
3469 {
3470     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
3471     TestObjectPythonV8Internal::limitedToOnlyAttributeAttributeGetter(info);
3472     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3473 }
3474
3475 static void limitedToOnlyAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
3476 {
3477     v8::Handle<v8::Object> holder = info.Holder();
3478     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3479     V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, cppValue, v8Value);
3480     CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope;
3481     impl->setAttribute(HTMLNames::limitedtoonlyattributeAttr, cppValue);
3482 }
3483
3484 static void limitedToOnlyAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
3485 {
3486     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
3487     CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope;
3488     TestObjectPythonV8Internal::limitedToOnlyAttributeAttributeSetter(v8Value, info);
3489     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3490 }
3491
3492 static void limitedToOnlyOtherAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
3493 {
3494     v8::Handle<v8::Object> holder = info.Holder();
3495     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3496     String v8Value = impl->fastGetAttribute(HTMLNames::OtherAttr);
3497     if (v8Value.isEmpty()) {
3498         ;
3499     } else if (equalIgnoringCase(v8Value, "Value1")) {
3500         v8Value = "Value1";
3501     } else if (equalIgnoringCase(v8Value, "Value2")) {
3502         v8Value = "Value2";
3503     } else {
3504         v8Value = "";
3505     }
3506     v8SetReturnValueString(info, v8Value, info.GetIsolate());
3507 }
3508
3509 static void limitedToOnlyOtherAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
3510 {
3511     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
3512     TestObjectPythonV8Internal::limitedToOnlyOtherAttributeAttributeGetter(info);
3513     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3514 }
3515
3516 static void limitedToOnlyOtherAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
3517 {
3518     v8::Handle<v8::Object> holder = info.Holder();
3519     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3520     V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, cppValue, v8Value);
3521     CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope;
3522     impl->setAttribute(HTMLNames::OtherAttr, cppValue);
3523 }
3524
3525 static void limitedToOnlyOtherAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
3526 {
3527     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
3528     CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope;
3529     TestObjectPythonV8Internal::limitedToOnlyOtherAttributeAttributeSetter(v8Value, info);
3530     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3531 }
3532
3533 static void limitedWithMissingDefaultAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
3534 {
3535     v8::Handle<v8::Object> holder = info.Holder();
3536     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3537     String v8Value = impl->fastGetAttribute(HTMLNames::limitedwithmissingdefaultattributeAttr);
3538     if (v8Value.isEmpty()) {
3539         v8Value = "rsa";
3540     } else if (equalIgnoringCase(v8Value, "rsa")) {
3541         v8Value = "rsa";
3542     } else if (equalIgnoringCase(v8Value, "dsa")) {
3543         v8Value = "dsa";
3544     } else {
3545         v8Value = "";
3546     }
3547     v8SetReturnValueString(info, v8Value, info.GetIsolate());
3548 }
3549
3550 static void limitedWithMissingDefaultAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
3551 {
3552     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
3553     TestObjectPythonV8Internal::limitedWithMissingDefaultAttributeAttributeGetter(info);
3554     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3555 }
3556
3557 static void limitedWithMissingDefaultAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
3558 {
3559     v8::Handle<v8::Object> holder = info.Holder();
3560     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3561     V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, cppValue, v8Value);
3562     CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope;
3563     impl->setAttribute(HTMLNames::limitedwithmissingdefaultattributeAttr, cppValue);
3564 }
3565
3566 static void limitedWithMissingDefaultAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
3567 {
3568     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
3569     CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope;
3570     TestObjectPythonV8Internal::limitedWithMissingDefaultAttributeAttributeSetter(v8Value, info);
3571     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3572 }
3573
3574 static void limitedWithInvalidMissingDefaultAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
3575 {
3576     v8::Handle<v8::Object> holder = info.Holder();
3577     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3578     String v8Value = impl->fastGetAttribute(HTMLNames::limitedwithinvalidmissingdefaultattributeAttr);
3579     if (v8Value.isEmpty()) {
3580         v8Value = "auto";
3581     } else if (equalIgnoringCase(v8Value, "ltr")) {
3582         v8Value = "ltr";
3583     } else if (equalIgnoringCase(v8Value, "rtl")) {
3584         v8Value = "rtl";
3585     } else if (equalIgnoringCase(v8Value, "auto")) {
3586         v8Value = "auto";
3587     } else {
3588         v8Value = "ltr";
3589     }
3590     v8SetReturnValueString(info, v8Value, info.GetIsolate());
3591 }
3592
3593 static void limitedWithInvalidMissingDefaultAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
3594 {
3595     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
3596     TestObjectPythonV8Internal::limitedWithInvalidMissingDefaultAttributeAttributeGetter(info);
3597     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3598 }
3599
3600 static void limitedWithInvalidMissingDefaultAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
3601 {
3602     v8::Handle<v8::Object> holder = info.Holder();
3603     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3604     V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, cppValue, v8Value);
3605     CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope;
3606     impl->setAttribute(HTMLNames::limitedwithinvalidmissingdefaultattributeAttr, cppValue);
3607 }
3608
3609 static void limitedWithInvalidMissingDefaultAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
3610 {
3611     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
3612     CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope;
3613     TestObjectPythonV8Internal::limitedWithInvalidMissingDefaultAttributeAttributeSetter(v8Value, info);
3614     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3615 }
3616
3617 static void corsSettingAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
3618 {
3619     v8::Handle<v8::Object> holder = info.Holder();
3620     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3621     String v8Value = impl->fastGetAttribute(HTMLNames::corssettingattributeAttr);
3622     if (v8Value.isNull()) {
3623         ;
3624     } else if (v8Value.isEmpty()) {
3625         v8Value = "anonymous";
3626     } else if (equalIgnoringCase(v8Value, "anonymous")) {
3627         v8Value = "anonymous";
3628     } else if (equalIgnoringCase(v8Value, "use-credentials")) {
3629         v8Value = "use-credentials";
3630     } else {
3631         v8Value = "anonymous";
3632     }
3633     v8SetReturnValueString(info, v8Value, info.GetIsolate());
3634 }
3635
3636 static void corsSettingAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
3637 {
3638     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
3639     TestObjectPythonV8Internal::corsSettingAttributeAttributeGetter(info);
3640     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3641 }
3642
3643 static void limitedWithEmptyMissingInvalidAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
3644 {
3645     v8::Handle<v8::Object> holder = info.Holder();
3646     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3647     String v8Value = impl->fastGetAttribute(HTMLNames::limitedwithemptymissinginvalidattributeAttr);
3648     if (v8Value.isNull()) {
3649         v8Value = "missing";
3650     } else if (v8Value.isEmpty()) {
3651         v8Value = "empty";
3652     } else if (equalIgnoringCase(v8Value, "empty")) {
3653         v8Value = "empty";
3654     } else if (equalIgnoringCase(v8Value, "missing")) {
3655         v8Value = "missing";
3656     } else if (equalIgnoringCase(v8Value, "invalid")) {
3657         v8Value = "invalid";
3658     } else if (equalIgnoringCase(v8Value, "a-normal")) {
3659         v8Value = "a-normal";
3660     } else {
3661         v8Value = "invalid";
3662     }
3663     v8SetReturnValueString(info, v8Value, info.GetIsolate());
3664 }
3665
3666 static void limitedWithEmptyMissingInvalidAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
3667 {
3668     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
3669     TestObjectPythonV8Internal::limitedWithEmptyMissingInvalidAttributeAttributeGetter(info);
3670     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3671 }
3672
3673 static void replaceableReadonlyLongAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
3674 {
3675     v8::Handle<v8::Object> holder = info.Holder();
3676     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3677     v8SetReturnValueInt(info, impl->replaceableReadonlyLongAttribute());
3678 }
3679
3680 static void replaceableReadonlyLongAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
3681 {
3682     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
3683     TestObjectPythonV8Internal::replaceableReadonlyLongAttributeAttributeGetter(info);
3684     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3685 }
3686
3687 static void locationReplaceableAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
3688 {
3689     v8::Handle<v8::Object> holder = info.Holder();
3690     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3691     v8SetReturnValueFast(info, WTF::getPtr(impl->locationReplaceable()), impl);
3692 }
3693
3694 static void locationReplaceableAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
3695 {
3696     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
3697     TestObjectPythonV8Internal::locationReplaceableAttributeGetter(info);
3698     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3699 }
3700
3701 static void locationReplaceableAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
3702 {
3703     v8::Handle<v8::Object> holder = info.Holder();
3704     TestObjectPython* proxyImpl = V8TestObjectPython::toNative(holder);
3705     RefPtr<TestNode> impl = WTF::getPtr(proxyImpl->locationReplaceable());
3706     if (!impl)
3707         return;
3708     V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, cppValue, v8Value);
3709     impl->setHref(cppValue);
3710 }
3711
3712 static void locationReplaceableAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
3713 {
3714     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
3715     TestObjectPythonV8Internal::locationReplaceableAttributeSetter(v8Value, info);
3716     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3717 }
3718
3719 static void runtimeEnabledLongAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
3720 {
3721     v8::Handle<v8::Object> holder = info.Holder();
3722     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3723     v8SetReturnValueInt(info, impl->runtimeEnabledLongAttribute());
3724 }
3725
3726 static void runtimeEnabledLongAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
3727 {
3728     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
3729     TestObjectPythonV8Internal::runtimeEnabledLongAttributeAttributeGetter(info);
3730     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3731 }
3732
3733 static void runtimeEnabledLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
3734 {
3735     v8::Handle<v8::Object> holder = info.Holder();
3736     ExceptionState exceptionState(ExceptionState::SetterContext, "runtimeEnabledLongAttribute", "TestObjectPython", holder, info.GetIsolate());
3737     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3738     V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(v8Value, exceptionState), exceptionState);
3739     impl->setRuntimeEnabledLongAttribute(cppValue);
3740 }
3741
3742 static void runtimeEnabledLongAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
3743 {
3744     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
3745     TestObjectPythonV8Internal::runtimeEnabledLongAttributeAttributeSetter(v8Value, info);
3746     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3747 }
3748
3749 static void perContextEnabledRuntimeEnabledLongAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
3750 {
3751     v8::Handle<v8::Object> holder = info.Holder();
3752     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3753     v8SetReturnValueInt(info, impl->perContextEnabledRuntimeEnabledLongAttribute());
3754 }
3755
3756 static void perContextEnabledRuntimeEnabledLongAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
3757 {
3758     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
3759     TestObjectPythonV8Internal::perContextEnabledRuntimeEnabledLongAttributeAttributeGetter(info);
3760     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3761 }
3762
3763 static void perContextEnabledRuntimeEnabledLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
3764 {
3765     v8::Handle<v8::Object> holder = info.Holder();
3766     ExceptionState exceptionState(ExceptionState::SetterContext, "perContextEnabledRuntimeEnabledLongAttribute", "TestObjectPython", holder, info.GetIsolate());
3767     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3768     V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(v8Value, exceptionState), exceptionState);
3769     impl->setPerContextEnabledRuntimeEnabledLongAttribute(cppValue);
3770 }
3771
3772 static void perContextEnabledRuntimeEnabledLongAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
3773 {
3774     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
3775     TestObjectPythonV8Internal::perContextEnabledRuntimeEnabledLongAttributeAttributeSetter(v8Value, info);
3776     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3777 }
3778
3779 #if ENABLE(CONDITION)
3780 static void conditionalRuntimeEnabledLongAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
3781 {
3782     v8::Handle<v8::Object> holder = info.Holder();
3783     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3784     v8SetReturnValueInt(info, impl->conditionalRuntimeEnabledLongAttribute());
3785 }
3786 #endif // ENABLE(CONDITION)
3787
3788 #if ENABLE(CONDITION)
3789 static void conditionalRuntimeEnabledLongAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
3790 {
3791     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
3792     TestObjectPythonV8Internal::conditionalRuntimeEnabledLongAttributeAttributeGetter(info);
3793     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3794 }
3795 #endif // ENABLE(CONDITION)
3796
3797 #if ENABLE(CONDITION)
3798 static void conditionalRuntimeEnabledLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
3799 {
3800     v8::Handle<v8::Object> holder = info.Holder();
3801     ExceptionState exceptionState(ExceptionState::SetterContext, "conditionalRuntimeEnabledLongAttribute", "TestObjectPython", holder, info.GetIsolate());
3802     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3803     V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(v8Value, exceptionState), exceptionState);
3804     impl->setConditionalRuntimeEnabledLongAttribute(cppValue);
3805 }
3806 #endif // ENABLE(CONDITION)
3807
3808 #if ENABLE(CONDITION)
3809 static void conditionalRuntimeEnabledLongAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
3810 {
3811     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
3812     TestObjectPythonV8Internal::conditionalRuntimeEnabledLongAttributeAttributeSetter(v8Value, info);
3813     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3814 }
3815 #endif // ENABLE(CONDITION)
3816
3817 static void setterCallWithActiveWindowAndFirstWindowStringAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
3818 {
3819     v8::Handle<v8::Object> holder = info.Holder();
3820     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3821     v8SetReturnValueString(info, impl->setterCallWithActiveWindowAndFirstWindowStringAttribute(), info.GetIsolate());
3822 }
3823
3824 static void setterCallWithActiveWindowAndFirstWindowStringAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
3825 {
3826     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
3827     TestObjectPythonV8Internal::setterCallWithActiveWindowAndFirstWindowStringAttributeAttributeGetter(info);
3828     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3829 }
3830
3831 static void setterCallWithActiveWindowAndFirstWindowStringAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
3832 {
3833     v8::Handle<v8::Object> holder = info.Holder();
3834     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3835     V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, cppValue, v8Value);
3836     impl->setSetterCallWithActiveWindowAndFirstWindowStringAttribute(callingDOMWindow(info.GetIsolate()), enteredDOMWindow(info.GetIsolate()), cppValue);
3837 }
3838
3839 static void setterCallWithActiveWindowAndFirstWindowStringAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
3840 {
3841     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
3842     TestObjectPythonV8Internal::setterCallWithActiveWindowAndFirstWindowStringAttributeAttributeSetter(v8Value, info);
3843     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3844 }
3845
3846 static void setterCallWithExecutionContextStringAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
3847 {
3848     v8::Handle<v8::Object> holder = info.Holder();
3849     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3850     v8SetReturnValueString(info, impl->setterCallWithExecutionContextStringAttribute(), info.GetIsolate());
3851 }
3852
3853 static void setterCallWithExecutionContextStringAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
3854 {
3855     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
3856     TestObjectPythonV8Internal::setterCallWithExecutionContextStringAttributeAttributeGetter(info);
3857     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3858 }
3859
3860 static void setterCallWithExecutionContextStringAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
3861 {
3862     v8::Handle<v8::Object> holder = info.Holder();
3863     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3864     V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, cppValue, v8Value);
3865     ExecutionContext* scriptContext = currentExecutionContext(info.GetIsolate());
3866     impl->setSetterCallWithExecutionContextStringAttribute(scriptContext, cppValue);
3867 }
3868
3869 static void setterCallWithExecutionContextStringAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
3870 {
3871     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
3872     TestObjectPythonV8Internal::setterCallWithExecutionContextStringAttributeAttributeSetter(v8Value, info);
3873     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3874 }
3875
3876 static void strictTypeCheckingFloatAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
3877 {
3878     v8::Handle<v8::Object> holder = info.Holder();
3879     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3880     v8SetReturnValue(info, impl->strictTypeCheckingFloatAttribute());
3881 }
3882
3883 static void strictTypeCheckingFloatAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
3884 {
3885     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
3886     TestObjectPythonV8Internal::strictTypeCheckingFloatAttributeAttributeGetter(info);
3887     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3888 }
3889
3890 static void strictTypeCheckingFloatAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
3891 {
3892     v8::Handle<v8::Object> holder = info.Holder();
3893     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3894     V8TRYCATCH_VOID(float, cppValue, static_cast<float>(v8Value->NumberValue()));
3895     impl->setStrictTypeCheckingFloatAttribute(cppValue);
3896 }
3897
3898 static void strictTypeCheckingFloatAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
3899 {
3900     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
3901     TestObjectPythonV8Internal::strictTypeCheckingFloatAttributeAttributeSetter(v8Value, info);
3902     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3903 }
3904
3905 static void strictTypeCheckingTestInterfaceAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
3906 {
3907     v8::Handle<v8::Object> holder = info.Holder();
3908     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3909     v8SetReturnValueFast(info, WTF::getPtr(impl->strictTypeCheckingTestInterfaceAttribute()), impl);
3910 }
3911
3912 static void strictTypeCheckingTestInterfaceAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
3913 {
3914     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
3915     TestObjectPythonV8Internal::strictTypeCheckingTestInterfaceAttributeAttributeGetter(info);
3916     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3917 }
3918
3919 static void strictTypeCheckingTestInterfaceAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
3920 {
3921     v8::Handle<v8::Object> holder = info.Holder();
3922     ExceptionState exceptionState(ExceptionState::SetterContext, "strictTypeCheckingTestInterfaceAttribute", "TestObjectPython", holder, info.GetIsolate());
3923     if (!isUndefinedOrNull(v8Value) && !V8TestInterface::hasInstance(v8Value, info.GetIsolate())) {
3924         exceptionState.throwTypeError("The provided value is not of type 'TestInterface'.");
3925         exceptionState.throwIfNeeded();
3926         return;
3927     }
3928     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3929     V8TRYCATCH_VOID(TestInterface*, cppValue, V8TestInterface::toNativeWithTypeCheck(info.GetIsolate(), v8Value));
3930     impl->setStrictTypeCheckingTestInterfaceAttribute(WTF::getPtr(cppValue));
3931 }
3932
3933 static void strictTypeCheckingTestInterfaceAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
3934 {
3935     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
3936     TestObjectPythonV8Internal::strictTypeCheckingTestInterfaceAttributeAttributeSetter(v8Value, info);
3937     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3938 }
3939
3940 static void treatNullAsNullStringStringAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
3941 {
3942     v8::Handle<v8::Object> holder = info.Holder();
3943     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3944     v8SetReturnValueString(info, impl->treatNullAsNullStringStringAttribute(), info.GetIsolate());
3945 }
3946
3947 static void treatNullAsNullStringStringAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
3948 {
3949     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
3950     TestObjectPythonV8Internal::treatNullAsNullStringStringAttributeAttributeGetter(info);
3951     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3952 }
3953
3954 static void treatNullAsNullStringStringAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
3955 {
3956     v8::Handle<v8::Object> holder = info.Holder();
3957     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3958     V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<WithNullCheck>, cppValue, v8Value);
3959     impl->setTreatNullAsNullStringStringAttribute(cppValue);
3960 }
3961
3962 static void treatNullAsNullStringStringAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
3963 {
3964     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
3965     TestObjectPythonV8Internal::treatNullAsNullStringStringAttributeAttributeSetter(v8Value, info);
3966     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3967 }
3968
3969 static void treatReturnedNullStringAsNullStringAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
3970 {
3971     v8::Handle<v8::Object> holder = info.Holder();
3972     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3973     v8SetReturnValueStringOrNull(info, impl->treatReturnedNullStringAsNullStringAttribute(), info.GetIsolate());
3974 }
3975
3976 static void treatReturnedNullStringAsNullStringAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
3977 {
3978     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
3979     TestObjectPythonV8Internal::treatReturnedNullStringAsNullStringAttributeAttributeGetter(info);
3980     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3981 }
3982
3983 static void treatReturnedNullStringAsNullStringAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
3984 {
3985     v8::Handle<v8::Object> holder = info.Holder();
3986     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
3987     V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, cppValue, v8Value);
3988     impl->setTreatReturnedNullStringAsNullStringAttribute(cppValue);
3989 }
3990
3991 static void treatReturnedNullStringAsNullStringAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
3992 {
3993     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
3994     TestObjectPythonV8Internal::treatReturnedNullStringAsNullStringAttributeAttributeSetter(v8Value, info);
3995     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
3996 }
3997
3998 static void treatReturnedNullStringAsUndefinedStringAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
3999 {
4000     v8::Handle<v8::Object> holder = info.Holder();
4001     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
4002     v8SetReturnValueStringOrUndefined(info, impl->treatReturnedNullStringAsUndefinedStringAttribute(), info.GetIsolate());
4003 }
4004
4005 static void treatReturnedNullStringAsUndefinedStringAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
4006 {
4007     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
4008     TestObjectPythonV8Internal::treatReturnedNullStringAsUndefinedStringAttributeAttributeGetter(info);
4009     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4010 }
4011
4012 static void treatReturnedNullStringAsUndefinedStringAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
4013 {
4014     v8::Handle<v8::Object> holder = info.Holder();
4015     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
4016     V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, cppValue, v8Value);
4017     impl->setTreatReturnedNullStringAsUndefinedStringAttribute(cppValue);
4018 }
4019
4020 static void treatReturnedNullStringAsUndefinedStringAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
4021 {
4022     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
4023     TestObjectPythonV8Internal::treatReturnedNullStringAsUndefinedStringAttributeAttributeSetter(v8Value, info);
4024     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4025 }
4026
4027 static void urlStringAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
4028 {
4029     v8::Handle<v8::Object> holder = info.Holder();
4030     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
4031     v8SetReturnValueString(info, impl->getURLAttribute(HTMLNames::urlstringattributeAttr), info.GetIsolate());
4032 }
4033
4034 static void urlStringAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
4035 {
4036     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
4037     TestObjectPythonV8Internal::urlStringAttributeAttributeGetter(info);
4038     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4039 }
4040
4041 static void urlStringAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
4042 {
4043     v8::Handle<v8::Object> holder = info.Holder();
4044     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
4045     V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, cppValue, v8Value);
4046     CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope;
4047     impl->setAttribute(HTMLNames::urlstringattributeAttr, cppValue);
4048 }
4049
4050 static void urlStringAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
4051 {
4052     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
4053     CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope;
4054     TestObjectPythonV8Internal::urlStringAttributeAttributeSetter(v8Value, info);
4055     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4056 }
4057
4058 static void urlStringAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
4059 {
4060     v8::Handle<v8::Object> holder = info.Holder();
4061     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
4062     v8SetReturnValueString(info, impl->getURLAttribute(HTMLNames::ReflectUrlAttributeAttr), info.GetIsolate());
4063 }
4064
4065 static void urlStringAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
4066 {
4067     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
4068     TestObjectPythonV8Internal::urlStringAttributeAttributeGetter(info);
4069     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4070 }
4071
4072 static void urlStringAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
4073 {
4074     v8::Handle<v8::Object> holder = info.Holder();
4075     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
4076     V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, cppValue, v8Value);
4077     CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope;
4078     impl->setAttribute(HTMLNames::ReflectUrlAttributeAttr, cppValue);
4079 }
4080
4081 static void urlStringAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
4082 {
4083     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
4084     CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope;
4085     TestObjectPythonV8Internal::urlStringAttributeAttributeSetter(v8Value, info);
4086     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4087 }
4088
4089 static void unforgeableLongAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
4090 {
4091     v8::Handle<v8::Object> holder = V8TestObjectPython::findInstanceInPrototypeChain(info.This(), info.GetIsolate());
4092     if (holder.IsEmpty())
4093         return;
4094     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
4095     v8SetReturnValueInt(info, impl->unforgeableLongAttribute());
4096 }
4097
4098 static void unforgeableLongAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
4099 {
4100     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
4101     TestObjectPythonV8Internal::unforgeableLongAttributeAttributeGetter(info);
4102     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4103 }
4104
4105 static void unforgeableLongAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
4106 {
4107     v8::Handle<v8::Object> holder = info.Holder();
4108     ExceptionState exceptionState(ExceptionState::SetterContext, "unforgeableLongAttribute", "TestObjectPython", holder, info.GetIsolate());
4109     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
4110     V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(v8Value, exceptionState), exceptionState);
4111     impl->setUnforgeableLongAttribute(cppValue);
4112 }
4113
4114 static void unforgeableLongAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
4115 {
4116     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
4117     TestObjectPythonV8Internal::unforgeableLongAttributeAttributeSetter(v8Value, info);
4118     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4119 }
4120
4121 static void anotherStringAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
4122 {
4123     v8::Handle<v8::Object> holder = info.Holder();
4124     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
4125     v8SetReturnValueString(info, impl->fastGetAttribute(HTMLNames::ReflectUrlAttributeAsAStringAttr), info.GetIsolate());
4126 }
4127
4128 static void anotherStringAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
4129 {
4130     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
4131     TestObjectPythonV8Internal::anotherStringAttributeAttributeGetter(info);
4132     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4133 }
4134
4135 static void anotherStringAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
4136 {
4137     v8::Handle<v8::Object> holder = info.Holder();
4138     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
4139     V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, cppValue, v8Value);
4140     CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope;
4141     impl->setAttribute(HTMLNames::ReflectUrlAttributeAsAStringAttr, cppValue);
4142 }
4143
4144 static void anotherStringAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
4145 {
4146     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
4147     CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope;
4148     TestObjectPythonV8Internal::anotherStringAttributeAttributeSetter(v8Value, info);
4149     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4150 }
4151
4152 static void testInterfacePythonAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
4153 {
4154     v8::Handle<v8::Object> holder = info.Holder();
4155     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
4156     v8SetReturnValueFast(info, WTF::getPtr(impl->testInterfacePythonAttribute()), impl);
4157 }
4158
4159 static void testInterfacePythonAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
4160 {
4161     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
4162     TestObjectPythonV8Internal::testInterfacePythonAttributeAttributeGetter(info);
4163     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4164 }
4165
4166 static void testInterfacePythonAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
4167 {
4168     v8::Handle<v8::Object> holder = info.Holder();
4169     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
4170     V8TRYCATCH_VOID(TestInterfacePythonImplementation*, cppValue, V8TestInterfacePython::toNativeWithTypeCheck(info.GetIsolate(), v8Value));
4171     impl->setTestInterfacePythonAttribute(WTF::getPtr(cppValue));
4172 }
4173
4174 static void testInterfacePythonAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
4175 {
4176     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
4177     TestObjectPythonV8Internal::testInterfacePythonAttributeAttributeSetter(v8Value, info);
4178     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4179 }
4180
4181 static void testInterfaceWillBeGarbageCollectedAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
4182 {
4183     v8::Handle<v8::Object> holder = info.Holder();
4184     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
4185     v8SetReturnValueFast(info, WTF::getPtr(impl->testInterfaceWillBeGarbageCollectedAttribute()), impl);
4186 }
4187
4188 static void testInterfaceWillBeGarbageCollectedAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
4189 {
4190     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
4191     TestObjectPythonV8Internal::testInterfaceWillBeGarbageCollectedAttributeAttributeGetter(info);
4192     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4193 }
4194
4195 static void testInterfaceWillBeGarbageCollectedAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
4196 {
4197     v8::Handle<v8::Object> holder = info.Holder();
4198     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
4199     V8TRYCATCH_VOID(TestInterfaceWillBeGarbageCollected*, cppValue, V8TestInterfaceWillBeGarbageCollected::toNativeWithTypeCheck(info.GetIsolate(), v8Value));
4200     impl->setTestInterfaceWillBeGarbageCollectedAttribute(WTF::getPtr(cppValue));
4201 }
4202
4203 static void testInterfaceWillBeGarbageCollectedAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
4204 {
4205     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
4206     TestObjectPythonV8Internal::testInterfaceWillBeGarbageCollectedAttributeAttributeSetter(v8Value, info);
4207     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4208 }
4209
4210 static void testInterfaceWillBeGarbageCollectedOrNullAttributeAttributeGetter(const v8::PropertyCallbackInfo<v8::Value>& info)
4211 {
4212     v8::Handle<v8::Object> holder = info.Holder();
4213     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
4214     bool isNull = false;
4215     RefPtrWillBeRawPtr<TestInterfaceWillBeGarbageCollected> v8Value = impl->testInterfaceWillBeGarbageCollectedOrNullAttribute(isNull);
4216     if (isNull) {
4217         v8SetReturnValueNull(info);
4218         return;
4219     }
4220     v8SetReturnValueFast(info, WTF::getPtr(v8Value.release()), impl);
4221 }
4222
4223 static void testInterfaceWillBeGarbageCollectedOrNullAttributeAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
4224 {
4225     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
4226     TestObjectPythonV8Internal::testInterfaceWillBeGarbageCollectedOrNullAttributeAttributeGetter(info);
4227     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4228 }
4229
4230 static void testInterfaceWillBeGarbageCollectedOrNullAttributeAttributeSetter(v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
4231 {
4232     v8::Handle<v8::Object> holder = info.Holder();
4233     TestObjectPython* impl = V8TestObjectPython::toNative(holder);
4234     V8TRYCATCH_VOID(TestInterfaceWillBeGarbageCollected*, cppValue, V8TestInterfaceWillBeGarbageCollected::toNativeWithTypeCheck(info.GetIsolate(), v8Value));
4235     impl->setTestInterfaceWillBeGarbageCollectedOrNullAttribute(WTF::getPtr(cppValue));
4236 }
4237
4238 static void testInterfaceWillBeGarbageCollectedOrNullAttributeAttributeSetterCallback(v8::Local<v8::String>, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
4239 {
4240     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
4241     TestObjectPythonV8Internal::testInterfaceWillBeGarbageCollectedOrNullAttributeAttributeSetter(v8Value, info);
4242     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4243 }
4244
4245 static void TestObjectPythonConstructorGetter(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
4246 {
4247     v8::Handle<v8::Value> data = info.Data();
4248     ASSERT(data->IsExternal());
4249     V8PerContextData* perContextData = V8PerContextData::from(info.Holder()->CreationContext());
4250     if (!perContextData)
4251         return;
4252     v8SetReturnValue(info, perContextData->constructorForType(WrapperTypeInfo::unwrap(data)));
4253 }
4254
4255 static void TestObjectPythonReplaceableAttributeSetter(v8::Local<v8::String> name, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
4256 {
4257     info.This()->ForceSet(name, v8Value);
4258 }
4259
4260 static void TestObjectPythonReplaceableAttributeSetterCallback(v8::Local<v8::String> name, v8::Local<v8::Value> v8Value, const v8::PropertyCallbackInfo<void>& info)
4261 {
4262     TestObjectPythonV8Internal::TestObjectPythonReplaceableAttributeSetter(name, v8Value, info);
4263 }
4264
4265 static void voidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
4266 {
4267     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
4268     impl->voidMethod();
4269 }
4270
4271 static void voidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
4272 {
4273     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4274     TestObjectPythonV8Internal::voidMethodMethod(info);
4275     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4276 }
4277
4278 static void staticVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
4279 {
4280     TestObjectPython::staticVoidMethod();
4281 }
4282
4283 static void staticVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
4284 {
4285     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4286     TestObjectPythonV8Internal::staticVoidMethodMethod(info);
4287     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4288 }
4289
4290 static void dateMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
4291 {
4292     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
4293     v8SetReturnValue(info, v8DateOrNull(impl->dateMethod(), info.GetIsolate()));
4294 }
4295
4296 static void dateMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
4297 {
4298     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4299     TestObjectPythonV8Internal::dateMethodMethod(info);
4300     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4301 }
4302
4303 static void stringMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
4304 {
4305     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
4306     v8SetReturnValueString(info, impl->stringMethod(), info.GetIsolate());
4307 }
4308
4309 static void stringMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
4310 {
4311     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4312     TestObjectPythonV8Internal::stringMethodMethod(info);
4313     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4314 }
4315
4316 static void readonlyDOMTimeStampMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
4317 {
4318     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
4319     v8SetReturnValue(info, static_cast<double>(impl->readonlyDOMTimeStampMethod()));
4320 }
4321
4322 static void readonlyDOMTimeStampMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
4323 {
4324     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4325     TestObjectPythonV8Internal::readonlyDOMTimeStampMethodMethod(info);
4326     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4327 }
4328
4329 static void booleanMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
4330 {
4331     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
4332     v8SetReturnValueBool(info, impl->booleanMethod());
4333 }
4334
4335 static void booleanMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
4336 {
4337     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4338     TestObjectPythonV8Internal::booleanMethodMethod(info);
4339     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4340 }
4341
4342 static void byteMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
4343 {
4344     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
4345     v8SetReturnValueInt(info, impl->byteMethod());
4346 }
4347
4348 static void byteMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
4349 {
4350     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4351     TestObjectPythonV8Internal::byteMethodMethod(info);
4352     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4353 }
4354
4355 static void doubleMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
4356 {
4357     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
4358     v8SetReturnValue(info, impl->doubleMethod());
4359 }
4360
4361 static void doubleMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
4362 {
4363     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4364     TestObjectPythonV8Internal::doubleMethodMethod(info);
4365     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4366 }
4367
4368 static void floatMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
4369 {
4370     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
4371     v8SetReturnValue(info, impl->floatMethod());
4372 }
4373
4374 static void floatMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
4375 {
4376     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4377     TestObjectPythonV8Internal::floatMethodMethod(info);
4378     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4379 }
4380
4381 static void longMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
4382 {
4383     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
4384     v8SetReturnValueInt(info, impl->longMethod());
4385 }
4386
4387 static void longMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
4388 {
4389     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4390     TestObjectPythonV8Internal::longMethodMethod(info);
4391     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4392 }
4393
4394 static void longLongMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
4395 {
4396     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
4397     v8SetReturnValue(info, static_cast<double>(impl->longLongMethod()));
4398 }
4399
4400 static void longLongMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
4401 {
4402     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4403     TestObjectPythonV8Internal::longLongMethodMethod(info);
4404     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4405 }
4406
4407 static void octetMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
4408 {
4409     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
4410     v8SetReturnValueUnsigned(info, impl->octetMethod());
4411 }
4412
4413 static void octetMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
4414 {
4415     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4416     TestObjectPythonV8Internal::octetMethodMethod(info);
4417     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4418 }
4419
4420 static void shortMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
4421 {
4422     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
4423     v8SetReturnValueInt(info, impl->shortMethod());
4424 }
4425
4426 static void shortMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
4427 {
4428     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4429     TestObjectPythonV8Internal::shortMethodMethod(info);
4430     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4431 }
4432
4433 static void unsignedLongMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
4434 {
4435     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
4436     v8SetReturnValueUnsigned(info, impl->unsignedLongMethod());
4437 }
4438
4439 static void unsignedLongMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
4440 {
4441     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4442     TestObjectPythonV8Internal::unsignedLongMethodMethod(info);
4443     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4444 }
4445
4446 static void unsignedLongLongMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
4447 {
4448     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
4449     v8SetReturnValue(info, static_cast<double>(impl->unsignedLongLongMethod()));
4450 }
4451
4452 static void unsignedLongLongMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
4453 {
4454     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4455     TestObjectPythonV8Internal::unsignedLongLongMethodMethod(info);
4456     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4457 }
4458
4459 static void unsignedShortMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
4460 {
4461     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
4462     v8SetReturnValueUnsigned(info, impl->unsignedShortMethod());
4463 }
4464
4465 static void unsignedShortMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
4466 {
4467     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4468     TestObjectPythonV8Internal::unsignedShortMethodMethod(info);
4469     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4470 }
4471
4472 static void voidMethodDateArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
4473 {
4474     if (UNLIKELY(info.Length() < 1)) {
4475         throwTypeError(ExceptionMessages::failedToExecute("voidMethodDateArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate());
4476         return;
4477     }
4478     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
4479     V8TRYCATCH_VOID(double, dateArg, toCoreDate(info[0]));
4480     impl->voidMethodDateArg(dateArg);
4481 }
4482
4483 static void voidMethodDateArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
4484 {
4485     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4486     TestObjectPythonV8Internal::voidMethodDateArgMethod(info);
4487     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4488 }
4489
4490 static void voidMethodStringArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
4491 {
4492     if (UNLIKELY(info.Length() < 1)) {
4493         throwTypeError(ExceptionMessages::failedToExecute("voidMethodStringArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate());
4494         return;
4495     }
4496     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
4497     V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, stringArg, info[0]);
4498     impl->voidMethodStringArg(stringArg);
4499 }
4500
4501 static void voidMethodStringArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
4502 {
4503     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4504     TestObjectPythonV8Internal::voidMethodStringArgMethod(info);
4505     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4506 }
4507
4508 static void voidMethodBooleanArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
4509 {
4510     if (UNLIKELY(info.Length() < 1)) {
4511         throwTypeError(ExceptionMessages::failedToExecute("voidMethodBooleanArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate());
4512         return;
4513     }
4514     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
4515     V8TRYCATCH_VOID(bool, booleanArg, info[0]->BooleanValue());
4516     impl->voidMethodBooleanArg(booleanArg);
4517 }
4518
4519 static void voidMethodBooleanArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
4520 {
4521     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4522     TestObjectPythonV8Internal::voidMethodBooleanArgMethod(info);
4523     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4524 }
4525
4526 static void voidMethodByteArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
4527 {
4528     ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodByteArg", "TestObjectPython", info.Holder(), info.GetIsolate());
4529     if (UNLIKELY(info.Length() < 1)) {
4530         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
4531         exceptionState.throwIfNeeded();
4532         return;
4533     }
4534     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
4535     V8TRYCATCH_EXCEPTION_VOID(int, byteArg, toInt8(info[0], exceptionState), exceptionState);
4536     impl->voidMethodByteArg(byteArg);
4537 }
4538
4539 static void voidMethodByteArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
4540 {
4541     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4542     TestObjectPythonV8Internal::voidMethodByteArgMethod(info);
4543     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4544 }
4545
4546 static void voidMethodDoubleArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
4547 {
4548     if (UNLIKELY(info.Length() < 1)) {
4549         throwTypeError(ExceptionMessages::failedToExecute("voidMethodDoubleArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate());
4550         return;
4551     }
4552     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
4553     V8TRYCATCH_VOID(double, doubleArg, static_cast<double>(info[0]->NumberValue()));
4554     impl->voidMethodDoubleArg(doubleArg);
4555 }
4556
4557 static void voidMethodDoubleArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
4558 {
4559     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4560     TestObjectPythonV8Internal::voidMethodDoubleArgMethod(info);
4561     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4562 }
4563
4564 static void voidMethodFloatArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
4565 {
4566     if (UNLIKELY(info.Length() < 1)) {
4567         throwTypeError(ExceptionMessages::failedToExecute("voidMethodFloatArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate());
4568         return;
4569     }
4570     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
4571     V8TRYCATCH_VOID(float, floatArg, static_cast<float>(info[0]->NumberValue()));
4572     impl->voidMethodFloatArg(floatArg);
4573 }
4574
4575 static void voidMethodFloatArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
4576 {
4577     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4578     TestObjectPythonV8Internal::voidMethodFloatArgMethod(info);
4579     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4580 }
4581
4582 static void voidMethodLongArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
4583 {
4584     ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodLongArg", "TestObjectPython", info.Holder(), info.GetIsolate());
4585     if (UNLIKELY(info.Length() < 1)) {
4586         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
4587         exceptionState.throwIfNeeded();
4588         return;
4589     }
4590     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
4591     V8TRYCATCH_EXCEPTION_VOID(int, longArg, toInt32(info[0], exceptionState), exceptionState);
4592     impl->voidMethodLongArg(longArg);
4593 }
4594
4595 static void voidMethodLongArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
4596 {
4597     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4598     TestObjectPythonV8Internal::voidMethodLongArgMethod(info);
4599     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4600 }
4601
4602 static void voidMethodLongLongArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
4603 {
4604     ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodLongLongArg", "TestObjectPython", info.Holder(), info.GetIsolate());
4605     if (UNLIKELY(info.Length() < 1)) {
4606         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
4607         exceptionState.throwIfNeeded();
4608         return;
4609     }
4610     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
4611     V8TRYCATCH_EXCEPTION_VOID(long long, longLongArg, toInt64(info[0], exceptionState), exceptionState);
4612     impl->voidMethodLongLongArg(longLongArg);
4613 }
4614
4615 static void voidMethodLongLongArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
4616 {
4617     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4618     TestObjectPythonV8Internal::voidMethodLongLongArgMethod(info);
4619     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4620 }
4621
4622 static void voidMethodOctetArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
4623 {
4624     ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodOctetArg", "TestObjectPython", info.Holder(), info.GetIsolate());
4625     if (UNLIKELY(info.Length() < 1)) {
4626         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
4627         exceptionState.throwIfNeeded();
4628         return;
4629     }
4630     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
4631     V8TRYCATCH_EXCEPTION_VOID(unsigned, octetArg, toUInt8(info[0], exceptionState), exceptionState);
4632     impl->voidMethodOctetArg(octetArg);
4633 }
4634
4635 static void voidMethodOctetArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
4636 {
4637     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4638     TestObjectPythonV8Internal::voidMethodOctetArgMethod(info);
4639     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4640 }
4641
4642 static void voidMethodShortArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
4643 {
4644     ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodShortArg", "TestObjectPython", info.Holder(), info.GetIsolate());
4645     if (UNLIKELY(info.Length() < 1)) {
4646         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
4647         exceptionState.throwIfNeeded();
4648         return;
4649     }
4650     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
4651     V8TRYCATCH_EXCEPTION_VOID(int, shortArg, toInt16(info[0], exceptionState), exceptionState);
4652     impl->voidMethodShortArg(shortArg);
4653 }
4654
4655 static void voidMethodShortArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
4656 {
4657     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4658     TestObjectPythonV8Internal::voidMethodShortArgMethod(info);
4659     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4660 }
4661
4662 static void voidMethodUnsignedLongArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
4663 {
4664     ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodUnsignedLongArg", "TestObjectPython", info.Holder(), info.GetIsolate());
4665     if (UNLIKELY(info.Length() < 1)) {
4666         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
4667         exceptionState.throwIfNeeded();
4668         return;
4669     }
4670     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
4671     V8TRYCATCH_EXCEPTION_VOID(unsigned, unsignedLongArg, toUInt32(info[0], exceptionState), exceptionState);
4672     impl->voidMethodUnsignedLongArg(unsignedLongArg);
4673 }
4674
4675 static void voidMethodUnsignedLongArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
4676 {
4677     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4678     TestObjectPythonV8Internal::voidMethodUnsignedLongArgMethod(info);
4679     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4680 }
4681
4682 static void voidMethodUnsignedLongLongArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
4683 {
4684     ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodUnsignedLongLongArg", "TestObjectPython", info.Holder(), info.GetIsolate());
4685     if (UNLIKELY(info.Length() < 1)) {
4686         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
4687         exceptionState.throwIfNeeded();
4688         return;
4689     }
4690     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
4691     V8TRYCATCH_EXCEPTION_VOID(unsigned long long, unsignedLongLongArg, toUInt64(info[0], exceptionState), exceptionState);
4692     impl->voidMethodUnsignedLongLongArg(unsignedLongLongArg);
4693 }
4694
4695 static void voidMethodUnsignedLongLongArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
4696 {
4697     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4698     TestObjectPythonV8Internal::voidMethodUnsignedLongLongArgMethod(info);
4699     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4700 }
4701
4702 static void voidMethodUnsignedShortArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
4703 {
4704     ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodUnsignedShortArg", "TestObjectPython", info.Holder(), info.GetIsolate());
4705     if (UNLIKELY(info.Length() < 1)) {
4706         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
4707         exceptionState.throwIfNeeded();
4708         return;
4709     }
4710     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
4711     V8TRYCATCH_EXCEPTION_VOID(unsigned, unsignedShortArg, toUInt16(info[0], exceptionState), exceptionState);
4712     impl->voidMethodUnsignedShortArg(unsignedShortArg);
4713 }
4714
4715 static void voidMethodUnsignedShortArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
4716 {
4717     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4718     TestObjectPythonV8Internal::voidMethodUnsignedShortArgMethod(info);
4719     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4720 }
4721
4722 static void testInterfaceEmptyMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
4723 {
4724     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
4725     v8SetReturnValue(info, impl->testInterfaceEmptyMethod());
4726 }
4727
4728 static void testInterfaceEmptyMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
4729 {
4730     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4731     TestObjectPythonV8Internal::testInterfaceEmptyMethodMethod(info);
4732     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4733 }
4734
4735 static void voidMethodTestInterfaceEmptyArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
4736 {
4737     if (UNLIKELY(info.Length() < 1)) {
4738         throwTypeError(ExceptionMessages::failedToExecute("voidMethodTestInterfaceEmptyArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate());
4739         return;
4740     }
4741     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
4742     V8TRYCATCH_VOID(TestInterfaceEmpty*, testInterfaceEmptyArg, V8TestInterfaceEmpty::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
4743     impl->voidMethodTestInterfaceEmptyArg(testInterfaceEmptyArg);
4744 }
4745
4746 static void voidMethodTestInterfaceEmptyArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
4747 {
4748     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4749     TestObjectPythonV8Internal::voidMethodTestInterfaceEmptyArgMethod(info);
4750     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4751 }
4752
4753 static void voidMethodLongArgTestInterfaceEmptyArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
4754 {
4755     ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodLongArgTestInterfaceEmptyArg", "TestObjectPython", info.Holder(), info.GetIsolate());
4756     if (UNLIKELY(info.Length() < 2)) {
4757         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(2, info.Length()));
4758         exceptionState.throwIfNeeded();
4759         return;
4760     }
4761     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
4762     V8TRYCATCH_EXCEPTION_VOID(int, longArg, toInt32(info[0], exceptionState), exceptionState);
4763     V8TRYCATCH_VOID(TestInterfaceEmpty*, testInterfaceEmptyArg, V8TestInterfaceEmpty::toNativeWithTypeCheck(info.GetIsolate(), info[1]));
4764     impl->voidMethodLongArgTestInterfaceEmptyArg(longArg, testInterfaceEmptyArg);
4765 }
4766
4767 static void voidMethodLongArgTestInterfaceEmptyArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
4768 {
4769     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4770     TestObjectPythonV8Internal::voidMethodLongArgTestInterfaceEmptyArgMethod(info);
4771     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4772 }
4773
4774 static void voidCallbackFunctionMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
4775 {
4776     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
4777     v8SetReturnValue(info, impl->voidCallbackFunctionMethod().v8Value());
4778 }
4779
4780 static void voidCallbackFunctionMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
4781 {
4782     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4783     TestObjectPythonV8Internal::voidCallbackFunctionMethodMethod(info);
4784     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4785 }
4786
4787 static void anyCallbackFunctionOptionalAnyArgMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
4788 {
4789     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
4790     v8SetReturnValue(info, impl->anyCallbackFunctionOptionalAnyArgMethod().v8Value());
4791 }
4792
4793 static void anyCallbackFunctionOptionalAnyArgMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
4794 {
4795     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4796     TestObjectPythonV8Internal::anyCallbackFunctionOptionalAnyArgMethodMethod(info);
4797     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4798 }
4799
4800 static void voidMethodVoidCallbackFunctionArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
4801 {
4802     if (UNLIKELY(info.Length() < 1)) {
4803         throwTypeError(ExceptionMessages::failedToExecute("voidMethodVoidCallbackFunctionArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate());
4804         return;
4805     }
4806     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
4807     V8TRYCATCH_VOID(ScriptValue, voidCallbackFunctionArg, ScriptValue(info[0], info.GetIsolate()));
4808     impl->voidMethodVoidCallbackFunctionArg(voidCallbackFunctionArg);
4809 }
4810
4811 static void voidMethodVoidCallbackFunctionArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
4812 {
4813     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4814     TestObjectPythonV8Internal::voidMethodVoidCallbackFunctionArgMethod(info);
4815     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4816 }
4817
4818 static void voidMethodAnyCallbackFunctionOptionalAnyArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
4819 {
4820     if (UNLIKELY(info.Length() < 1)) {
4821         throwTypeError(ExceptionMessages::failedToExecute("voidMethodAnyCallbackFunctionOptionalAnyArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate());
4822         return;
4823     }
4824     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
4825     V8TRYCATCH_VOID(ScriptValue, anyCallbackFunctionOptionalAnyArgArg, ScriptValue(info[0], info.GetIsolate()));
4826     impl->voidMethodAnyCallbackFunctionOptionalAnyArg(anyCallbackFunctionOptionalAnyArgArg);
4827 }
4828
4829 static void voidMethodAnyCallbackFunctionOptionalAnyArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
4830 {
4831     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4832     TestObjectPythonV8Internal::voidMethodAnyCallbackFunctionOptionalAnyArgMethod(info);
4833     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4834 }
4835
4836 static void compareHowMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
4837 {
4838     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
4839     v8SetReturnValue(info, impl->compareHowMethod());
4840 }
4841
4842 static void compareHowMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
4843 {
4844     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4845     TestObjectPythonV8Internal::compareHowMethodMethod(info);
4846     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4847 }
4848
4849 static void anyMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
4850 {
4851     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
4852     v8SetReturnValue(info, impl->anyMethod().v8Value());
4853 }
4854
4855 static void anyMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
4856 {
4857     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4858     TestObjectPythonV8Internal::anyMethodMethod(info);
4859     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4860 }
4861
4862 static void voidMethodCompareHowArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
4863 {
4864     if (UNLIKELY(info.Length() < 1)) {
4865         throwTypeError(ExceptionMessages::failedToExecute("voidMethodCompareHowArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate());
4866         return;
4867     }
4868     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
4869     V8TRYCATCH_VOID(Range::CompareHow, compareHowArg, static_cast<Range::CompareHow>(info[0]->Int32Value()));
4870     impl->voidMethodCompareHowArg(compareHowArg);
4871 }
4872
4873 static void voidMethodCompareHowArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
4874 {
4875     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4876     TestObjectPythonV8Internal::voidMethodCompareHowArgMethod(info);
4877     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4878 }
4879
4880 static void voidMethodEventTargetArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
4881 {
4882     if (UNLIKELY(info.Length() < 1)) {
4883         throwTypeError(ExceptionMessages::failedToExecute("voidMethodEventTargetArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate());
4884         return;
4885     }
4886     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
4887     V8TRYCATCH_VOID(EventTarget*, eventTargetArg, V8DOMWrapper::isDOMWrapper(info[0]) ? toWrapperTypeInfo(v8::Handle<v8::Object>::Cast(info[0]))->toEventTarget(v8::Handle<v8::Object>::Cast(info[0])) : 0);
4888     impl->voidMethodEventTargetArg(eventTargetArg);
4889 }
4890
4891 static void voidMethodEventTargetArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
4892 {
4893     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4894     TestObjectPythonV8Internal::voidMethodEventTargetArgMethod(info);
4895     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4896 }
4897
4898 static void voidMethodMediaQueryListListenerArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
4899 {
4900     if (UNLIKELY(info.Length() < 1)) {
4901         throwTypeError(ExceptionMessages::failedToExecute("voidMethodMediaQueryListListenerArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate());
4902         return;
4903     }
4904     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
4905     V8TRYCATCH_VOID(RefPtrWillBeRawPtr<MediaQueryListListener>, mediaQueryListListenerArg, MediaQueryListListener::create(ScriptValue(info[0], info.GetIsolate())));
4906     impl->voidMethodMediaQueryListListenerArg(mediaQueryListListenerArg);
4907 }
4908
4909 static void voidMethodMediaQueryListListenerArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
4910 {
4911     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4912     TestObjectPythonV8Internal::voidMethodMediaQueryListListenerArgMethod(info);
4913     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4914 }
4915
4916 static void voidMethodAnyArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
4917 {
4918     if (UNLIKELY(info.Length() < 1)) {
4919         throwTypeError(ExceptionMessages::failedToExecute("voidMethodAnyArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate());
4920         return;
4921     }
4922     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
4923     V8TRYCATCH_VOID(ScriptValue, anyArg, ScriptValue(info[0], info.GetIsolate()));
4924     impl->voidMethodAnyArg(anyArg);
4925 }
4926
4927 static void voidMethodAnyArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
4928 {
4929     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4930     TestObjectPythonV8Internal::voidMethodAnyArgMethod(info);
4931     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4932 }
4933
4934 static void voidMethodAttrArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
4935 {
4936     if (UNLIKELY(info.Length() < 1)) {
4937         throwTypeError(ExceptionMessages::failedToExecute("voidMethodAttrArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate());
4938         return;
4939     }
4940     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
4941     V8TRYCATCH_VOID(Attr*, attrArg, V8Attr::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
4942     impl->voidMethodAttrArg(attrArg);
4943 }
4944
4945 static void voidMethodAttrArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
4946 {
4947     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4948     TestObjectPythonV8Internal::voidMethodAttrArgMethod(info);
4949     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4950 }
4951
4952 static void voidMethodDocumentArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
4953 {
4954     if (UNLIKELY(info.Length() < 1)) {
4955         throwTypeError(ExceptionMessages::failedToExecute("voidMethodDocumentArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate());
4956         return;
4957     }
4958     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
4959     V8TRYCATCH_VOID(Document*, documentArg, V8Document::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
4960     impl->voidMethodDocumentArg(documentArg);
4961 }
4962
4963 static void voidMethodDocumentArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
4964 {
4965     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4966     TestObjectPythonV8Internal::voidMethodDocumentArgMethod(info);
4967     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4968 }
4969
4970 static void voidMethodDocumentTypeArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
4971 {
4972     if (UNLIKELY(info.Length() < 1)) {
4973         throwTypeError(ExceptionMessages::failedToExecute("voidMethodDocumentTypeArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate());
4974         return;
4975     }
4976     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
4977     V8TRYCATCH_VOID(DocumentType*, documentTypeArg, V8DocumentType::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
4978     impl->voidMethodDocumentTypeArg(documentTypeArg);
4979 }
4980
4981 static void voidMethodDocumentTypeArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
4982 {
4983     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
4984     TestObjectPythonV8Internal::voidMethodDocumentTypeArgMethod(info);
4985     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
4986 }
4987
4988 static void voidMethodElementArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
4989 {
4990     if (UNLIKELY(info.Length() < 1)) {
4991         throwTypeError(ExceptionMessages::failedToExecute("voidMethodElementArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate());
4992         return;
4993     }
4994     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
4995     V8TRYCATCH_VOID(Element*, elementArg, V8Element::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
4996     impl->voidMethodElementArg(elementArg);
4997 }
4998
4999 static void voidMethodElementArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5000 {
5001     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5002     TestObjectPythonV8Internal::voidMethodElementArgMethod(info);
5003     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5004 }
5005
5006 static void voidMethodNodeArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5007 {
5008     if (UNLIKELY(info.Length() < 1)) {
5009         throwTypeError(ExceptionMessages::failedToExecute("voidMethodNodeArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate());
5010         return;
5011     }
5012     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
5013     V8TRYCATCH_VOID(Node*, nodeArg, V8Node::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
5014     impl->voidMethodNodeArg(nodeArg);
5015 }
5016
5017 static void voidMethodNodeArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5018 {
5019     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5020     TestObjectPythonV8Internal::voidMethodNodeArgMethod(info);
5021     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5022 }
5023
5024 static void arrayBufferMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5025 {
5026     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
5027     v8SetReturnValue(info, impl->arrayBufferMethod());
5028 }
5029
5030 static void arrayBufferMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5031 {
5032     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5033     TestObjectPythonV8Internal::arrayBufferMethodMethod(info);
5034     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5035 }
5036
5037 static void arrayBufferViewMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5038 {
5039     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
5040     v8SetReturnValue(info, impl->arrayBufferViewMethod());
5041 }
5042
5043 static void arrayBufferViewMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5044 {
5045     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5046     TestObjectPythonV8Internal::arrayBufferViewMethodMethod(info);
5047     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5048 }
5049
5050 static void float32ArrayMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5051 {
5052     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
5053     v8SetReturnValue(info, impl->float32ArrayMethod());
5054 }
5055
5056 static void float32ArrayMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5057 {
5058     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5059     TestObjectPythonV8Internal::float32ArrayMethodMethod(info);
5060     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5061 }
5062
5063 static void int32ArrayMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5064 {
5065     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
5066     v8SetReturnValue(info, impl->int32ArrayMethod());
5067 }
5068
5069 static void int32ArrayMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5070 {
5071     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5072     TestObjectPythonV8Internal::int32ArrayMethodMethod(info);
5073     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5074 }
5075
5076 static void uint8ArrayMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5077 {
5078     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
5079     v8SetReturnValue(info, impl->uint8ArrayMethod());
5080 }
5081
5082 static void uint8ArrayMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5083 {
5084     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5085     TestObjectPythonV8Internal::uint8ArrayMethodMethod(info);
5086     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5087 }
5088
5089 static void voidMethodArrayBufferArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5090 {
5091     if (UNLIKELY(info.Length() < 1)) {
5092         throwTypeError(ExceptionMessages::failedToExecute("voidMethodArrayBufferArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate());
5093         return;
5094     }
5095     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
5096     V8TRYCATCH_VOID(ArrayBuffer*, arrayBufferArg, info[0]->IsArrayBuffer() ? V8ArrayBuffer::toNative(v8::Handle<v8::ArrayBuffer>::Cast(info[0])) : 0);
5097     impl->voidMethodArrayBufferArg(arrayBufferArg);
5098 }
5099
5100 static void voidMethodArrayBufferArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5101 {
5102     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5103     TestObjectPythonV8Internal::voidMethodArrayBufferArgMethod(info);
5104     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5105 }
5106
5107 static void voidMethodArrayBufferOrNullArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5108 {
5109     if (UNLIKELY(info.Length() < 1)) {
5110         throwTypeError(ExceptionMessages::failedToExecute("voidMethodArrayBufferOrNullArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate());
5111         return;
5112     }
5113     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
5114     V8TRYCATCH_VOID(ArrayBuffer*, arrayBufferArg, info[0]->IsArrayBuffer() ? V8ArrayBuffer::toNative(v8::Handle<v8::ArrayBuffer>::Cast(info[0])) : 0);
5115     impl->voidMethodArrayBufferOrNullArg(arrayBufferArg);
5116 }
5117
5118 static void voidMethodArrayBufferOrNullArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5119 {
5120     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5121     TestObjectPythonV8Internal::voidMethodArrayBufferOrNullArgMethod(info);
5122     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5123 }
5124
5125 static void voidMethodArrayBufferViewArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5126 {
5127     if (UNLIKELY(info.Length() < 1)) {
5128         throwTypeError(ExceptionMessages::failedToExecute("voidMethodArrayBufferViewArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate());
5129         return;
5130     }
5131     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
5132     V8TRYCATCH_VOID(ArrayBufferView*, arrayBufferViewArg, info[0]->IsArrayBufferView() ? V8ArrayBufferView::toNative(v8::Handle<v8::ArrayBufferView>::Cast(info[0])) : 0);
5133     impl->voidMethodArrayBufferViewArg(arrayBufferViewArg);
5134 }
5135
5136 static void voidMethodArrayBufferViewArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5137 {
5138     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5139     TestObjectPythonV8Internal::voidMethodArrayBufferViewArgMethod(info);
5140     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5141 }
5142
5143 static void voidMethodFloat32ArrayArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5144 {
5145     if (UNLIKELY(info.Length() < 1)) {
5146         throwTypeError(ExceptionMessages::failedToExecute("voidMethodFloat32ArrayArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate());
5147         return;
5148     }
5149     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
5150     V8TRYCATCH_VOID(Float32Array*, float32ArrayArg, info[0]->IsFloat32Array() ? V8Float32Array::toNative(v8::Handle<v8::Float32Array>::Cast(info[0])) : 0);
5151     impl->voidMethodFloat32ArrayArg(float32ArrayArg);
5152 }
5153
5154 static void voidMethodFloat32ArrayArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5155 {
5156     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5157     TestObjectPythonV8Internal::voidMethodFloat32ArrayArgMethod(info);
5158     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5159 }
5160
5161 static void voidMethodInt32ArrayArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5162 {
5163     if (UNLIKELY(info.Length() < 1)) {
5164         throwTypeError(ExceptionMessages::failedToExecute("voidMethodInt32ArrayArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate());
5165         return;
5166     }
5167     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
5168     V8TRYCATCH_VOID(Int32Array*, int32ArrayArg, info[0]->IsInt32Array() ? V8Int32Array::toNative(v8::Handle<v8::Int32Array>::Cast(info[0])) : 0);
5169     impl->voidMethodInt32ArrayArg(int32ArrayArg);
5170 }
5171
5172 static void voidMethodInt32ArrayArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5173 {
5174     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5175     TestObjectPythonV8Internal::voidMethodInt32ArrayArgMethod(info);
5176     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5177 }
5178
5179 static void voidMethodUint8ArrayArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5180 {
5181     if (UNLIKELY(info.Length() < 1)) {
5182         throwTypeError(ExceptionMessages::failedToExecute("voidMethodUint8ArrayArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate());
5183         return;
5184     }
5185     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
5186     V8TRYCATCH_VOID(Uint8Array*, uint8ArrayArg, info[0]->IsUint8Array() ? V8Uint8Array::toNative(v8::Handle<v8::Uint8Array>::Cast(info[0])) : 0);
5187     impl->voidMethodUint8ArrayArg(uint8ArrayArg);
5188 }
5189
5190 static void voidMethodUint8ArrayArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5191 {
5192     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5193     TestObjectPythonV8Internal::voidMethodUint8ArrayArgMethod(info);
5194     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5195 }
5196
5197 static void longArrayMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5198 {
5199     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
5200     v8SetReturnValue(info, v8Array(impl->longArrayMethod(), info.GetIsolate()));
5201 }
5202
5203 static void longArrayMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5204 {
5205     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5206     TestObjectPythonV8Internal::longArrayMethodMethod(info);
5207     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5208 }
5209
5210 static void stringArrayMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5211 {
5212     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
5213     v8SetReturnValue(info, v8Array(impl->stringArrayMethod(), info.GetIsolate()));
5214 }
5215
5216 static void stringArrayMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5217 {
5218     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5219     TestObjectPythonV8Internal::stringArrayMethodMethod(info);
5220     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5221 }
5222
5223 static void testInterfaceEmptyArrayMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5224 {
5225     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
5226     v8SetReturnValue(info, v8Array(impl->testInterfaceEmptyArrayMethod(), info.GetIsolate()));
5227 }
5228
5229 static void testInterfaceEmptyArrayMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5230 {
5231     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5232     TestObjectPythonV8Internal::testInterfaceEmptyArrayMethodMethod(info);
5233     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5234 }
5235
5236 static void voidMethodArrayLongArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5237 {
5238     if (UNLIKELY(info.Length() < 1)) {
5239         throwTypeError(ExceptionMessages::failedToExecute("voidMethodArrayLongArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate());
5240         return;
5241     }
5242     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
5243     V8TRYCATCH_VOID(Vector<int>, arrayLongArg, toNativeArray<int>(info[0], 1, info.GetIsolate()));
5244     impl->voidMethodArrayLongArg(arrayLongArg);
5245 }
5246
5247 static void voidMethodArrayLongArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5248 {
5249     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5250     TestObjectPythonV8Internal::voidMethodArrayLongArgMethod(info);
5251     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5252 }
5253
5254 static void voidMethodArrayStringArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5255 {
5256     if (UNLIKELY(info.Length() < 1)) {
5257         throwTypeError(ExceptionMessages::failedToExecute("voidMethodArrayStringArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate());
5258         return;
5259     }
5260     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
5261     V8TRYCATCH_VOID(Vector<String>, arrayStringArg, toNativeArray<String>(info[0], 1, info.GetIsolate()));
5262     impl->voidMethodArrayStringArg(arrayStringArg);
5263 }
5264
5265 static void voidMethodArrayStringArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5266 {
5267     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5268     TestObjectPythonV8Internal::voidMethodArrayStringArgMethod(info);
5269     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5270 }
5271
5272 static void voidMethodArrayTestInterfaceEmptyArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5273 {
5274     if (UNLIKELY(info.Length() < 1)) {
5275         throwTypeError(ExceptionMessages::failedToExecute("voidMethodArrayTestInterfaceEmptyArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate());
5276         return;
5277     }
5278     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
5279     V8TRYCATCH_VOID(Vector<RefPtr<TestInterfaceEmpty> >, arrayTestInterfaceEmptyArg, (toRefPtrNativeArray<TestInterfaceEmpty, V8TestInterfaceEmpty>(info[0], 1, info.GetIsolate())));
5280     impl->voidMethodArrayTestInterfaceEmptyArg(arrayTestInterfaceEmptyArg);
5281 }
5282
5283 static void voidMethodArrayTestInterfaceEmptyArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5284 {
5285     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5286     TestObjectPythonV8Internal::voidMethodArrayTestInterfaceEmptyArgMethod(info);
5287     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5288 }
5289
5290 static void longSequenceMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5291 {
5292     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
5293     v8SetReturnValue(info, v8Array(impl->longSequenceMethod(), info.GetIsolate()));
5294 }
5295
5296 static void longSequenceMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5297 {
5298     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5299     TestObjectPythonV8Internal::longSequenceMethodMethod(info);
5300     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5301 }
5302
5303 static void stringSequenceMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5304 {
5305     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
5306     v8SetReturnValue(info, v8Array(impl->stringSequenceMethod(), info.GetIsolate()));
5307 }
5308
5309 static void stringSequenceMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5310 {
5311     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5312     TestObjectPythonV8Internal::stringSequenceMethodMethod(info);
5313     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5314 }
5315
5316 static void testInterfaceEmptySequenceMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5317 {
5318     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
5319     v8SetReturnValue(info, v8Array(impl->testInterfaceEmptySequenceMethod(), info.GetIsolate()));
5320 }
5321
5322 static void testInterfaceEmptySequenceMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5323 {
5324     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5325     TestObjectPythonV8Internal::testInterfaceEmptySequenceMethodMethod(info);
5326     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5327 }
5328
5329 static void voidMethodSequenceLongArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5330 {
5331     if (UNLIKELY(info.Length() < 1)) {
5332         throwTypeError(ExceptionMessages::failedToExecute("voidMethodSequenceLongArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate());
5333         return;
5334     }
5335     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
5336     V8TRYCATCH_VOID(Vector<int>, longSequenceArg, toNativeArray<int>(info[0], 1, info.GetIsolate()));
5337     impl->voidMethodSequenceLongArg(longSequenceArg);
5338 }
5339
5340 static void voidMethodSequenceLongArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5341 {
5342     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5343     TestObjectPythonV8Internal::voidMethodSequenceLongArgMethod(info);
5344     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5345 }
5346
5347 static void voidMethodSequenceStringArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5348 {
5349     if (UNLIKELY(info.Length() < 1)) {
5350         throwTypeError(ExceptionMessages::failedToExecute("voidMethodSequenceStringArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate());
5351         return;
5352     }
5353     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
5354     V8TRYCATCH_VOID(Vector<String>, stringSequenceArg, toNativeArray<String>(info[0], 1, info.GetIsolate()));
5355     impl->voidMethodSequenceStringArg(stringSequenceArg);
5356 }
5357
5358 static void voidMethodSequenceStringArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5359 {
5360     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5361     TestObjectPythonV8Internal::voidMethodSequenceStringArgMethod(info);
5362     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5363 }
5364
5365 static void voidMethodSequenceTestInterfaceEmptyArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5366 {
5367     if (UNLIKELY(info.Length() < 1)) {
5368         throwTypeError(ExceptionMessages::failedToExecute("voidMethodSequenceTestInterfaceEmptyArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate());
5369         return;
5370     }
5371     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
5372     V8TRYCATCH_VOID(Vector<RefPtr<TestInterfaceEmpty> >, testInterfaceEmptySequenceArg, (toRefPtrNativeArray<TestInterfaceEmpty, V8TestInterfaceEmpty>(info[0], 1, info.GetIsolate())));
5373     impl->voidMethodSequenceTestInterfaceEmptyArg(testInterfaceEmptySequenceArg);
5374 }
5375
5376 static void voidMethodSequenceTestInterfaceEmptyArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5377 {
5378     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5379     TestObjectPythonV8Internal::voidMethodSequenceTestInterfaceEmptyArgMethod(info);
5380     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5381 }
5382
5383 static void voidMethodTestInterfaceEmptyOrNullArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5384 {
5385     if (UNLIKELY(info.Length() < 1)) {
5386         throwTypeError(ExceptionMessages::failedToExecute("voidMethodTestInterfaceEmptyOrNullArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate());
5387         return;
5388     }
5389     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
5390     V8TRYCATCH_VOID(TestInterfaceEmpty*, nullableTestInterfaceEmptyArg, V8TestInterfaceEmpty::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
5391     impl->voidMethodTestInterfaceEmptyOrNullArg(nullableTestInterfaceEmptyArg);
5392 }
5393
5394 static void voidMethodTestInterfaceEmptyOrNullArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5395 {
5396     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5397     TestObjectPythonV8Internal::voidMethodTestInterfaceEmptyOrNullArgMethod(info);
5398     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5399 }
5400
5401 static void voidMethodTestCallbackInterfaceArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5402 {
5403     if (UNLIKELY(info.Length() < 1)) {
5404         throwTypeError(ExceptionMessages::failedToExecute("voidMethodTestCallbackInterfaceArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate());
5405         return;
5406     }
5407     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
5408     if (info.Length() <= 0 || !info[0]->IsFunction()) {
5409         throwTypeError(ExceptionMessages::failedToExecute("voidMethodTestCallbackInterfaceArg", "TestObjectPython", "The callback provided as parameter 1 is not a function."), info.GetIsolate());
5410         return;
5411     }
5412     OwnPtr<TestCallbackInterface> testCallbackInterfaceArg = V8TestCallbackInterface::create(v8::Handle<v8::Function>::Cast(info[0]), currentExecutionContext(info.GetIsolate()));
5413     impl->voidMethodTestCallbackInterfaceArg(testCallbackInterfaceArg.release());
5414 }
5415
5416 static void voidMethodTestCallbackInterfaceArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5417 {
5418     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5419     TestObjectPythonV8Internal::voidMethodTestCallbackInterfaceArgMethod(info);
5420     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5421 }
5422
5423 static void voidMethodOptionalTestCallbackInterfaceArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5424 {
5425     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
5426     OwnPtr<TestCallbackInterface> optionalTestCallbackInterfaceArg;
5427     if (info.Length() > 0 && !isUndefinedOrNull(info[0])) {
5428         if (!info[0]->IsFunction()) {
5429             throwTypeError(ExceptionMessages::failedToExecute("voidMethodOptionalTestCallbackInterfaceArg", "TestObjectPython", "The callback provided as parameter 1 is not a function."), info.GetIsolate());
5430             return;
5431         }
5432         optionalTestCallbackInterfaceArg = V8TestCallbackInterface::create(v8::Handle<v8::Function>::Cast(info[0]), currentExecutionContext(info.GetIsolate()));
5433     }
5434     impl->voidMethodOptionalTestCallbackInterfaceArg(optionalTestCallbackInterfaceArg.release());
5435 }
5436
5437 static void voidMethodOptionalTestCallbackInterfaceArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5438 {
5439     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5440     TestObjectPythonV8Internal::voidMethodOptionalTestCallbackInterfaceArgMethod(info);
5441     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5442 }
5443
5444 static void voidMethodTestCallbackInterfaceOrNullArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5445 {
5446     if (UNLIKELY(info.Length() < 1)) {
5447         throwTypeError(ExceptionMessages::failedToExecute("voidMethodTestCallbackInterfaceOrNullArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate());
5448         return;
5449     }
5450     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
5451     if (info.Length() <= 0 || !(info[0]->IsFunction() || info[0]->IsNull())) {
5452         throwTypeError(ExceptionMessages::failedToExecute("voidMethodTestCallbackInterfaceOrNullArg", "TestObjectPython", "The callback provided as parameter 1 is not a function."), info.GetIsolate());
5453         return;
5454     }
5455     OwnPtr<TestCallbackInterface> testCallbackInterfaceArg = info[0]->IsNull() ? nullptr : V8TestCallbackInterface::create(v8::Handle<v8::Function>::Cast(info[0]), currentExecutionContext(info.GetIsolate()));
5456     impl->voidMethodTestCallbackInterfaceOrNullArg(testCallbackInterfaceArg.release());
5457 }
5458
5459 static void voidMethodTestCallbackInterfaceOrNullArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5460 {
5461     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5462     TestObjectPythonV8Internal::voidMethodTestCallbackInterfaceOrNullArgMethod(info);
5463     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5464 }
5465
5466 static void testEnumMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5467 {
5468     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
5469     v8SetReturnValueString(info, impl->testEnumMethod(), info.GetIsolate());
5470 }
5471
5472 static void testEnumMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5473 {
5474     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5475     TestObjectPythonV8Internal::testEnumMethodMethod(info);
5476     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5477 }
5478
5479 static void voidMethodTestEnumArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5480 {
5481     if (UNLIKELY(info.Length() < 1)) {
5482         throwTypeError(ExceptionMessages::failedToExecute("voidMethodTestEnumArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate());
5483         return;
5484     }
5485     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
5486     V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, testEnumTypeArg, info[0]);
5487     String string = testEnumTypeArg;
5488     if (!(string == "" || string == "EnumValue1" || string == "EnumValue2" || string == "EnumValue3")) {
5489         throwTypeError(ExceptionMessages::failedToExecute("voidMethodTestEnumArg", "TestObjectPython", "parameter 1 ('" + string + "') is not a valid enum value."), info.GetIsolate());
5490         return;
5491     }
5492     impl->voidMethodTestEnumArg(testEnumTypeArg);
5493 }
5494
5495 static void voidMethodTestEnumArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5496 {
5497     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5498     TestObjectPythonV8Internal::voidMethodTestEnumArgMethod(info);
5499     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5500 }
5501
5502 static void dictionaryMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5503 {
5504     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
5505     v8SetReturnValue(info, impl->dictionaryMethod());
5506 }
5507
5508 static void dictionaryMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5509 {
5510     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5511     TestObjectPythonV8Internal::dictionaryMethodMethod(info);
5512     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5513 }
5514
5515 static void nodeFilterMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5516 {
5517     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
5518     v8SetReturnValue(info, impl->nodeFilterMethod());
5519 }
5520
5521 static void nodeFilterMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5522 {
5523     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5524     TestObjectPythonV8Internal::nodeFilterMethodMethod(info);
5525     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5526 }
5527
5528 static void promiseMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5529 {
5530     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
5531     v8SetReturnValue(info, impl->promiseMethod().v8Value());
5532 }
5533
5534 static void promiseMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5535 {
5536     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5537     TestObjectPythonV8Internal::promiseMethodMethod(info);
5538     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5539 }
5540
5541 static void serializedScriptValueMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5542 {
5543     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
5544     v8SetReturnValue(info, impl->serializedScriptValueMethod() ? impl->serializedScriptValueMethod()->deserialize() : v8::Handle<v8::Value>(v8::Null(info.GetIsolate())));
5545 }
5546
5547 static void serializedScriptValueMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5548 {
5549     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5550     TestObjectPythonV8Internal::serializedScriptValueMethodMethod(info);
5551     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5552 }
5553
5554 static void xPathNSResolverMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5555 {
5556     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
5557     v8SetReturnValue(info, impl->xPathNSResolverMethod());
5558 }
5559
5560 static void xPathNSResolverMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5561 {
5562     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5563     TestObjectPythonV8Internal::xPathNSResolverMethodMethod(info);
5564     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5565 }
5566
5567 static void voidMethodDictionaryArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5568 {
5569     if (UNLIKELY(info.Length() < 1)) {
5570         throwTypeError(ExceptionMessages::failedToExecute("voidMethodDictionaryArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate());
5571         return;
5572     }
5573     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
5574     V8TRYCATCH_VOID(Dictionary, dictionaryArg, Dictionary(info[0], info.GetIsolate()));
5575     if (!dictionaryArg.isUndefinedOrNull() && !dictionaryArg.isObject()) {
5576         throwTypeError(ExceptionMessages::failedToExecute("voidMethodDictionaryArg", "TestObjectPython", "parameter 1 ('dictionaryArg') is not an object."), info.GetIsolate());
5577         return;
5578     }
5579     impl->voidMethodDictionaryArg(dictionaryArg);
5580 }
5581
5582 static void voidMethodDictionaryArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5583 {
5584     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5585     TestObjectPythonV8Internal::voidMethodDictionaryArgMethod(info);
5586     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5587 }
5588
5589 static void voidMethodEventListenerArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5590 {
5591     ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodEventListenerArg", "TestObjectPython", info.Holder(), info.GetIsolate());
5592     if (UNLIKELY(info.Length() < 1)) {
5593         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
5594         exceptionState.throwIfNeeded();
5595         return;
5596     }
5597     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
5598     RefPtr<EventListener> eventListenerArg = V8EventListenerList::getEventListener(info[1], false, ListenerFindOrCreate);
5599     impl->voidMethodEventListenerArg(eventListenerArg);
5600     if (listener && !impl->toNode())
5601         removeHiddenValueFromArray(info.Holder(), info[1], V8TestObjectPython::eventListenerCacheIndex, info.GetIsolate());
5602 }
5603
5604 static void voidMethodEventListenerArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5605 {
5606     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5607     TestObjectPythonV8Internal::voidMethodEventListenerArgMethod(info);
5608     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5609 }
5610
5611 static void voidMethodNodeFilterArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5612 {
5613     if (UNLIKELY(info.Length() < 1)) {
5614         throwTypeError(ExceptionMessages::failedToExecute("voidMethodNodeFilterArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate());
5615         return;
5616     }
5617     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
5618     V8TRYCATCH_VOID(RefPtr<NodeFilter>, nodeFilterArg, toNodeFilter(info[0], info.GetIsolate()));
5619     impl->voidMethodNodeFilterArg(nodeFilterArg.release());
5620 }
5621
5622 static void voidMethodNodeFilterArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5623 {
5624     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5625     TestObjectPythonV8Internal::voidMethodNodeFilterArgMethod(info);
5626     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5627 }
5628
5629 static void voidMethodPromiseArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5630 {
5631     if (UNLIKELY(info.Length() < 1)) {
5632         throwTypeError(ExceptionMessages::failedToExecute("voidMethodPromiseArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate());
5633         return;
5634     }
5635     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
5636     V8TRYCATCH_VOID(ScriptPromise, promiseArg, ScriptPromise(info[0], info.GetIsolate()));
5637     if (!promiseArg.isUndefinedOrNull() && !promiseArg.isObject()) {
5638         throwTypeError(ExceptionMessages::failedToExecute("voidMethodPromiseArg", "TestObjectPython", "parameter 1 ('promiseArg') is not an object."), info.GetIsolate());
5639         return;
5640     }
5641     impl->voidMethodPromiseArg(promiseArg);
5642 }
5643
5644 static void voidMethodPromiseArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5645 {
5646     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5647     TestObjectPythonV8Internal::voidMethodPromiseArgMethod(info);
5648     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5649 }
5650
5651 static void voidMethodSerializedScriptValueArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5652 {
5653     ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodSerializedScriptValueArg", "TestObjectPython", info.Holder(), info.GetIsolate());
5654     if (UNLIKELY(info.Length() < 1)) {
5655         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
5656         exceptionState.throwIfNeeded();
5657         return;
5658     }
5659     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
5660     RefPtr<SerializedScriptValue> serializedScriptValueArg = SerializedScriptValue::create(info[0], 0, 0, exceptionState, info.GetIsolate());
5661     if (exceptionState.throwIfNeeded())
5662         return;
5663     impl->voidMethodSerializedScriptValueArg(serializedScriptValueArg);
5664 }
5665
5666 static void voidMethodSerializedScriptValueArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5667 {
5668     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5669     TestObjectPythonV8Internal::voidMethodSerializedScriptValueArgMethod(info);
5670     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5671 }
5672
5673 static void voidMethodXPathNSResolverArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5674 {
5675     if (UNLIKELY(info.Length() < 1)) {
5676         throwTypeError(ExceptionMessages::failedToExecute("voidMethodXPathNSResolverArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate());
5677         return;
5678     }
5679     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
5680     V8TRYCATCH_VOID(RefPtrWillBeRawPtr<XPathNSResolver>, xPathNSResolverArg, toXPathNSResolver(info[0], info.GetIsolate()));
5681     impl->voidMethodXPathNSResolverArg(xPathNSResolverArg.release());
5682 }
5683
5684 static void voidMethodXPathNSResolverArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5685 {
5686     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5687     TestObjectPythonV8Internal::voidMethodXPathNSResolverArgMethod(info);
5688     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5689 }
5690
5691 static void voidMethodSequenceDictionaryArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5692 {
5693     if (UNLIKELY(info.Length() < 1)) {
5694         throwTypeError(ExceptionMessages::failedToExecute("voidMethodSequenceDictionaryArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate());
5695         return;
5696     }
5697     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
5698     V8TRYCATCH_VOID(Vector<Dictionary>, dictionarySequenceArg, toNativeArray<Dictionary>(info[0], 1, info.GetIsolate()));
5699     impl->voidMethodSequenceDictionaryArg(dictionarySequenceArg);
5700 }
5701
5702 static void voidMethodSequenceDictionaryArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5703 {
5704     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5705     TestObjectPythonV8Internal::voidMethodSequenceDictionaryArgMethod(info);
5706     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5707 }
5708
5709 static void voidMethodStringArgLongArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5710 {
5711     ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodStringArgLongArg", "TestObjectPython", info.Holder(), info.GetIsolate());
5712     if (UNLIKELY(info.Length() < 2)) {
5713         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(2, info.Length()));
5714         exceptionState.throwIfNeeded();
5715         return;
5716     }
5717     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
5718     V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, stringArg, info[0]);
5719     V8TRYCATCH_EXCEPTION_VOID(int, longArg, toInt32(info[1], exceptionState), exceptionState);
5720     impl->voidMethodStringArgLongArg(stringArg, longArg);
5721 }
5722
5723 static void voidMethodStringArgLongArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5724 {
5725     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5726     TestObjectPythonV8Internal::voidMethodStringArgLongArgMethod(info);
5727     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5728 }
5729
5730 static void voidMethodOptionalStringArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5731 {
5732     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
5733     if (UNLIKELY(info.Length() <= 0)) {
5734         impl->voidMethodOptionalStringArg();
5735         return;
5736     }
5737     V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, optionalStringArg, info[0]);
5738     impl->voidMethodOptionalStringArg(optionalStringArg);
5739 }
5740
5741 static void voidMethodOptionalStringArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5742 {
5743     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5744     TestObjectPythonV8Internal::voidMethodOptionalStringArgMethod(info);
5745     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5746 }
5747
5748 static void voidMethodOptionalTestInterfaceEmptyArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5749 {
5750     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
5751     if (UNLIKELY(info.Length() <= 0)) {
5752         impl->voidMethodOptionalTestInterfaceEmptyArg();
5753         return;
5754     }
5755     V8TRYCATCH_VOID(TestInterfaceEmpty*, optionalTestInterfaceEmptyArg, V8TestInterfaceEmpty::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
5756     impl->voidMethodOptionalTestInterfaceEmptyArg(optionalTestInterfaceEmptyArg);
5757 }
5758
5759 static void voidMethodOptionalTestInterfaceEmptyArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5760 {
5761     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5762     TestObjectPythonV8Internal::voidMethodOptionalTestInterfaceEmptyArgMethod(info);
5763     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5764 }
5765
5766 static void voidMethodOptionalLongArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5767 {
5768     ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodOptionalLongArg", "TestObjectPython", info.Holder(), info.GetIsolate());
5769     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
5770     if (UNLIKELY(info.Length() <= 0)) {
5771         impl->voidMethodOptionalLongArg();
5772         return;
5773     }
5774     V8TRYCATCH_EXCEPTION_VOID(int, optionalLongArg, toInt32(info[0], exceptionState), exceptionState);
5775     impl->voidMethodOptionalLongArg(optionalLongArg);
5776 }
5777
5778 static void voidMethodOptionalLongArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5779 {
5780     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5781     TestObjectPythonV8Internal::voidMethodOptionalLongArgMethod(info);
5782     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5783 }
5784
5785 static void stringMethodOptionalLongArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5786 {
5787     ExceptionState exceptionState(ExceptionState::ExecutionContext, "stringMethodOptionalLongArg", "TestObjectPython", info.Holder(), info.GetIsolate());
5788     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
5789     if (UNLIKELY(info.Length() <= 0)) {
5790         v8SetReturnValueString(info, impl->stringMethodOptionalLongArg(), info.GetIsolate());
5791         return;
5792     }
5793     V8TRYCATCH_EXCEPTION_VOID(int, optionalLongArg, toInt32(info[0], exceptionState), exceptionState);
5794     v8SetReturnValueString(info, impl->stringMethodOptionalLongArg(optionalLongArg), info.GetIsolate());
5795 }
5796
5797 static void stringMethodOptionalLongArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5798 {
5799     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5800     TestObjectPythonV8Internal::stringMethodOptionalLongArgMethod(info);
5801     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5802 }
5803
5804 static void testInterfaceEmptyMethodOptionalLongArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5805 {
5806     ExceptionState exceptionState(ExceptionState::ExecutionContext, "testInterfaceEmptyMethodOptionalLongArg", "TestObjectPython", info.Holder(), info.GetIsolate());
5807     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
5808     if (UNLIKELY(info.Length() <= 0)) {
5809         v8SetReturnValue(info, impl->testInterfaceEmptyMethodOptionalLongArg());
5810         return;
5811     }
5812     V8TRYCATCH_EXCEPTION_VOID(int, optionalLongArg, toInt32(info[0], exceptionState), exceptionState);
5813     v8SetReturnValue(info, impl->testInterfaceEmptyMethodOptionalLongArg(optionalLongArg));
5814 }
5815
5816 static void testInterfaceEmptyMethodOptionalLongArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5817 {
5818     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5819     TestObjectPythonV8Internal::testInterfaceEmptyMethodOptionalLongArgMethod(info);
5820     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5821 }
5822
5823 static void longMethodOptionalLongArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5824 {
5825     ExceptionState exceptionState(ExceptionState::ExecutionContext, "longMethodOptionalLongArg", "TestObjectPython", info.Holder(), info.GetIsolate());
5826     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
5827     if (UNLIKELY(info.Length() <= 0)) {
5828         v8SetReturnValueInt(info, impl->longMethodOptionalLongArg());
5829         return;
5830     }
5831     V8TRYCATCH_EXCEPTION_VOID(int, optionalLongArg, toInt32(info[0], exceptionState), exceptionState);
5832     v8SetReturnValueInt(info, impl->longMethodOptionalLongArg(optionalLongArg));
5833 }
5834
5835 static void longMethodOptionalLongArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5836 {
5837     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5838     TestObjectPythonV8Internal::longMethodOptionalLongArgMethod(info);
5839     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5840 }
5841
5842 static void voidMethodLongArgOptionalLongArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5843 {
5844     ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodLongArgOptionalLongArg", "TestObjectPython", info.Holder(), info.GetIsolate());
5845     if (UNLIKELY(info.Length() < 1)) {
5846         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
5847         exceptionState.throwIfNeeded();
5848         return;
5849     }
5850     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
5851     V8TRYCATCH_EXCEPTION_VOID(int, longArg, toInt32(info[0], exceptionState), exceptionState);
5852     if (UNLIKELY(info.Length() <= 1)) {
5853         impl->voidMethodLongArgOptionalLongArg(longArg);
5854         return;
5855     }
5856     V8TRYCATCH_EXCEPTION_VOID(int, optionalLongArg, toInt32(info[1], exceptionState), exceptionState);
5857     impl->voidMethodLongArgOptionalLongArg(longArg, optionalLongArg);
5858 }
5859
5860 static void voidMethodLongArgOptionalLongArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5861 {
5862     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5863     TestObjectPythonV8Internal::voidMethodLongArgOptionalLongArgMethod(info);
5864     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5865 }
5866
5867 static void voidMethodLongArgOptionalLongArgOptionalLongArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5868 {
5869     ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodLongArgOptionalLongArgOptionalLongArg", "TestObjectPython", info.Holder(), info.GetIsolate());
5870     if (UNLIKELY(info.Length() < 1)) {
5871         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
5872         exceptionState.throwIfNeeded();
5873         return;
5874     }
5875     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
5876     V8TRYCATCH_EXCEPTION_VOID(int, longArg, toInt32(info[0], exceptionState), exceptionState);
5877     if (UNLIKELY(info.Length() <= 1)) {
5878         impl->voidMethodLongArgOptionalLongArgOptionalLongArg(longArg);
5879         return;
5880     }
5881     V8TRYCATCH_EXCEPTION_VOID(int, optionalLongArg1, toInt32(info[1], exceptionState), exceptionState);
5882     if (UNLIKELY(info.Length() <= 2)) {
5883         impl->voidMethodLongArgOptionalLongArgOptionalLongArg(longArg, optionalLongArg1);
5884         return;
5885     }
5886     V8TRYCATCH_EXCEPTION_VOID(int, optionalLongArg2, toInt32(info[2], exceptionState), exceptionState);
5887     impl->voidMethodLongArgOptionalLongArgOptionalLongArg(longArg, optionalLongArg1, optionalLongArg2);
5888 }
5889
5890 static void voidMethodLongArgOptionalLongArgOptionalLongArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5891 {
5892     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5893     TestObjectPythonV8Internal::voidMethodLongArgOptionalLongArgOptionalLongArgMethod(info);
5894     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5895 }
5896
5897 static void voidMethodLongArgOptionalTestInterfaceEmptyArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5898 {
5899     ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodLongArgOptionalTestInterfaceEmptyArg", "TestObjectPython", info.Holder(), info.GetIsolate());
5900     if (UNLIKELY(info.Length() < 1)) {
5901         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
5902         exceptionState.throwIfNeeded();
5903         return;
5904     }
5905     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
5906     V8TRYCATCH_EXCEPTION_VOID(int, longArg, toInt32(info[0], exceptionState), exceptionState);
5907     if (UNLIKELY(info.Length() <= 1)) {
5908         impl->voidMethodLongArgOptionalTestInterfaceEmptyArg(longArg);
5909         return;
5910     }
5911     V8TRYCATCH_VOID(TestInterfaceEmpty*, optionalTestInterfaceEmpty, V8TestInterfaceEmpty::toNativeWithTypeCheck(info.GetIsolate(), info[1]));
5912     impl->voidMethodLongArgOptionalTestInterfaceEmptyArg(longArg, optionalTestInterfaceEmpty);
5913 }
5914
5915 static void voidMethodLongArgOptionalTestInterfaceEmptyArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5916 {
5917     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5918     TestObjectPythonV8Internal::voidMethodLongArgOptionalTestInterfaceEmptyArgMethod(info);
5919     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5920 }
5921
5922 static void voidMethodTestInterfaceEmptyArgOptionalLongArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5923 {
5924     ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodTestInterfaceEmptyArgOptionalLongArg", "TestObjectPython", info.Holder(), info.GetIsolate());
5925     if (UNLIKELY(info.Length() < 1)) {
5926         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
5927         exceptionState.throwIfNeeded();
5928         return;
5929     }
5930     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
5931     V8TRYCATCH_VOID(TestInterfaceEmpty*, optionalTestInterfaceEmpty, V8TestInterfaceEmpty::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
5932     if (UNLIKELY(info.Length() <= 1)) {
5933         impl->voidMethodTestInterfaceEmptyArgOptionalLongArg(optionalTestInterfaceEmpty);
5934         return;
5935     }
5936     V8TRYCATCH_EXCEPTION_VOID(int, longArg, toInt32(info[1], exceptionState), exceptionState);
5937     impl->voidMethodTestInterfaceEmptyArgOptionalLongArg(optionalTestInterfaceEmpty, longArg);
5938 }
5939
5940 static void voidMethodTestInterfaceEmptyArgOptionalLongArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5941 {
5942     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5943     TestObjectPythonV8Internal::voidMethodTestInterfaceEmptyArgOptionalLongArgMethod(info);
5944     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5945 }
5946
5947 static void voidMethodOptionalDictionaryArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5948 {
5949     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
5950     V8TRYCATCH_VOID(Dictionary, optionalDictionaryArg, Dictionary(info[0], info.GetIsolate()));
5951     if (!optionalDictionaryArg.isUndefinedOrNull() && !optionalDictionaryArg.isObject()) {
5952         throwTypeError(ExceptionMessages::failedToExecute("voidMethodOptionalDictionaryArg", "TestObjectPython", "parameter 1 ('optionalDictionaryArg') is not an object."), info.GetIsolate());
5953         return;
5954     }
5955     impl->voidMethodOptionalDictionaryArg(optionalDictionaryArg);
5956 }
5957
5958 static void voidMethodOptionalDictionaryArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5959 {
5960     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5961     TestObjectPythonV8Internal::voidMethodOptionalDictionaryArgMethod(info);
5962     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5963 }
5964
5965 static void voidMethodVariadicStringArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5966 {
5967     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
5968     V8TRYCATCH_VOID(Vector<String>, variadicStringArgs, toNativeArguments<String>(info, 0));
5969     impl->voidMethodVariadicStringArg(variadicStringArgs);
5970 }
5971
5972 static void voidMethodVariadicStringArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5973 {
5974     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5975     TestObjectPythonV8Internal::voidMethodVariadicStringArgMethod(info);
5976     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5977 }
5978
5979 static void voidMethodStringArgVariadicStringArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5980 {
5981     if (UNLIKELY(info.Length() < 1)) {
5982         throwTypeError(ExceptionMessages::failedToExecute("voidMethodStringArgVariadicStringArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate());
5983         return;
5984     }
5985     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
5986     V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, stringArg, info[0]);
5987     V8TRYCATCH_VOID(Vector<String>, variadicStringArgs, toNativeArguments<String>(info, 1));
5988     impl->voidMethodStringArgVariadicStringArg(stringArg, variadicStringArgs);
5989 }
5990
5991 static void voidMethodStringArgVariadicStringArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
5992 {
5993     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
5994     TestObjectPythonV8Internal::voidMethodStringArgVariadicStringArgMethod(info);
5995     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
5996 }
5997
5998 static void voidMethodVariadicTestInterfaceEmptyArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
5999 {
6000     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
6001     Vector<RefPtr<TestInterfaceEmpty> > variadicTestInterfaceEmptyArgs;
6002     for (int i = 0; i < info.Length(); ++i) {
6003         if (!V8TestInterfaceEmpty::hasInstance(info[i], info.GetIsolate())) {
6004             throwTypeError(ExceptionMessages::failedToExecute("voidMethodVariadicTestInterfaceEmptyArg", "TestObjectPython", "parameter 1 is not of type 'TestInterfaceEmpty'."), info.GetIsolate());
6005             return;
6006         }
6007         variadicTestInterfaceEmptyArgs.append(V8TestInterfaceEmpty::toNative(v8::Handle<v8::Object>::Cast(info[i])));
6008     }
6009     impl->voidMethodVariadicTestInterfaceEmptyArg(variadicTestInterfaceEmptyArgs);
6010 }
6011
6012 static void voidMethodVariadicTestInterfaceEmptyArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
6013 {
6014     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
6015     TestObjectPythonV8Internal::voidMethodVariadicTestInterfaceEmptyArgMethod(info);
6016     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
6017 }
6018
6019 static void voidMethodTestInterfaceEmptyArgVariadicTestInterfaceEmptyArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
6020 {
6021     if (UNLIKELY(info.Length() < 1)) {
6022         throwTypeError(ExceptionMessages::failedToExecute("voidMethodTestInterfaceEmptyArgVariadicTestInterfaceEmptyArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate());
6023         return;
6024     }
6025     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
6026     V8TRYCATCH_VOID(TestInterfaceEmpty*, testInterfaceEmptyArg, V8TestInterfaceEmpty::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
6027     Vector<RefPtr<TestInterfaceEmpty> > variadicTestInterfaceEmptyArgs;
6028     for (int i = 1; i < info.Length(); ++i) {
6029         if (!V8TestInterfaceEmpty::hasInstance(info[i], info.GetIsolate())) {
6030             throwTypeError(ExceptionMessages::failedToExecute("voidMethodTestInterfaceEmptyArgVariadicTestInterfaceEmptyArg", "TestObjectPython", "parameter 2 is not of type 'TestInterfaceEmpty'."), info.GetIsolate());
6031             return;
6032         }
6033         variadicTestInterfaceEmptyArgs.append(V8TestInterfaceEmpty::toNative(v8::Handle<v8::Object>::Cast(info[i])));
6034     }
6035     impl->voidMethodTestInterfaceEmptyArgVariadicTestInterfaceEmptyArg(testInterfaceEmptyArg, variadicTestInterfaceEmptyArgs);
6036 }
6037
6038 static void voidMethodTestInterfaceEmptyArgVariadicTestInterfaceEmptyArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
6039 {
6040     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
6041     TestObjectPythonV8Internal::voidMethodTestInterfaceEmptyArgVariadicTestInterfaceEmptyArgMethod(info);
6042     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
6043 }
6044
6045 static void voidMethodVariadicTestInterfaceWillBeGarbageCollectedArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
6046 {
6047     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
6048     WillBeHeapVector<RefPtrWillBeMember<TestInterfaceWillBeGarbageCollected> > variadicTestInterfaceWillBeGarbageCollectedArg;
6049     for (int i = 0; i < info.Length(); ++i) {
6050         if (!V8TestInterfaceWillBeGarbageCollected::hasInstance(info[i], info.GetIsolate())) {
6051             throwTypeError(ExceptionMessages::failedToExecute("voidMethodVariadicTestInterfaceWillBeGarbageCollectedArg", "TestObjectPython", "parameter 1 is not of type 'TestInterfaceWillBeGarbageCollected'."), info.GetIsolate());
6052             return;
6053         }
6054         variadicTestInterfaceWillBeGarbageCollectedArg.append(V8TestInterfaceWillBeGarbageCollected::toNative(v8::Handle<v8::Object>::Cast(info[i])));
6055     }
6056     impl->voidMethodVariadicTestInterfaceWillBeGarbageCollectedArg(variadicTestInterfaceWillBeGarbageCollectedArg);
6057 }
6058
6059 static void voidMethodVariadicTestInterfaceWillBeGarbageCollectedArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
6060 {
6061     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
6062     TestObjectPythonV8Internal::voidMethodVariadicTestInterfaceWillBeGarbageCollectedArgMethod(info);
6063     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
6064 }
6065
6066 static void overloadedMethodA1Method(const v8::FunctionCallbackInfo<v8::Value>& info)
6067 {
6068     ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedMethodA", "TestObjectPython", info.Holder(), info.GetIsolate());
6069     if (UNLIKELY(info.Length() < 1)) {
6070         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
6071         exceptionState.throwIfNeeded();
6072         return;
6073     }
6074     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
6075     V8TRYCATCH_EXCEPTION_VOID(int, longArg, toInt32(info[0], exceptionState), exceptionState);
6076     impl->overloadedMethodA(longArg);
6077 }
6078
6079 static void overloadedMethodA2Method(const v8::FunctionCallbackInfo<v8::Value>& info)
6080 {
6081     ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedMethodA", "TestObjectPython", info.Holder(), info.GetIsolate());
6082     if (UNLIKELY(info.Length() < 2)) {
6083         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(2, info.Length()));
6084         exceptionState.throwIfNeeded();
6085         return;
6086     }
6087     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
6088     V8TRYCATCH_EXCEPTION_VOID(int, longArg1, toInt32(info[0], exceptionState), exceptionState);
6089     V8TRYCATCH_EXCEPTION_VOID(int, longArg2, toInt32(info[1], exceptionState), exceptionState);
6090     impl->overloadedMethodA(longArg1, longArg2);
6091 }
6092
6093 static void overloadedMethodAMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
6094 {
6095     if (((info.Length() == 1))) {
6096         overloadedMethodA1Method(info);
6097         return;
6098     }
6099     if (((info.Length() == 2))) {
6100         overloadedMethodA2Method(info);
6101         return;
6102     }
6103     ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedMethodA", "TestObjectPython", info.Holder(), info.GetIsolate());
6104     if (UNLIKELY(info.Length() < 1)) {
6105         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
6106         exceptionState.throwIfNeeded();
6107         return;
6108     }
6109     exceptionState.throwTypeError("No function was found that matched the signature provided.");
6110     exceptionState.throwIfNeeded();
6111 }
6112
6113 static void overloadedMethodAMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
6114 {
6115     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
6116     TestObjectPythonV8Internal::overloadedMethodAMethod(info);
6117     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
6118 }
6119
6120 static void overloadedMethodB1Method(const v8::FunctionCallbackInfo<v8::Value>& info)
6121 {
6122     ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedMethodB", "TestObjectPython", info.Holder(), info.GetIsolate());
6123     if (UNLIKELY(info.Length() < 1)) {
6124         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
6125         exceptionState.throwIfNeeded();
6126         return;
6127     }
6128     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
6129     V8TRYCATCH_EXCEPTION_VOID(int, longArg, toInt32(info[0], exceptionState), exceptionState);
6130     impl->overloadedMethodB(longArg);
6131 }
6132
6133 static void overloadedMethodB2Method(const v8::FunctionCallbackInfo<v8::Value>& info)
6134 {
6135     ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedMethodB", "TestObjectPython", info.Holder(), info.GetIsolate());
6136     if (UNLIKELY(info.Length() < 1)) {
6137         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
6138         exceptionState.throwIfNeeded();
6139         return;
6140     }
6141     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
6142     V8TRYCATCH_EXCEPTION_VOID(int, longArg1, toInt32(info[0], exceptionState), exceptionState);
6143     if (UNLIKELY(info.Length() <= 1)) {
6144         impl->overloadedMethodB(longArg1);
6145         return;
6146     }
6147     V8TRYCATCH_EXCEPTION_VOID(int, longArg2, toInt32(info[1], exceptionState), exceptionState);
6148     impl->overloadedMethodB(longArg1, longArg2);
6149 }
6150
6151 static void overloadedMethodBMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
6152 {
6153     if (((info.Length() == 1))) {
6154         overloadedMethodB1Method(info);
6155         return;
6156     }
6157     if (((info.Length() == 1)) || ((info.Length() == 2))) {
6158         overloadedMethodB2Method(info);
6159         return;
6160     }
6161     ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedMethodB", "TestObjectPython", info.Holder(), info.GetIsolate());
6162     if (UNLIKELY(info.Length() < 1)) {
6163         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
6164         exceptionState.throwIfNeeded();
6165         return;
6166     }
6167     exceptionState.throwTypeError("No function was found that matched the signature provided.");
6168     exceptionState.throwIfNeeded();
6169 }
6170
6171 static void overloadedMethodBMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
6172 {
6173     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
6174     TestObjectPythonV8Internal::overloadedMethodBMethod(info);
6175     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
6176 }
6177
6178 static void overloadedMethodC1Method(const v8::FunctionCallbackInfo<v8::Value>& info)
6179 {
6180     ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedMethodC", "TestObjectPython", info.Holder(), info.GetIsolate());
6181     if (UNLIKELY(info.Length() < 1)) {
6182         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
6183         exceptionState.throwIfNeeded();
6184         return;
6185     }
6186     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
6187     V8TRYCATCH_EXCEPTION_VOID(int, longArg, toInt32(info[0], exceptionState), exceptionState);
6188     impl->overloadedMethodC(longArg);
6189 }
6190
6191 static void overloadedMethodC2Method(const v8::FunctionCallbackInfo<v8::Value>& info)
6192 {
6193     ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedMethodC", "TestObjectPython", info.Holder(), info.GetIsolate());
6194     if (UNLIKELY(info.Length() < 1)) {
6195         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
6196         exceptionState.throwIfNeeded();
6197         return;
6198     }
6199     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
6200     V8TRYCATCH_EXCEPTION_VOID(int, longArg, toInt32(info[0], exceptionState), exceptionState);
6201     V8TRYCATCH_VOID(Vector<int>, longArgs, toNativeArguments<int>(info, 1));
6202     impl->overloadedMethodC(longArg, longArgs);
6203 }
6204
6205 static void overloadedMethodCMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
6206 {
6207     if (((info.Length() == 1))) {
6208         overloadedMethodC1Method(info);
6209         return;
6210     }
6211     if () {
6212         overloadedMethodC2Method(info);
6213         return;
6214     }
6215     ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedMethodC", "TestObjectPython", info.Holder(), info.GetIsolate());
6216     if (UNLIKELY(info.Length() < 1)) {
6217         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
6218         exceptionState.throwIfNeeded();
6219         return;
6220     }
6221     exceptionState.throwTypeError("No function was found that matched the signature provided.");
6222     exceptionState.throwIfNeeded();
6223 }
6224
6225 static void overloadedMethodCMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
6226 {
6227     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
6228     TestObjectPythonV8Internal::overloadedMethodCMethod(info);
6229     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
6230 }
6231
6232 static void overloadedMethodD1Method(const v8::FunctionCallbackInfo<v8::Value>& info)
6233 {
6234     ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedMethodD", "TestObjectPython", info.Holder(), info.GetIsolate());
6235     if (UNLIKELY(info.Length() < 1)) {
6236         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
6237         exceptionState.throwIfNeeded();
6238         return;
6239     }
6240     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
6241     V8TRYCATCH_EXCEPTION_VOID(int, longArg, toInt32(info[0], exceptionState), exceptionState);
6242     impl->overloadedMethodD(longArg);
6243 }
6244
6245 static void overloadedMethodD2Method(const v8::FunctionCallbackInfo<v8::Value>& info)
6246 {
6247     if (UNLIKELY(info.Length() < 1)) {
6248         throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodD", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate());
6249         return;
6250     }
6251     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
6252     V8TRYCATCH_VOID(TestInterfaceEmpty*, testInterfaceEmptyArg, V8TestInterfaceEmpty::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
6253     impl->overloadedMethodD(testInterfaceEmptyArg);
6254 }
6255
6256 static void overloadedMethodDMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
6257 {
6258     if (((info.Length() == 1))) {
6259         overloadedMethodD1Method(info);
6260         return;
6261     }
6262     if (((info.Length() == 1) && (V8TestInterfaceEmpty::hasInstance(info[0], info.GetIsolate())))) {
6263         overloadedMethodD2Method(info);
6264         return;
6265     }
6266     ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedMethodD", "TestObjectPython", info.Holder(), info.GetIsolate());
6267     if (UNLIKELY(info.Length() < 1)) {
6268         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
6269         exceptionState.throwIfNeeded();
6270         return;
6271     }
6272     exceptionState.throwTypeError("No function was found that matched the signature provided.");
6273     exceptionState.throwIfNeeded();
6274 }
6275
6276 static void overloadedMethodDMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
6277 {
6278     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
6279     TestObjectPythonV8Internal::overloadedMethodDMethod(info);
6280     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
6281 }
6282
6283 static void overloadedMethodE1Method(const v8::FunctionCallbackInfo<v8::Value>& info)
6284 {
6285     ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedMethodE", "TestObjectPython", info.Holder(), info.GetIsolate());
6286     if (UNLIKELY(info.Length() < 1)) {
6287         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
6288         exceptionState.throwIfNeeded();
6289         return;
6290     }
6291     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
6292     V8TRYCATCH_EXCEPTION_VOID(int, longArg, toInt32(info[0], exceptionState), exceptionState);
6293     impl->overloadedMethodE(longArg);
6294 }
6295
6296 static void overloadedMethodE2Method(const v8::FunctionCallbackInfo<v8::Value>& info)
6297 {
6298     if (UNLIKELY(info.Length() < 1)) {
6299         throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodE", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate());
6300         return;
6301     }
6302     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
6303     V8TRYCATCH_VOID(Vector<int>, longArrayArg, toNativeArray<int>(info[0], 1, info.GetIsolate()));
6304     impl->overloadedMethodE(longArrayArg);
6305 }
6306
6307 static void overloadedMethodEMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
6308 {
6309     if (((info.Length() == 1))) {
6310         overloadedMethodE1Method(info);
6311         return;
6312     }
6313     if (((info.Length() == 1) && (info[0]->IsArray()))) {
6314         overloadedMethodE2Method(info);
6315         return;
6316     }
6317     ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedMethodE", "TestObjectPython", info.Holder(), info.GetIsolate());
6318     if (UNLIKELY(info.Length() < 1)) {
6319         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
6320         exceptionState.throwIfNeeded();
6321         return;
6322     }
6323     exceptionState.throwTypeError("No function was found that matched the signature provided.");
6324     exceptionState.throwIfNeeded();
6325 }
6326
6327 static void overloadedMethodEMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
6328 {
6329     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
6330     TestObjectPythonV8Internal::overloadedMethodEMethod(info);
6331     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
6332 }
6333
6334 static void overloadedMethodF1Method(const v8::FunctionCallbackInfo<v8::Value>& info)
6335 {
6336     ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedMethodF", "TestObjectPython", info.Holder(), info.GetIsolate());
6337     if (UNLIKELY(info.Length() < 1)) {
6338         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
6339         exceptionState.throwIfNeeded();
6340         return;
6341     }
6342     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
6343     V8TRYCATCH_EXCEPTION_VOID(int, longArg, toInt32(info[0], exceptionState), exceptionState);
6344     impl->overloadedMethodF(longArg);
6345 }
6346
6347 static void overloadedMethodF2Method(const v8::FunctionCallbackInfo<v8::Value>& info)
6348 {
6349     if (UNLIKELY(info.Length() < 1)) {
6350         throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodF", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate());
6351         return;
6352     }
6353     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
6354     V8TRYCATCH_VOID(TestInterfaceEmpty*, testInterfaceEmptyNullableArg, V8TestInterfaceEmpty::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
6355     impl->overloadedMethodF(testInterfaceEmptyNullableArg);
6356 }
6357
6358 static void overloadedMethodFMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
6359 {
6360     if (((info.Length() == 1))) {
6361         overloadedMethodF1Method(info);
6362         return;
6363     }
6364     if (((info.Length() == 1) && (info[0]->IsNull() || V8TestInterfaceEmpty::hasInstance(info[0], info.GetIsolate())))) {
6365         overloadedMethodF2Method(info);
6366         return;
6367     }
6368     ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedMethodF", "TestObjectPython", info.Holder(), info.GetIsolate());
6369     if (UNLIKELY(info.Length() < 1)) {
6370         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
6371         exceptionState.throwIfNeeded();
6372         return;
6373     }
6374     exceptionState.throwTypeError("No function was found that matched the signature provided.");
6375     exceptionState.throwIfNeeded();
6376 }
6377
6378 static void overloadedMethodFMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
6379 {
6380     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
6381     TestObjectPythonV8Internal::overloadedMethodFMethod(info);
6382     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
6383 }
6384
6385 static void overloadedMethodG1Method(const v8::FunctionCallbackInfo<v8::Value>& info)
6386 {
6387     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
6388     impl->overloadedMethodG();
6389 }
6390
6391 static void overloadedMethodG2Method(const v8::FunctionCallbackInfo<v8::Value>& info)
6392 {
6393     if (UNLIKELY(info.Length() < 1)) {
6394         throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodG", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate());
6395         return;
6396     }
6397     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
6398     V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, strictTypeCheckingStringArg, info[0]);
6399     impl->overloadedMethodG(strictTypeCheckingStringArg);
6400 }
6401
6402 static void overloadedMethodGMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
6403 {
6404     if (((info.Length() == 0))) {
6405         overloadedMethodG1Method(info);
6406         return;
6407     }
6408     if (((info.Length() == 1) && (isUndefinedOrNull(info[0]) || info[0]->IsString() || info[0]->IsObject()))) {
6409         overloadedMethodG2Method(info);
6410         return;
6411     }
6412     throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodG", "TestObjectPython", "No function was found that matched the signature provided."), info.GetIsolate());
6413 }
6414
6415 static void overloadedMethodGMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
6416 {
6417     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
6418     TestObjectPythonV8Internal::overloadedMethodGMethod(info);
6419     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
6420 }
6421
6422 static void overloadedMethodH1Method(const v8::FunctionCallbackInfo<v8::Value>& info)
6423 {
6424     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
6425     impl->overloadedMethodH();
6426 }
6427
6428 static void overloadedMethodH2Method(const v8::FunctionCallbackInfo<v8::Value>& info)
6429 {
6430     if (UNLIKELY(info.Length() < 1)) {
6431         throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodH", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate());
6432         return;
6433     }
6434     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
6435     if (info.Length() <= 0 || !info[0]->IsFunction()) {
6436         throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodH", "TestObjectPython", "The callback provided as parameter 1 is not a function."), info.GetIsolate());
6437         return;
6438     }
6439     OwnPtr<TestCallbackInterface> testCallbackInterfaceArg = V8TestCallbackInterface::create(v8::Handle<v8::Function>::Cast(info[0]), currentExecutionContext(info.GetIsolate()));
6440     impl->overloadedMethodH(testCallbackInterfaceArg.release());
6441 }
6442
6443 static void overloadedMethodHMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
6444 {
6445     if (((info.Length() == 0))) {
6446         overloadedMethodH1Method(info);
6447         return;
6448     }
6449     if (((info.Length() == 1) && (info[0]->IsNull() || info[0]->IsFunction()))) {
6450         overloadedMethodH2Method(info);
6451         return;
6452     }
6453     throwTypeError(ExceptionMessages::failedToExecute("overloadedMethodH", "TestObjectPython", "No function was found that matched the signature provided."), info.GetIsolate());
6454 }
6455
6456 static void overloadedMethodHMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
6457 {
6458     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
6459     TestObjectPythonV8Internal::overloadedMethodHMethod(info);
6460     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
6461 }
6462
6463 static void overloadedPerWorldBindingsMethod1Method(const v8::FunctionCallbackInfo<v8::Value>& info)
6464 {
6465     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
6466     impl->overloadedPerWorldBindingsMethod();
6467 }
6468
6469 static void overloadedPerWorldBindingsMethod1MethodForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info)
6470 {
6471     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
6472     impl->overloadedPerWorldBindingsMethod();
6473 }
6474
6475 static void overloadedPerWorldBindingsMethod2Method(const v8::FunctionCallbackInfo<v8::Value>& info)
6476 {
6477     ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedPerWorldBindingsMethod", "TestObjectPython", info.Holder(), info.GetIsolate());
6478     if (UNLIKELY(info.Length() < 1)) {
6479         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
6480         exceptionState.throwIfNeeded();
6481         return;
6482     }
6483     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
6484     V8TRYCATCH_EXCEPTION_VOID(int, longArg, toInt32(info[0], exceptionState), exceptionState);
6485     impl->overloadedPerWorldBindingsMethod(longArg);
6486 }
6487
6488 static void overloadedPerWorldBindingsMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
6489 {
6490     if (((info.Length() == 0))) {
6491         overloadedPerWorldBindingsMethod1Method(info);
6492         return;
6493     }
6494     if (((info.Length() == 1))) {
6495         overloadedPerWorldBindingsMethod2Method(info);
6496         return;
6497     }
6498     throwTypeError(ExceptionMessages::failedToExecute("overloadedPerWorldBindingsMethod", "TestObjectPython", "No function was found that matched the signature provided."), info.GetIsolate());
6499 }
6500
6501 static void overloadedPerWorldBindingsMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
6502 {
6503     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
6504     TestObjectPythonV8Internal::overloadedPerWorldBindingsMethodMethod(info);
6505     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
6506 }
6507
6508 static void overloadedPerWorldBindingsMethod2MethodForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info)
6509 {
6510     ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedPerWorldBindingsMethod", "TestObjectPython", info.Holder(), info.GetIsolate());
6511     if (UNLIKELY(info.Length() < 1)) {
6512         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
6513         exceptionState.throwIfNeeded();
6514         return;
6515     }
6516     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
6517     V8TRYCATCH_EXCEPTION_VOID(int, longArg, toInt32(info[0], exceptionState), exceptionState);
6518     impl->overloadedPerWorldBindingsMethod(longArg);
6519 }
6520
6521 static void overloadedPerWorldBindingsMethodMethodForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info)
6522 {
6523     if (((info.Length() == 0))) {
6524         overloadedPerWorldBindingsMethod1MethodForMainWorld(info);
6525         return;
6526     }
6527     if (((info.Length() == 1))) {
6528         overloadedPerWorldBindingsMethod2MethodForMainWorld(info);
6529         return;
6530     }
6531     throwTypeError(ExceptionMessages::failedToExecute("overloadedPerWorldBindingsMethod", "TestObjectPython", "No function was found that matched the signature provided."), info.GetIsolate());
6532 }
6533
6534 static void overloadedPerWorldBindingsMethodMethodCallbackForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info)
6535 {
6536     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
6537     TestObjectPythonV8Internal::overloadedPerWorldBindingsMethodMethodForMainWorld(info);
6538     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
6539 }
6540
6541 static void overloadedStaticMethod1Method(const v8::FunctionCallbackInfo<v8::Value>& info)
6542 {
6543     ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedStaticMethod", "TestObjectPython", info.Holder(), info.GetIsolate());
6544     if (UNLIKELY(info.Length() < 1)) {
6545         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
6546         exceptionState.throwIfNeeded();
6547         return;
6548     }
6549     V8TRYCATCH_EXCEPTION_VOID(int, longArg, toInt32(info[0], exceptionState), exceptionState);
6550     TestObjectPython::overloadedStaticMethod(longArg);
6551 }
6552
6553 static void overloadedStaticMethod2Method(const v8::FunctionCallbackInfo<v8::Value>& info)
6554 {
6555     ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedStaticMethod", "TestObjectPython", info.Holder(), info.GetIsolate());
6556     if (UNLIKELY(info.Length() < 2)) {
6557         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(2, info.Length()));
6558         exceptionState.throwIfNeeded();
6559         return;
6560     }
6561     V8TRYCATCH_EXCEPTION_VOID(int, longArg1, toInt32(info[0], exceptionState), exceptionState);
6562     V8TRYCATCH_EXCEPTION_VOID(int, longArg2, toInt32(info[1], exceptionState), exceptionState);
6563     TestObjectPython::overloadedStaticMethod(longArg1, longArg2);
6564 }
6565
6566 static void overloadedStaticMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
6567 {
6568     if (((info.Length() == 1))) {
6569         overloadedStaticMethod1Method(info);
6570         return;
6571     }
6572     if (((info.Length() == 2))) {
6573         overloadedStaticMethod2Method(info);
6574         return;
6575     }
6576     ExceptionState exceptionState(ExceptionState::ExecutionContext, "overloadedStaticMethod", "TestObjectPython", info.Holder(), info.GetIsolate());
6577     if (UNLIKELY(info.Length() < 1)) {
6578         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
6579         exceptionState.throwIfNeeded();
6580         return;
6581     }
6582     exceptionState.throwTypeError("No function was found that matched the signature provided.");
6583     exceptionState.throwIfNeeded();
6584 }
6585
6586 static void overloadedStaticMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
6587 {
6588     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
6589     TestObjectPythonV8Internal::overloadedStaticMethodMethod(info);
6590     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
6591 }
6592
6593 static void voidMethodClampUnsignedShortArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
6594 {
6595     ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodClampUnsignedShortArg", "TestObjectPython", info.Holder(), info.GetIsolate());
6596     if (UNLIKELY(info.Length() < 1)) {
6597         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
6598         exceptionState.throwIfNeeded();
6599         return;
6600     }
6601     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
6602     unsigned clampUnsignedShortArg = 0;
6603     V8TRYCATCH_VOID(double, clampUnsignedShortArgNativeValue, info[0]->NumberValue());
6604     if (!std::isnan(clampUnsignedShortArgNativeValue))
6605         clampUnsignedShortArg = clampTo<unsigned short>(clampUnsignedShortArgNativeValue);
6606     impl->voidMethodClampUnsignedShortArg(clampUnsignedShortArg);
6607 }
6608
6609 static void voidMethodClampUnsignedShortArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
6610 {
6611     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
6612     TestObjectPythonV8Internal::voidMethodClampUnsignedShortArgMethod(info);
6613     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
6614 }
6615
6616 static void voidMethodClampUnsignedLongArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
6617 {
6618     ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodClampUnsignedLongArg", "TestObjectPython", info.Holder(), info.GetIsolate());
6619     if (UNLIKELY(info.Length() < 1)) {
6620         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
6621         exceptionState.throwIfNeeded();
6622         return;
6623     }
6624     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
6625     unsigned clampUnsignedLongArg = 0;
6626     V8TRYCATCH_VOID(double, clampUnsignedLongArgNativeValue, info[0]->NumberValue());
6627     if (!std::isnan(clampUnsignedLongArgNativeValue))
6628         clampUnsignedLongArg = clampTo<unsigned long>(clampUnsignedLongArgNativeValue);
6629     impl->voidMethodClampUnsignedLongArg(clampUnsignedLongArg);
6630 }
6631
6632 static void voidMethodClampUnsignedLongArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
6633 {
6634     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
6635     TestObjectPythonV8Internal::voidMethodClampUnsignedLongArgMethod(info);
6636     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
6637 }
6638
6639 static void voidMethodDefaultUndefinedTestInterfaceEmptyArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
6640 {
6641     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
6642     V8TRYCATCH_VOID(TestInterfaceEmpty*, defaultUndefinedTestInterfaceEmptyArg, V8TestInterfaceEmpty::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
6643     impl->voidMethodDefaultUndefinedTestInterfaceEmptyArg(defaultUndefinedTestInterfaceEmptyArg);
6644 }
6645
6646 static void voidMethodDefaultUndefinedTestInterfaceEmptyArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
6647 {
6648     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
6649     TestObjectPythonV8Internal::voidMethodDefaultUndefinedTestInterfaceEmptyArgMethod(info);
6650     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
6651 }
6652
6653 static void voidMethodDefaultUndefinedLongArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
6654 {
6655     ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodDefaultUndefinedLongArg", "TestObjectPython", info.Holder(), info.GetIsolate());
6656     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
6657     V8TRYCATCH_EXCEPTION_VOID(int, defaultUndefinedLongArg, toInt32(info[0], exceptionState), exceptionState);
6658     impl->voidMethodDefaultUndefinedLongArg(defaultUndefinedLongArg);
6659 }
6660
6661 static void voidMethodDefaultUndefinedLongArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
6662 {
6663     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
6664     TestObjectPythonV8Internal::voidMethodDefaultUndefinedLongArgMethod(info);
6665     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
6666 }
6667
6668 static void voidMethodDefaultUndefinedStringArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
6669 {
6670     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
6671     V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, defaultUndefinedStringArg, info[0]);
6672     impl->voidMethodDefaultUndefinedStringArg(defaultUndefinedStringArg);
6673 }
6674
6675 static void voidMethodDefaultUndefinedStringArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
6676 {
6677     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
6678     TestObjectPythonV8Internal::voidMethodDefaultUndefinedStringArgMethod(info);
6679     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
6680 }
6681
6682 static void voidMethodDefaultNullStringStringArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
6683 {
6684     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
6685     V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, defaultNullStringStringArg, argumentOrNull(info, 0));
6686     impl->voidMethodDefaultNullStringStringArg(defaultNullStringStringArg);
6687 }
6688
6689 static void voidMethodDefaultNullStringStringArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
6690 {
6691     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
6692     TestObjectPythonV8Internal::voidMethodDefaultNullStringStringArgMethod(info);
6693     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
6694 }
6695
6696 static void voidMethodEnforceRangeLongArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
6697 {
6698     ExceptionState exceptionState(ExceptionState::ExecutionContext, "voidMethodEnforceRangeLongArg", "TestObjectPython", info.Holder(), info.GetIsolate());
6699     if (UNLIKELY(info.Length() < 1)) {
6700         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
6701         exceptionState.throwIfNeeded();
6702         return;
6703     }
6704     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
6705     V8TRYCATCH_EXCEPTION_VOID(int, enforceRangeLongArg, toInt32(info[0], EnforceRange, exceptionState), exceptionState);
6706     impl->voidMethodEnforceRangeLongArg(enforceRangeLongArg);
6707 }
6708
6709 static void voidMethodEnforceRangeLongArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
6710 {
6711     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
6712     TestObjectPythonV8Internal::voidMethodEnforceRangeLongArgMethod(info);
6713     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
6714 }
6715
6716 static void voidMethodTreatNullAsNullStringStringArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
6717 {
6718     if (UNLIKELY(info.Length() < 1)) {
6719         throwTypeError(ExceptionMessages::failedToExecute("voidMethodTreatNullAsNullStringStringArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate());
6720         return;
6721     }
6722     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
6723     V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<WithNullCheck>, treatNullAsNullStringStringArg, info[0]);
6724     impl->voidMethodTreatNullAsNullStringStringArg(treatNullAsNullStringStringArg);
6725 }
6726
6727 static void voidMethodTreatNullAsNullStringStringArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
6728 {
6729     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
6730     TestObjectPythonV8Internal::voidMethodTreatNullAsNullStringStringArgMethod(info);
6731     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
6732 }
6733
6734 static void voidMethodTreatNullAsNullStringTreatUndefinedAsNullStringStringArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
6735 {
6736     if (UNLIKELY(info.Length() < 1)) {
6737         throwTypeError(ExceptionMessages::failedToExecute("voidMethodTreatNullAsNullStringTreatUndefinedAsNullStringStringArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate());
6738         return;
6739     }
6740     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
6741     V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<WithUndefinedOrNullCheck>, treatNullAsNullStringStringArg, info[0]);
6742     impl->voidMethodTreatNullAsNullStringTreatUndefinedAsNullStringStringArg(treatNullAsNullStringStringArg);
6743 }
6744
6745 static void voidMethodTreatNullAsNullStringTreatUndefinedAsNullStringStringArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
6746 {
6747     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
6748     TestObjectPythonV8Internal::voidMethodTreatNullAsNullStringTreatUndefinedAsNullStringStringArgMethod(info);
6749     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
6750 }
6751
6752 static void activityLoggingAccessForAllWorldsMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
6753 {
6754     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
6755     impl->activityLoggingAccessForAllWorldsMethod();
6756 }
6757
6758 static void activityLoggingAccessForAllWorldsMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
6759 {
6760     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
6761     V8PerContextData* contextData = V8PerContextData::from(info.GetIsolate()->GetCurrentContext());
6762     if (contextData && contextData->activityLogger()) {
6763         Vector<v8::Handle<v8::Value> > loggerArgs = toNativeArguments<v8::Handle<v8::Value> >(info, 0);
6764         contextData->activityLogger()->log("TestObjectPython.activityLoggingAccessForAllWorldsMethod", info.Length(), loggerArgs.data(), "Method");
6765     }
6766     TestObjectPythonV8Internal::activityLoggingAccessForAllWorldsMethodMethod(info);
6767     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
6768 }
6769
6770 static void callWithScriptStateVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
6771 {
6772     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
6773     ScriptState* currentState = ScriptState::current();
6774     if (!currentState)
6775         return;
6776     ScriptState& state = *currentState;
6777     impl->callWithScriptStateVoidMethod(&state);
6778     if (state.hadException()) {
6779         v8::Local<v8::Value> exception = state.exception();
6780         state.clearException();
6781         throwError(exception, info.GetIsolate());
6782         return;
6783     }
6784 }
6785
6786 static void callWithScriptStateVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
6787 {
6788     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
6789     TestObjectPythonV8Internal::callWithScriptStateVoidMethodMethod(info);
6790     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
6791 }
6792
6793 static void callWithScriptStateLongMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
6794 {
6795     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
6796     ScriptState* currentState = ScriptState::current();
6797     if (!currentState)
6798         return;
6799     ScriptState& state = *currentState;
6800     int result = impl->callWithScriptStateLongMethod(&state);
6801     if (state.hadException()) {
6802         v8::Local<v8::Value> exception = state.exception();
6803         state.clearException();
6804         throwError(exception, info.GetIsolate());
6805         return;
6806     }
6807     v8SetReturnValueInt(info, result);
6808 }
6809
6810 static void callWithScriptStateLongMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
6811 {
6812     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
6813     TestObjectPythonV8Internal::callWithScriptStateLongMethodMethod(info);
6814     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
6815 }
6816
6817 static void callWithExecutionContextVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
6818 {
6819     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
6820     ExecutionContext* scriptContext = currentExecutionContext(info.GetIsolate());
6821     impl->callWithExecutionContextVoidMethod(scriptContext);
6822 }
6823
6824 static void callWithExecutionContextVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
6825 {
6826     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
6827     TestObjectPythonV8Internal::callWithExecutionContextVoidMethodMethod(info);
6828     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
6829 }
6830
6831 static void callWithScriptStateExecutionContextVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
6832 {
6833     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
6834     ScriptState* currentState = ScriptState::current();
6835     if (!currentState)
6836         return;
6837     ScriptState& state = *currentState;
6838     ExecutionContext* scriptContext = currentExecutionContext(info.GetIsolate());
6839     impl->callWithScriptStateExecutionContextVoidMethod(&state, scriptContext);
6840     if (state.hadException()) {
6841         v8::Local<v8::Value> exception = state.exception();
6842         state.clearException();
6843         throwError(exception, info.GetIsolate());
6844         return;
6845     }
6846 }
6847
6848 static void callWithScriptStateExecutionContextVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
6849 {
6850     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
6851     TestObjectPythonV8Internal::callWithScriptStateExecutionContextVoidMethodMethod(info);
6852     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
6853 }
6854
6855 static void callWithScriptStateScriptArgumentsVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
6856 {
6857     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
6858     ScriptState* currentState = ScriptState::current();
6859     if (!currentState)
6860         return;
6861     ScriptState& state = *currentState;
6862     RefPtr<ScriptArguments> scriptArguments(createScriptArguments(info, 0));
6863     impl->callWithScriptStateScriptArgumentsVoidMethod(&state, scriptArguments.release());
6864     if (state.hadException()) {
6865         v8::Local<v8::Value> exception = state.exception();
6866         state.clearException();
6867         throwError(exception, info.GetIsolate());
6868         return;
6869     }
6870 }
6871
6872 static void callWithScriptStateScriptArgumentsVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
6873 {
6874     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
6875     TestObjectPythonV8Internal::callWithScriptStateScriptArgumentsVoidMethodMethod(info);
6876     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
6877 }
6878
6879 static void callWithScriptStateScriptArgumentsVoidMethodOptionalBooleanArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
6880 {
6881     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
6882     if (UNLIKELY(info.Length() <= 0)) {
6883         ScriptState* currentState = ScriptState::current();
6884         if (!currentState)
6885             return;
6886         ScriptState& state = *currentState;
6887         RefPtr<ScriptArguments> scriptArguments(createScriptArguments(info, 1));
6888         impl->callWithScriptStateScriptArgumentsVoidMethodOptionalBooleanArg(&state, scriptArguments.release());
6889         if (state.hadException()) {
6890             v8::Local<v8::Value> exception = state.exception();
6891             state.clearException();
6892             throwError(exception, info.GetIsolate());
6893             return;
6894         }
6895         return;
6896     }
6897     V8TRYCATCH_VOID(bool, optionalBooleanArg, info[0]->BooleanValue());
6898     ScriptState* currentState = ScriptState::current();
6899     if (!currentState)
6900         return;
6901     ScriptState& state = *currentState;
6902     RefPtr<ScriptArguments> scriptArguments(createScriptArguments(info, 1));
6903     impl->callWithScriptStateScriptArgumentsVoidMethodOptionalBooleanArg(&state, scriptArguments.release(), optionalBooleanArg);
6904     if (state.hadException()) {
6905         v8::Local<v8::Value> exception = state.exception();
6906         state.clearException();
6907         throwError(exception, info.GetIsolate());
6908         return;
6909     }
6910 }
6911
6912 static void callWithScriptStateScriptArgumentsVoidMethodOptionalBooleanArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
6913 {
6914     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
6915     TestObjectPythonV8Internal::callWithScriptStateScriptArgumentsVoidMethodOptionalBooleanArgMethod(info);
6916     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
6917 }
6918
6919 static void callWithActiveWindowMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
6920 {
6921     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
6922     impl->callWithActiveWindow(callingDOMWindow(info.GetIsolate()));
6923 }
6924
6925 static void callWithActiveWindowMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
6926 {
6927     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
6928     TestObjectPythonV8Internal::callWithActiveWindowMethod(info);
6929     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
6930 }
6931
6932 static void callWithActiveWindowScriptWindowMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
6933 {
6934     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
6935     impl->callWithActiveWindowScriptWindow(callingDOMWindow(info.GetIsolate()), enteredDOMWindow(info.GetIsolate()));
6936 }
6937
6938 static void callWithActiveWindowScriptWindowMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
6939 {
6940     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
6941     TestObjectPythonV8Internal::callWithActiveWindowScriptWindowMethod(info);
6942     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
6943 }
6944
6945 static void checkSecurityForNodeVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
6946 {
6947     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
6948     if (!BindingSecurity::shouldAllowAccessToNode(info.GetIsolate(), impl->checkSecurityForNodeVoidMethod(exceptionState), exceptionState)) {
6949         v8SetReturnValueNull(info);
6950         exceptionState.throwIfNeeded();
6951         return;
6952     }
6953     impl->checkSecurityForNodeVoidMethod();
6954 }
6955
6956 static void checkSecurityForNodeVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
6957 {
6958     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
6959     TestObjectPythonV8Internal::checkSecurityForNodeVoidMethodMethod(info);
6960     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
6961 }
6962
6963 #if ENABLE(CONDITION)
6964 static void conditionalConditionVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
6965 {
6966     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
6967     impl->conditionalConditionVoidMethod();
6968 }
6969 #endif // ENABLE(CONDITION)
6970
6971 #if ENABLE(CONDITION)
6972 static void conditionalConditionVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
6973 {
6974     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
6975     TestObjectPythonV8Internal::conditionalConditionVoidMethodMethod(info);
6976     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
6977 }
6978 #endif // ENABLE(CONDITION)
6979
6980 #if ENABLE(CONDITION_1) && ENABLE(CONDITION_2)
6981 static void conditionalCondition1AndCondition2VoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
6982 {
6983     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
6984     impl->conditionalCondition1AndCondition2VoidMethod();
6985 }
6986 #endif // ENABLE(CONDITION_1) && ENABLE(CONDITION_2)
6987
6988 #if ENABLE(CONDITION_1) && ENABLE(CONDITION_2)
6989 static void conditionalCondition1AndCondition2VoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
6990 {
6991     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
6992     TestObjectPythonV8Internal::conditionalCondition1AndCondition2VoidMethodMethod(info);
6993     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
6994 }
6995 #endif // ENABLE(CONDITION_1) && ENABLE(CONDITION_2)
6996
6997 #if ENABLE(CONDITION)
6998 static void conditionalConditionStaticVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
6999 {
7000     TestObjectPython::conditionalConditionStaticVoidMethod();
7001 }
7002 #endif // ENABLE(CONDITION)
7003
7004 #if ENABLE(CONDITION)
7005 static void conditionalConditionStaticVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
7006 {
7007     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
7008     TestObjectPythonV8Internal::conditionalConditionStaticVoidMethodMethod(info);
7009     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
7010 }
7011 #endif // ENABLE(CONDITION)
7012
7013 static void customVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
7014 {
7015     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
7016     V8TestObjectPython::customVoidMethodMethodCustom(info);
7017     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
7018 }
7019
7020 #if ENABLE(CONDITION)
7021 static void conditionalConditionCustomVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
7022 {
7023     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
7024     V8TestObjectPython::conditionalConditionCustomVoidMethodMethodCustom(info);
7025     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
7026 }
7027 #endif // ENABLE(CONDITION)
7028
7029 static void customElementCallbacksVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
7030 {
7031     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
7032     CustomElementCallbackDispatcher::CallbackDeliveryScope deliveryScope;
7033     impl->customElementCallbacksVoidMethod();
7034 }
7035
7036 static void customElementCallbacksVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
7037 {
7038     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
7039     TestObjectPythonV8Internal::customElementCallbacksVoidMethodMethod(info);
7040     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
7041 }
7042
7043 static void deprecatedVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
7044 {
7045     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
7046     impl->deprecatedVoidMethod();
7047 }
7048
7049 static void deprecatedVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
7050 {
7051     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
7052     UseCounter::countDeprecation(callingExecutionContext(info.GetIsolate()), UseCounter::voidMethod);
7053     TestObjectPythonV8Internal::deprecatedVoidMethodMethod(info);
7054     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
7055 }
7056
7057 static void doNotCheckSignatureVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
7058 {
7059     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
7060     impl->doNotCheckSignatureVoidMethod();
7061 }
7062
7063 static void doNotCheckSignatureVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
7064 {
7065     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
7066     TestObjectPythonV8Internal::doNotCheckSignatureVoidMethodMethod(info);
7067     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
7068 }
7069
7070 static void implementedAsVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
7071 {
7072     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
7073     impl->implementedAsMethodName();
7074 }
7075
7076 static void implementedAsVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
7077 {
7078     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
7079     TestObjectPythonV8Internal::implementedAsVoidMethodMethod(info);
7080     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
7081 }
7082
7083 static void measureAsVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
7084 {
7085     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
7086     impl->measureAsVoidMethod();
7087 }
7088
7089 static void measureAsVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
7090 {
7091     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
7092     UseCounter::count(callingExecutionContext(info.GetIsolate()), UseCounter::TestFeature);
7093     TestObjectPythonV8Internal::measureAsVoidMethodMethod(info);
7094     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
7095 }
7096
7097 static void notEnumerableVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
7098 {
7099     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
7100     impl->notEnumerableVoidMethod();
7101 }
7102
7103 static void notEnumerableVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
7104 {
7105     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
7106     TestObjectPythonV8Internal::notEnumerableVoidMethodMethod(info);
7107     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
7108 }
7109
7110 static void perContextEnabledVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
7111 {
7112     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
7113     impl->perContextEnabledVoidMethod();
7114 }
7115
7116 static void perContextEnabledVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
7117 {
7118     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
7119     TestObjectPythonV8Internal::perContextEnabledVoidMethodMethod(info);
7120     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
7121 }
7122
7123 static void perWorldBindingsVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
7124 {
7125     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
7126     impl->perWorldBindingsVoidMethod();
7127 }
7128
7129 static void perWorldBindingsVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
7130 {
7131     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
7132     TestObjectPythonV8Internal::perWorldBindingsVoidMethodMethod(info);
7133     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
7134 }
7135
7136 static void perWorldBindingsVoidMethodMethodForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info)
7137 {
7138     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
7139     impl->perWorldBindingsVoidMethod();
7140 }
7141
7142 static void perWorldBindingsVoidMethodMethodCallbackForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info)
7143 {
7144     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
7145     TestObjectPythonV8Internal::perWorldBindingsVoidMethodMethodForMainWorld(info);
7146     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
7147 }
7148
7149 static void perWorldBindingsVoidMethodTestInterfaceEmptyArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
7150 {
7151     if (UNLIKELY(info.Length() < 1)) {
7152         throwTypeError(ExceptionMessages::failedToExecute("perWorldBindingsVoidMethodTestInterfaceEmptyArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate());
7153         return;
7154     }
7155     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
7156     V8TRYCATCH_VOID(TestInterfaceEmpty*, testInterfaceEmptyArg, V8TestInterfaceEmpty::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
7157     impl->perWorldBindingsVoidMethodTestInterfaceEmptyArg(testInterfaceEmptyArg);
7158 }
7159
7160 static void perWorldBindingsVoidMethodTestInterfaceEmptyArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
7161 {
7162     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
7163     TestObjectPythonV8Internal::perWorldBindingsVoidMethodTestInterfaceEmptyArgMethod(info);
7164     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
7165 }
7166
7167 static void perWorldBindingsVoidMethodTestInterfaceEmptyArgMethodForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info)
7168 {
7169     if (UNLIKELY(info.Length() < 1)) {
7170         throwTypeError(ExceptionMessages::failedToExecute("perWorldBindingsVoidMethodTestInterfaceEmptyArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate());
7171         return;
7172     }
7173     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
7174     V8TRYCATCH_VOID(TestInterfaceEmpty*, testInterfaceEmptyArg, V8TestInterfaceEmpty::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
7175     impl->perWorldBindingsVoidMethodTestInterfaceEmptyArg(testInterfaceEmptyArg);
7176 }
7177
7178 static void perWorldBindingsVoidMethodTestInterfaceEmptyArgMethodCallbackForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info)
7179 {
7180     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
7181     TestObjectPythonV8Internal::perWorldBindingsVoidMethodTestInterfaceEmptyArgMethodForMainWorld(info);
7182     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
7183 }
7184
7185 static void activityLoggingForAllWorldsPerWorldBindingsVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
7186 {
7187     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
7188     impl->activityLoggingForAllWorldsPerWorldBindingsVoidMethod();
7189 }
7190
7191 static void activityLoggingForAllWorldsPerWorldBindingsVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
7192 {
7193     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
7194     V8PerContextData* contextData = V8PerContextData::from(info.GetIsolate()->GetCurrentContext());
7195     if (contextData && contextData->activityLogger()) {
7196         Vector<v8::Handle<v8::Value> > loggerArgs = toNativeArguments<v8::Handle<v8::Value> >(info, 0);
7197         contextData->activityLogger()->log("TestObjectPython.activityLoggingForAllWorldsPerWorldBindingsVoidMethod", info.Length(), loggerArgs.data(), "Method");
7198     }
7199     TestObjectPythonV8Internal::activityLoggingForAllWorldsPerWorldBindingsVoidMethodMethod(info);
7200     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
7201 }
7202
7203 static void activityLoggingForAllWorldsPerWorldBindingsVoidMethodMethodForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info)
7204 {
7205     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
7206     impl->activityLoggingForAllWorldsPerWorldBindingsVoidMethod();
7207 }
7208
7209 static void activityLoggingForAllWorldsPerWorldBindingsVoidMethodMethodCallbackForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info)
7210 {
7211     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
7212     V8PerContextData* contextData = V8PerContextData::from(info.GetIsolate()->GetCurrentContext());
7213     if (contextData && contextData->activityLogger()) {
7214         Vector<v8::Handle<v8::Value> > loggerArgs = toNativeArguments<v8::Handle<v8::Value> >(info, 0);
7215         contextData->activityLogger()->log("TestObjectPython.activityLoggingForAllWorldsPerWorldBindingsVoidMethod", info.Length(), loggerArgs.data(), "Method");
7216     }
7217     TestObjectPythonV8Internal::activityLoggingForAllWorldsPerWorldBindingsVoidMethodMethodForMainWorld(info);
7218     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
7219 }
7220
7221 static void activityLoggingForIsolatedWorldsPerWorldBindingsVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
7222 {
7223     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
7224     impl->activityLoggingForIsolatedWorldsPerWorldBindingsVoidMethod();
7225 }
7226
7227 static void activityLoggingForIsolatedWorldsPerWorldBindingsVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
7228 {
7229     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
7230     V8PerContextData* contextData = V8PerContextData::from(info.GetIsolate()->GetCurrentContext());
7231     if (contextData && contextData->activityLogger()) {
7232         Vector<v8::Handle<v8::Value> > loggerArgs = toNativeArguments<v8::Handle<v8::Value> >(info, 0);
7233         contextData->activityLogger()->log("TestObjectPython.activityLoggingForIsolatedWorldsPerWorldBindingsVoidMethod", info.Length(), loggerArgs.data(), "Method");
7234     }
7235     TestObjectPythonV8Internal::activityLoggingForIsolatedWorldsPerWorldBindingsVoidMethodMethod(info);
7236     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
7237 }
7238
7239 static void activityLoggingForIsolatedWorldsPerWorldBindingsVoidMethodMethodForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info)
7240 {
7241     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
7242     impl->activityLoggingForIsolatedWorldsPerWorldBindingsVoidMethod();
7243 }
7244
7245 static void activityLoggingForIsolatedWorldsPerWorldBindingsVoidMethodMethodCallbackForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info)
7246 {
7247     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
7248     TestObjectPythonV8Internal::activityLoggingForIsolatedWorldsPerWorldBindingsVoidMethodMethodForMainWorld(info);
7249     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
7250 }
7251
7252 static void raisesExceptionVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
7253 {
7254     ExceptionState exceptionState(ExceptionState::ExecutionContext, "raisesExceptionVoidMethod", "TestObjectPython", info.Holder(), info.GetIsolate());
7255     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
7256     impl->raisesExceptionVoidMethod(exceptionState);
7257     if (exceptionState.throwIfNeeded())
7258         return;
7259 }
7260
7261 static void raisesExceptionVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
7262 {
7263     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
7264     TestObjectPythonV8Internal::raisesExceptionVoidMethodMethod(info);
7265     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
7266 }
7267
7268 static void raisesExceptionStringMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
7269 {
7270     ExceptionState exceptionState(ExceptionState::ExecutionContext, "raisesExceptionStringMethod", "TestObjectPython", info.Holder(), info.GetIsolate());
7271     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
7272     String result = impl->raisesExceptionStringMethod(exceptionState);
7273     if (exceptionState.throwIfNeeded())
7274         return;
7275     v8SetReturnValueString(info, result, info.GetIsolate());
7276 }
7277
7278 static void raisesExceptionStringMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
7279 {
7280     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
7281     TestObjectPythonV8Internal::raisesExceptionStringMethodMethod(info);
7282     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
7283 }
7284
7285 static void raisesExceptionVoidMethodOptionalLongArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
7286 {
7287     ExceptionState exceptionState(ExceptionState::ExecutionContext, "raisesExceptionVoidMethodOptionalLongArg", "TestObjectPython", info.Holder(), info.GetIsolate());
7288     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
7289     if (UNLIKELY(info.Length() <= 0)) {
7290         impl->raisesExceptionVoidMethodOptionalLongArg(exceptionState);
7291         if (exceptionState.throwIfNeeded())
7292             return;
7293         return;
7294     }
7295     V8TRYCATCH_EXCEPTION_VOID(int, optionalLongArg, toInt32(info[0], exceptionState), exceptionState);
7296     impl->raisesExceptionVoidMethodOptionalLongArg(optionalLongArg, exceptionState);
7297     if (exceptionState.throwIfNeeded())
7298         return;
7299 }
7300
7301 static void raisesExceptionVoidMethodOptionalLongArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
7302 {
7303     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
7304     TestObjectPythonV8Internal::raisesExceptionVoidMethodOptionalLongArgMethod(info);
7305     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
7306 }
7307
7308 static void raisesExceptionVoidMethodTestCallbackInterfaceArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
7309 {
7310     ExceptionState exceptionState(ExceptionState::ExecutionContext, "raisesExceptionVoidMethodTestCallbackInterfaceArg", "TestObjectPython", info.Holder(), info.GetIsolate());
7311     if (UNLIKELY(info.Length() < 1)) {
7312         exceptionState.throwTypeError(ExceptionMessages::notEnoughArguments(1, info.Length()));
7313         exceptionState.throwIfNeeded();
7314         return;
7315     }
7316     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
7317     if (info.Length() <= 0 || !info[0]->IsFunction()) {
7318         exceptionState.throwTypeError("The callback provided as parameter 1 is not a function.");
7319         exceptionState.throwIfNeeded();
7320         return;
7321     }
7322     OwnPtr<TestCallbackInterface> testCallbackInterfaceArg = V8TestCallbackInterface::create(v8::Handle<v8::Function>::Cast(info[0]), currentExecutionContext(info.GetIsolate()));
7323     impl->raisesExceptionVoidMethodTestCallbackInterfaceArg(testCallbackInterfaceArg.release(), exceptionState);
7324     if (exceptionState.throwIfNeeded())
7325         return;
7326 }
7327
7328 static void raisesExceptionVoidMethodTestCallbackInterfaceArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
7329 {
7330     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
7331     TestObjectPythonV8Internal::raisesExceptionVoidMethodTestCallbackInterfaceArgMethod(info);
7332     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
7333 }
7334
7335 static void raisesExceptionVoidMethodOptionalTestCallbackInterfaceArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
7336 {
7337     ExceptionState exceptionState(ExceptionState::ExecutionContext, "raisesExceptionVoidMethodOptionalTestCallbackInterfaceArg", "TestObjectPython", info.Holder(), info.GetIsolate());
7338     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
7339     OwnPtr<TestCallbackInterface> optionalTestCallbackInterfaceArg;
7340     if (info.Length() > 0 && !isUndefinedOrNull(info[0])) {
7341         if (!info[0]->IsFunction()) {
7342             exceptionState.throwTypeError("The callback provided as parameter 1 is not a function.");
7343             exceptionState.throwIfNeeded();
7344             return;
7345         }
7346         optionalTestCallbackInterfaceArg = V8TestCallbackInterface::create(v8::Handle<v8::Function>::Cast(info[0]), currentExecutionContext(info.GetIsolate()));
7347     }
7348     impl->raisesExceptionVoidMethodOptionalTestCallbackInterfaceArg(optionalTestCallbackInterfaceArg.release(), exceptionState);
7349     if (exceptionState.throwIfNeeded())
7350         return;
7351 }
7352
7353 static void raisesExceptionVoidMethodOptionalTestCallbackInterfaceArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
7354 {
7355     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
7356     TestObjectPythonV8Internal::raisesExceptionVoidMethodOptionalTestCallbackInterfaceArgMethod(info);
7357     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
7358 }
7359
7360 static void raisesExceptionTestInterfaceEmptyVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
7361 {
7362     ExceptionState exceptionState(ExceptionState::ExecutionContext, "raisesExceptionTestInterfaceEmptyVoidMethod", "TestObjectPython", info.Holder(), info.GetIsolate());
7363     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
7364     RefPtr<TestInterfaceEmpty> result = impl->raisesExceptionTestInterfaceEmptyVoidMethod(exceptionState);
7365     if (exceptionState.throwIfNeeded())
7366         return;
7367     v8SetReturnValue(info, result.release());
7368 }
7369
7370 static void raisesExceptionTestInterfaceEmptyVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
7371 {
7372     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
7373     TestObjectPythonV8Internal::raisesExceptionTestInterfaceEmptyVoidMethodMethod(info);
7374     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
7375 }
7376
7377 static void readOnlyVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
7378 {
7379     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
7380     impl->readOnlyVoidMethod();
7381 }
7382
7383 static void readOnlyVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
7384 {
7385     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
7386     TestObjectPythonV8Internal::readOnlyVoidMethodMethod(info);
7387     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
7388 }
7389
7390 static void notEnumerableReadOnlyVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
7391 {
7392     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
7393     impl->notEnumerableReadOnlyVoidMethod();
7394 }
7395
7396 static void notEnumerableReadOnlyVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
7397 {
7398     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
7399     TestObjectPythonV8Internal::notEnumerableReadOnlyVoidMethodMethod(info);
7400     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
7401 }
7402
7403 static void runtimeEnabledVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
7404 {
7405     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
7406     impl->runtimeEnabledVoidMethod();
7407 }
7408
7409 static void runtimeEnabledVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
7410 {
7411     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
7412     TestObjectPythonV8Internal::runtimeEnabledVoidMethodMethod(info);
7413     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
7414 }
7415
7416 static void perWorldBindingsRuntimeEnabledVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
7417 {
7418     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
7419     impl->perWorldBindingsRuntimeEnabledVoidMethod();
7420 }
7421
7422 static void perWorldBindingsRuntimeEnabledVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
7423 {
7424     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
7425     TestObjectPythonV8Internal::perWorldBindingsRuntimeEnabledVoidMethodMethod(info);
7426     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
7427 }
7428
7429 static void perWorldBindingsRuntimeEnabledVoidMethodMethodForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info)
7430 {
7431     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
7432     impl->perWorldBindingsRuntimeEnabledVoidMethod();
7433 }
7434
7435 static void perWorldBindingsRuntimeEnabledVoidMethodMethodCallbackForMainWorld(const v8::FunctionCallbackInfo<v8::Value>& info)
7436 {
7437     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
7438     TestObjectPythonV8Internal::perWorldBindingsRuntimeEnabledVoidMethodMethodForMainWorld(info);
7439     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
7440 }
7441
7442 static void strictTypeCheckingVoidMethodTestInterfaceEmptyArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
7443 {
7444     if (UNLIKELY(info.Length() < 1)) {
7445         throwTypeError(ExceptionMessages::failedToExecute("strictTypeCheckingVoidMethodTestInterfaceEmptyArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate());
7446         return;
7447     }
7448     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
7449     if (info.Length() > 0 && !V8TestInterfaceEmpty::hasInstance(info[0], info.GetIsolate())) {
7450         throwTypeError(ExceptionMessages::failedToExecute("strictTypeCheckingVoidMethodTestInterfaceEmptyArg", "TestObjectPython", "parameter 1 is not of type 'TestInterfaceEmpty'."), info.GetIsolate());
7451         return;
7452     }
7453     V8TRYCATCH_VOID(TestInterfaceEmpty*, testInterfaceEmptyArg, V8TestInterfaceEmpty::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
7454     impl->strictTypeCheckingVoidMethodTestInterfaceEmptyArg(testInterfaceEmptyArg);
7455 }
7456
7457 static void strictTypeCheckingVoidMethodTestInterfaceEmptyArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
7458 {
7459     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
7460     TestObjectPythonV8Internal::strictTypeCheckingVoidMethodTestInterfaceEmptyArgMethod(info);
7461     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
7462 }
7463
7464 static void strictTypeCheckingVoidMethodTestInterfaceEmptyOrNullArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
7465 {
7466     if (UNLIKELY(info.Length() < 1)) {
7467         throwTypeError(ExceptionMessages::failedToExecute("strictTypeCheckingVoidMethodTestInterfaceEmptyOrNullArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate());
7468         return;
7469     }
7470     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
7471     if (info.Length() > 0 && !isUndefinedOrNull(info[0]) && !V8TestInterfaceEmpty::hasInstance(info[0], info.GetIsolate())) {
7472         throwTypeError(ExceptionMessages::failedToExecute("strictTypeCheckingVoidMethodTestInterfaceEmptyOrNullArg", "TestObjectPython", "parameter 1 is not of type 'TestInterfaceEmpty'."), info.GetIsolate());
7473         return;
7474     }
7475     V8TRYCATCH_VOID(TestInterfaceEmpty*, testInterfaceEmptyArg, V8TestInterfaceEmpty::toNativeWithTypeCheck(info.GetIsolate(), info[0]));
7476     impl->strictTypeCheckingVoidMethodTestInterfaceEmptyOrNullArg(testInterfaceEmptyArg);
7477 }
7478
7479 static void strictTypeCheckingVoidMethodTestInterfaceEmptyOrNullArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
7480 {
7481     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
7482     TestObjectPythonV8Internal::strictTypeCheckingVoidMethodTestInterfaceEmptyOrNullArgMethod(info);
7483     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
7484 }
7485
7486 static void treatReturnedNullStringAsNullStringMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
7487 {
7488     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
7489     v8SetReturnValueStringOrNull(info, impl->treatReturnedNullStringAsNullStringMethod(), info.GetIsolate());
7490 }
7491
7492 static void treatReturnedNullStringAsNullStringMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
7493 {
7494     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
7495     TestObjectPythonV8Internal::treatReturnedNullStringAsNullStringMethodMethod(info);
7496     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
7497 }
7498
7499 static void treatReturnedNullStringAsUndefinedStringMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
7500 {
7501     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
7502     v8SetReturnValueStringOrUndefined(info, impl->treatReturnedNullStringAsUndefinedStringMethod(), info.GetIsolate());
7503 }
7504
7505 static void treatReturnedNullStringAsUndefinedStringMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
7506 {
7507     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
7508     TestObjectPythonV8Internal::treatReturnedNullStringAsUndefinedStringMethodMethod(info);
7509     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
7510 }
7511
7512 static void unforgeableVoidMethodMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
7513 {
7514     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
7515     impl->unforgeableVoidMethod();
7516 }
7517
7518 static void unforgeableVoidMethodMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
7519 {
7520     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
7521     TestObjectPythonV8Internal::unforgeableVoidMethodMethod(info);
7522     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
7523 }
7524
7525 static void voidMethodTestInterfaceWillBeGarbageCollectedSequenceArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
7526 {
7527     if (UNLIKELY(info.Length() < 1)) {
7528         throwTypeError(ExceptionMessages::failedToExecute("voidMethodTestInterfaceWillBeGarbageCollectedSequenceArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate());
7529         return;
7530     }
7531     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
7532     V8TRYCATCH_VOID(WillBeHeapVector<RefPtrWillBeMember<TestInterfaceWillBeGarbageCollected> >, testInterfaceWillBeGarbageCollectedSequenceArg, (toMemberNativeArray<TestInterfaceWillBeGarbageCollected, V8TestInterfaceWillBeGarbageCollected>(info[0], 1, info.GetIsolate())));
7533     impl->voidMethodTestInterfaceWillBeGarbageCollectedSequenceArg(testInterfaceWillBeGarbageCollectedSequenceArg);
7534 }
7535
7536 static void voidMethodTestInterfaceWillBeGarbageCollectedSequenceArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
7537 {
7538     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
7539     TestObjectPythonV8Internal::voidMethodTestInterfaceWillBeGarbageCollectedSequenceArgMethod(info);
7540     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
7541 }
7542
7543 static void voidMethodTestInterfaceWillBeGarbageCollectedArrayArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
7544 {
7545     if (UNLIKELY(info.Length() < 1)) {
7546         throwTypeError(ExceptionMessages::failedToExecute("voidMethodTestInterfaceWillBeGarbageCollectedArrayArg", "TestObjectPython", ExceptionMessages::notEnoughArguments(1, info.Length())), info.GetIsolate());
7547         return;
7548     }
7549     TestObjectPython* impl = V8TestObjectPython::toNative(info.Holder());
7550     V8TRYCATCH_VOID(WillBeHeapVector<RefPtrWillBeMember<TestInterfaceWillBeGarbageCollected> >, testInterfaceWillBeGarbageCollectedArrayArg, (toMemberNativeArray<TestInterfaceWillBeGarbageCollected, V8TestInterfaceWillBeGarbageCollected>(info[0], 1, info.GetIsolate())));
7551     impl->voidMethodTestInterfaceWillBeGarbageCollectedArrayArg(testInterfaceWillBeGarbageCollectedArrayArg);
7552 }
7553
7554 static void voidMethodTestInterfaceWillBeGarbageCollectedArrayArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
7555 {
7556     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
7557     TestObjectPythonV8Internal::voidMethodTestInterfaceWillBeGarbageCollectedArrayArgMethod(info);
7558     TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
7559 }
7560
7561 } // namespace TestObjectPythonV8Internal
7562
7563 static const V8DOMConfiguration::AttributeConfiguration V8TestObjectPythonAttributes[] = {
7564     {"readonlyStringAttribute", TestObjectPythonV8Internal::readonlyStringAttributeAttributeGetterCallback, 0, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7565     {"readonlyTestInterfaceEmptyAttribute", TestObjectPythonV8Internal::readonlyTestInterfaceEmptyAttributeAttributeGetterCallback, 0, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7566     {"readonlyLongAttribute", TestObjectPythonV8Internal::readonlyLongAttributeAttributeGetterCallback, 0, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7567     {"dateAttribute", TestObjectPythonV8Internal::dateAttributeAttributeGetterCallback, TestObjectPythonV8Internal::dateAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7568     {"stringAttribute", TestObjectPythonV8Internal::stringAttributeAttributeGetterCallback, TestObjectPythonV8Internal::stringAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7569     {"readonlyDOMTimeStampAttribute", TestObjectPythonV8Internal::readonlyDOMTimeStampAttributeAttributeGetterCallback, 0, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7570     {"booleanAttribute", TestObjectPythonV8Internal::booleanAttributeAttributeGetterCallback, TestObjectPythonV8Internal::booleanAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7571     {"byteAttribute", TestObjectPythonV8Internal::byteAttributeAttributeGetterCallback, TestObjectPythonV8Internal::byteAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7572     {"doubleAttribute", TestObjectPythonV8Internal::doubleAttributeAttributeGetterCallback, TestObjectPythonV8Internal::doubleAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7573     {"floatAttribute", TestObjectPythonV8Internal::floatAttributeAttributeGetterCallback, TestObjectPythonV8Internal::floatAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7574     {"longAttribute", TestObjectPythonV8Internal::longAttributeAttributeGetterCallback, TestObjectPythonV8Internal::longAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7575     {"longLongAttribute", TestObjectPythonV8Internal::longLongAttributeAttributeGetterCallback, TestObjectPythonV8Internal::longLongAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7576     {"octetAttribute", TestObjectPythonV8Internal::octetAttributeAttributeGetterCallback, TestObjectPythonV8Internal::octetAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7577     {"shortAttribute", TestObjectPythonV8Internal::shortAttributeAttributeGetterCallback, TestObjectPythonV8Internal::shortAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7578     {"unsignedLongAttribute", TestObjectPythonV8Internal::unsignedLongAttributeAttributeGetterCallback, TestObjectPythonV8Internal::unsignedLongAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7579     {"unsignedLongLongAttribute", TestObjectPythonV8Internal::unsignedLongLongAttributeAttributeGetterCallback, TestObjectPythonV8Internal::unsignedLongLongAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7580     {"unsignedShortAttribute", TestObjectPythonV8Internal::unsignedShortAttributeAttributeGetterCallback, TestObjectPythonV8Internal::unsignedShortAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7581     {"testInterfaceEmptyAttribute", TestObjectPythonV8Internal::testInterfaceEmptyAttributeAttributeGetterCallback, TestObjectPythonV8Internal::testInterfaceEmptyAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7582     {"testObjectPythonAttribute", TestObjectPythonV8Internal::testObjectPythonAttributeAttributeGetterCallback, TestObjectPythonV8Internal::testObjectPythonAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7583     {"voidCallbackFunctionAttribute", TestObjectPythonV8Internal::voidCallbackFunctionAttributeAttributeGetterCallback, TestObjectPythonV8Internal::voidCallbackFunctionAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7584     {"anyCallbackFunctionOptionalAnyArgAttribute", TestObjectPythonV8Internal::anyCallbackFunctionOptionalAnyArgAttributeAttributeGetterCallback, TestObjectPythonV8Internal::anyCallbackFunctionOptionalAnyArgAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7585     {"cssAttribute", TestObjectPythonV8Internal::cssAttributeAttributeGetterCallback, TestObjectPythonV8Internal::cssAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7586     {"imeAttribute", TestObjectPythonV8Internal::imeAttributeAttributeGetterCallback, TestObjectPythonV8Internal::imeAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7587     {"svgAttribute", TestObjectPythonV8Internal::svgAttributeAttributeGetterCallback, TestObjectPythonV8Internal::svgAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7588     {"xmlAttribute", TestObjectPythonV8Internal::xmlAttributeAttributeGetterCallback, TestObjectPythonV8Internal::xmlAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7589     {"nodeFilterAttribute", TestObjectPythonV8Internal::nodeFilterAttributeAttributeGetterCallback, TestObjectPythonV8Internal::nodeFilterAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7590     {"serializedScriptValueAttribute", TestObjectPythonV8Internal::serializedScriptValueAttributeAttributeGetterCallback, TestObjectPythonV8Internal::serializedScriptValueAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7591     {"anyAttribute", TestObjectPythonV8Internal::anyAttributeAttributeGetterCallback, TestObjectPythonV8Internal::anyAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7592     {"promiseAttribute", TestObjectPythonV8Internal::promiseAttributeAttributeGetterCallback, TestObjectPythonV8Internal::promiseAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7593     {"windowAttribute", TestObjectPythonV8Internal::windowAttributeAttributeGetterCallback, TestObjectPythonV8Internal::windowAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7594     {"documentAttribute", TestObjectPythonV8Internal::documentAttributeAttributeGetterCallback, TestObjectPythonV8Internal::documentAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7595     {"documentFragmentAttribute", TestObjectPythonV8Internal::documentFragmentAttributeAttributeGetterCallback, TestObjectPythonV8Internal::documentFragmentAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7596     {"documentTypeAttribute", TestObjectPythonV8Internal::documentTypeAttributeAttributeGetterCallback, TestObjectPythonV8Internal::documentTypeAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7597     {"elementAttribute", TestObjectPythonV8Internal::elementAttributeAttributeGetterCallback, TestObjectPythonV8Internal::elementAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7598     {"nodeAttribute", TestObjectPythonV8Internal::nodeAttributeAttributeGetterCallback, TestObjectPythonV8Internal::nodeAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7599     {"shadowRootAttribute", TestObjectPythonV8Internal::shadowRootAttributeAttributeGetterCallback, TestObjectPythonV8Internal::shadowRootAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7600     {"arrayBufferAttribute", TestObjectPythonV8Internal::arrayBufferAttributeAttributeGetterCallback, TestObjectPythonV8Internal::arrayBufferAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7601     {"float32ArrayAttribute", TestObjectPythonV8Internal::float32ArrayAttributeAttributeGetterCallback, TestObjectPythonV8Internal::float32ArrayAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7602     {"uint8ArrayAttribute", TestObjectPythonV8Internal::uint8ArrayAttributeAttributeGetterCallback, TestObjectPythonV8Internal::uint8ArrayAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7603     {"self", TestObjectPythonV8Internal::selfAttributeGetterCallback, 0, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7604     {"readonlyEventTargetAttribute", TestObjectPythonV8Internal::readonlyEventTargetAttributeAttributeGetterCallback, 0, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7605     {"readonlyEventTargetOrNullAttribute", TestObjectPythonV8Internal::readonlyEventTargetOrNullAttributeAttributeGetterCallback, 0, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7606     {"readonlyWindowAttribute", TestObjectPythonV8Internal::readonlyWindowAttributeAttributeGetterCallback, 0, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7607     {"htmlCollectionAttribute", TestObjectPythonV8Internal::htmlCollectionAttributeAttributeGetterCallback, 0, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7608     {"htmlElementAttribute", TestObjectPythonV8Internal::htmlElementAttributeAttributeGetterCallback, 0, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7609     {"stringArrayAttribute", TestObjectPythonV8Internal::stringArrayAttributeAttributeGetterCallback, TestObjectPythonV8Internal::stringArrayAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7610     {"testInterfaceEmptyArrayAttribute", TestObjectPythonV8Internal::testInterfaceEmptyArrayAttributeAttributeGetterCallback, TestObjectPythonV8Internal::testInterfaceEmptyArrayAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7611     {"floatArrayAttribute", TestObjectPythonV8Internal::floatArrayAttributeAttributeGetterCallback, TestObjectPythonV8Internal::floatArrayAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7612     {"stringOrNullAttribute", TestObjectPythonV8Internal::stringOrNullAttributeAttributeGetterCallback, TestObjectPythonV8Internal::stringOrNullAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7613     {"longOrNullAttribute", TestObjectPythonV8Internal::longOrNullAttributeAttributeGetterCallback, TestObjectPythonV8Internal::longOrNullAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7614     {"testInterfaceOrNullAttribute", TestObjectPythonV8Internal::testInterfaceOrNullAttributeAttributeGetterCallback, TestObjectPythonV8Internal::testInterfaceOrNullAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7615     {"testEnumAttribute", TestObjectPythonV8Internal::testEnumAttributeAttributeGetterCallback, TestObjectPythonV8Internal::testEnumAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7616     {"testObjectAConstructorAttribute", TestObjectPythonV8Internal::TestObjectPythonConstructorGetter, TestObjectPythonV8Internal::TestObjectPythonReplaceableAttributeSetterCallback, 0, 0, const_cast<WrapperTypeInfo*>(&V8TestObjectA::wrapperTypeInfo), static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::DontEnum), 0 /* on instance */},
7617     {"eventHandlerAttribute", TestObjectPythonV8Internal::eventHandlerAttributeAttributeGetterCallback, TestObjectPythonV8Internal::eventHandlerAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7618     {"activityLoggingAccessForAllWorldsLongAttribute", TestObjectPythonV8Internal::activityLoggingAccessForAllWorldsLongAttributeAttributeGetterCallback, TestObjectPythonV8Internal::activityLoggingAccessForAllWorldsLongAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7619     {"activityLoggingGetterForAllWorldsLongAttribute", TestObjectPythonV8Internal::activityLoggingGetterForAllWorldsLongAttributeAttributeGetterCallback, TestObjectPythonV8Internal::activityLoggingGetterForAllWorldsLongAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7620     {"activityLoggingSetterForAllWorldsLongAttribute", TestObjectPythonV8Internal::activityLoggingSetterForAllWorldsLongAttributeAttributeGetterCallback, TestObjectPythonV8Internal::activityLoggingSetterForAllWorldsLongAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7621     {"cachedAttributeAnyAttribute", TestObjectPythonV8Internal::cachedAttributeAnyAttributeAttributeGetterCallback, TestObjectPythonV8Internal::cachedAttributeAnyAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7622     {"callWithExecutionContextAnyAttribute", TestObjectPythonV8Internal::callWithExecutionContextAnyAttributeAttributeGetterCallback, TestObjectPythonV8Internal::callWithExecutionContextAnyAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7623     {"checkSecurityForNodeReadonlyDocumentAttribute", TestObjectPythonV8Internal::checkSecurityForNodeReadonlyDocumentAttributeAttributeGetterCallback, 0, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7624 #if ENABLE(CONDITION)
7625     {"conditionalLongAttribute", TestObjectPythonV8Internal::conditionalLongAttributeAttributeGetterCallback, TestObjectPythonV8Internal::conditionalLongAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7626 #endif // ENABLE(CONDITION)
7627 #if ENABLE(CONDITION_1) && ENABLE(CONDITION_2)
7628     {"conditionalAndLongAttribute", TestObjectPythonV8Internal::conditionalAndLongAttributeAttributeGetterCallback, TestObjectPythonV8Internal::conditionalAndLongAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7629 #endif // ENABLE(CONDITION_1) && ENABLE(CONDITION_2)
7630 #if ENABLE(CONDITION_1) || ENABLE(CONDITION_2)
7631     {"conditionalOrLongAttribute", TestObjectPythonV8Internal::conditionalOrLongAttributeAttributeGetterCallback, TestObjectPythonV8Internal::conditionalOrLongAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7632 #endif // ENABLE(CONDITION_1) || ENABLE(CONDITION_2)
7633     {"customObjectAttribute", TestObjectPythonV8Internal::customObjectAttributeAttributeGetterCallback, TestObjectPythonV8Internal::customObjectAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7634     {"customGetterLongAttribute", TestObjectPythonV8Internal::customGetterLongAttributeAttributeGetterCallback, TestObjectPythonV8Internal::customGetterLongAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7635     {"customGetterReadonlyObjectAttribute", TestObjectPythonV8Internal::customGetterReadonlyObjectAttributeAttributeGetterCallback, 0, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7636     {"customSetterLongAttribute", TestObjectPythonV8Internal::customSetterLongAttributeAttributeGetterCallback, TestObjectPythonV8Internal::customSetterLongAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7637 #if ENABLE(CONDITION)
7638     {"customLongAttribute", TestObjectPythonV8Internal::customLongAttributeAttributeGetterCallback, TestObjectPythonV8Internal::customLongAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7639 #endif // ENABLE(CONDITION)
7640     {"customElementsCallbacksReadonlyLongAttribute", TestObjectPythonV8Internal::customElementsCallbacksReadonlyLongAttributeAttributeGetterCallback, 0, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7641     {"deprecatedLongAttribute", TestObjectPythonV8Internal::deprecatedLongAttributeAttributeGetterCallback, TestObjectPythonV8Internal::deprecatedLongAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7642     {"enforceRangeLongAttribute", TestObjectPythonV8Internal::enforceRangeLongAttributeAttributeGetterCallback, TestObjectPythonV8Internal::enforceRangeLongAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7643     {"implementedAsLongAttribute", TestObjectPythonV8Internal::implementedAsLongAttributeAttributeGetterCallback, TestObjectPythonV8Internal::implementedAsLongAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7644     {"customImplementedAsLongAttribute", TestObjectPythonV8Internal::customImplementedAsLongAttributeAttributeGetterCallback, TestObjectPythonV8Internal::customImplementedAsLongAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7645     {"customGetterImplementedAsLongAttribute", TestObjectPythonV8Internal::customGetterImplementedAsLongAttributeAttributeGetterCallback, TestObjectPythonV8Internal::customGetterImplementedAsLongAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7646     {"customSetterImplementedAsLongAttribute", TestObjectPythonV8Internal::customSetterImplementedAsLongAttributeAttributeGetterCallback, TestObjectPythonV8Internal::customSetterImplementedAsLongAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7647     {"measureAsLongAttribute", TestObjectPythonV8Internal::measureAsLongAttributeAttributeGetterCallback, TestObjectPythonV8Internal::measureAsLongAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7648     {"notEnumerableLongAttribute", TestObjectPythonV8Internal::notEnumerableLongAttributeAttributeGetterCallback, TestObjectPythonV8Internal::notEnumerableLongAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::DontEnum), 0 /* on instance */},
7649     {"perWorldBindingsLongAttribute", TestObjectPythonV8Internal::perWorldBindingsLongAttributeAttributeGetterCallback, TestObjectPythonV8Internal::perWorldBindingsLongAttributeAttributeSetterCallback, TestObjectPythonV8Internal::perWorldBindingsLongAttributeAttributeGetterCallbackForMainWorld, TestObjectPythonV8Internal::perWorldBindingsLongAttributeAttributeSetterCallbackForMainWorld, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7650     {"perWorldBindingsReadonlyLongAttribute", TestObjectPythonV8Internal::perWorldBindingsReadonlyLongAttributeAttributeGetterCallback, 0, TestObjectPythonV8Internal::perWorldBindingsReadonlyLongAttributeAttributeGetterCallbackForMainWorld, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7651     {"perWorldBindingsReadonlyTestInterfaceEmptyAttribute", TestObjectPythonV8Internal::perWorldBindingsReadonlyTestInterfaceEmptyAttributeAttributeGetterCallback, 0, TestObjectPythonV8Internal::perWorldBindingsReadonlyTestInterfaceEmptyAttributeAttributeGetterCallbackForMainWorld, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7652     {"activityLoggingAccessPerWorldBindingsLongAttribute", TestObjectPythonV8Internal::activityLoggingAccessPerWorldBindingsLongAttributeAttributeGetterCallback, TestObjectPythonV8Internal::activityLoggingAccessPerWorldBindingsLongAttributeAttributeSetterCallback, TestObjectPythonV8Internal::activityLoggingAccessPerWorldBindingsLongAttributeAttributeGetterCallbackForMainWorld, TestObjectPythonV8Internal::activityLoggingAccessPerWorldBindingsLongAttributeAttributeSetterCallbackForMainWorld, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7653     {"activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttribute", TestObjectPythonV8Internal::activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttributeAttributeGetterCallback, TestObjectPythonV8Internal::activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttributeAttributeSetterCallback, TestObjectPythonV8Internal::activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttributeAttributeGetterCallbackForMainWorld, TestObjectPythonV8Internal::activityLoggingAccessForIsolatedWorldsPerWorldBindingsLongAttributeAttributeSetterCallbackForMainWorld, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7654     {"activityLoggingGetterPerWorldBindingsLongAttribute", TestObjectPythonV8Internal::activityLoggingGetterPerWorldBindingsLongAttributeAttributeGetterCallback, TestObjectPythonV8Internal::activityLoggingGetterPerWorldBindingsLongAttributeAttributeSetterCallback, TestObjectPythonV8Internal::activityLoggingGetterPerWorldBindingsLongAttributeAttributeGetterCallbackForMainWorld, TestObjectPythonV8Internal::activityLoggingGetterPerWorldBindingsLongAttributeAttributeSetterCallbackForMainWorld, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7655     {"activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttribute", TestObjectPythonV8Internal::activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttributeAttributeGetterCallback, TestObjectPythonV8Internal::activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttributeAttributeSetterCallback, TestObjectPythonV8Internal::activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttributeAttributeGetterCallbackForMainWorld, TestObjectPythonV8Internal::activityLoggingGetterForIsolatedWorldsPerWorldBindingsLongAttributeAttributeSetterCallbackForMainWorld, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7656     {"location", TestObjectPythonV8Internal::locationAttributeGetterCallback, TestObjectPythonV8Internal::locationAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7657     {"locationWithException", TestObjectPythonV8Internal::locationWithExceptionAttributeGetterCallback, TestObjectPythonV8Internal::locationWithExceptionAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7658     {"locationWithCallWith", TestObjectPythonV8Internal::locationWithCallWithAttributeGetterCallback, TestObjectPythonV8Internal::locationWithCallWithAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7659     {"locationWithPerWorldBindings", TestObjectPythonV8Internal::locationWithPerWorldBindingsAttributeGetterCallback, TestObjectPythonV8Internal::locationWithPerWorldBindingsAttributeSetterCallback, TestObjectPythonV8Internal::locationWithPerWorldBindingsAttributeGetterCallbackForMainWorld, TestObjectPythonV8Internal::locationWithPerWorldBindingsAttributeSetterCallbackForMainWorld, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7660     {"locationWillBeGarbageCollected", TestObjectPythonV8Internal::locationWillBeGarbageCollectedAttributeGetterCallback, TestObjectPythonV8Internal::locationWillBeGarbageCollectedAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7661     {"raisesExceptionLongAttribute", TestObjectPythonV8Internal::raisesExceptionLongAttributeAttributeGetterCallback, TestObjectPythonV8Internal::raisesExceptionLongAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7662     {"raisesExceptionGetterLongAttribute", TestObjectPythonV8Internal::raisesExceptionGetterLongAttributeAttributeGetterCallback, TestObjectPythonV8Internal::raisesExceptionGetterLongAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7663     {"setterRaisesExceptionLongAttribute", TestObjectPythonV8Internal::setterRaisesExceptionLongAttributeAttributeGetterCallback, TestObjectPythonV8Internal::setterRaisesExceptionLongAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7664     {"raisesExceptionTestInterfaceEmptyAttribute", TestObjectPythonV8Internal::raisesExceptionTestInterfaceEmptyAttributeAttributeGetterCallback, TestObjectPythonV8Internal::raisesExceptionTestInterfaceEmptyAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7665     {"cachedAttributeRaisesExceptionGetterAnyAttribute", TestObjectPythonV8Internal::cachedAttributeRaisesExceptionGetterAnyAttributeAttributeGetterCallback, TestObjectPythonV8Internal::cachedAttributeRaisesExceptionGetterAnyAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7666     {"reflectTestInterfaceAttribute", TestObjectPythonV8Internal::reflectTestInterfaceAttributeAttributeGetterCallback, TestObjectPythonV8Internal::reflectTestInterfaceAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7667     {"reflectReflectedNameAttributeTestAttribute", TestObjectPythonV8Internal::reflectReflectedNameAttributeTestAttributeAttributeGetterCallback, TestObjectPythonV8Internal::reflectReflectedNameAttributeTestAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7668     {"reflectBooleanAttribute", TestObjectPythonV8Internal::reflectBooleanAttributeAttributeGetterCallback, TestObjectPythonV8Internal::reflectBooleanAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7669     {"reflectLongAttribute", TestObjectPythonV8Internal::reflectLongAttributeAttributeGetterCallback, TestObjectPythonV8Internal::reflectLongAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7670     {"reflectUnsignedShortAttribute", TestObjectPythonV8Internal::reflectUnsignedShortAttributeAttributeGetterCallback, TestObjectPythonV8Internal::reflectUnsignedShortAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7671     {"reflectUnsignedLongAttribute", TestObjectPythonV8Internal::reflectUnsignedLongAttributeAttributeGetterCallback, TestObjectPythonV8Internal::reflectUnsignedLongAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7672     {"id", TestObjectPythonV8Internal::idAttributeGetterCallback, TestObjectPythonV8Internal::idAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7673     {"name", TestObjectPythonV8Internal::nameAttributeGetterCallback, TestObjectPythonV8Internal::nameAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7674     {"class", TestObjectPythonV8Internal::classAttributeGetterCallback, TestObjectPythonV8Internal::classAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7675     {"reflectedId", TestObjectPythonV8Internal::reflectedIdAttributeGetterCallback, TestObjectPythonV8Internal::reflectedIdAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7676     {"reflectedName", TestObjectPythonV8Internal::reflectedNameAttributeGetterCallback, TestObjectPythonV8Internal::reflectedNameAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7677     {"reflectedClass", TestObjectPythonV8Internal::reflectedClassAttributeGetterCallback, TestObjectPythonV8Internal::reflectedClassAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7678     {"limitedToOnlyOneAttribute", TestObjectPythonV8Internal::limitedToOnlyOneAttributeAttributeGetterCallback, TestObjectPythonV8Internal::limitedToOnlyOneAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7679     {"limitedToOnlyAttribute", TestObjectPythonV8Internal::limitedToOnlyAttributeAttributeGetterCallback, TestObjectPythonV8Internal::limitedToOnlyAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7680     {"limitedToOnlyOtherAttribute", TestObjectPythonV8Internal::limitedToOnlyOtherAttributeAttributeGetterCallback, TestObjectPythonV8Internal::limitedToOnlyOtherAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7681     {"limitedWithMissingDefaultAttribute", TestObjectPythonV8Internal::limitedWithMissingDefaultAttributeAttributeGetterCallback, TestObjectPythonV8Internal::limitedWithMissingDefaultAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7682     {"limitedWithInvalidMissingDefaultAttribute", TestObjectPythonV8Internal::limitedWithInvalidMissingDefaultAttributeAttributeGetterCallback, TestObjectPythonV8Internal::limitedWithInvalidMissingDefaultAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7683     {"corsSettingAttribute", TestObjectPythonV8Internal::corsSettingAttributeAttributeGetterCallback, 0, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7684     {"limitedWithEmptyMissingInvalidAttribute", TestObjectPythonV8Internal::limitedWithEmptyMissingInvalidAttributeAttributeGetterCallback, 0, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7685     {"replaceableReadonlyLongAttribute", TestObjectPythonV8Internal::replaceableReadonlyLongAttributeAttributeGetterCallback, TestObjectPythonV8Internal::TestObjectPythonReplaceableAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7686     {"locationReplaceable", TestObjectPythonV8Internal::locationReplaceableAttributeGetterCallback, TestObjectPythonV8Internal::locationReplaceableAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7687     {"setterCallWithActiveWindowAndFirstWindowStringAttribute", TestObjectPythonV8Internal::setterCallWithActiveWindowAndFirstWindowStringAttributeAttributeGetterCallback, TestObjectPythonV8Internal::setterCallWithActiveWindowAndFirstWindowStringAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7688     {"setterCallWithExecutionContextStringAttribute", TestObjectPythonV8Internal::setterCallWithExecutionContextStringAttributeAttributeGetterCallback, TestObjectPythonV8Internal::setterCallWithExecutionContextStringAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7689     {"strictTypeCheckingFloatAttribute", TestObjectPythonV8Internal::strictTypeCheckingFloatAttributeAttributeGetterCallback, TestObjectPythonV8Internal::strictTypeCheckingFloatAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7690     {"strictTypeCheckingTestInterfaceAttribute", TestObjectPythonV8Internal::strictTypeCheckingTestInterfaceAttributeAttributeGetterCallback, TestObjectPythonV8Internal::strictTypeCheckingTestInterfaceAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7691     {"treatNullAsNullStringStringAttribute", TestObjectPythonV8Internal::treatNullAsNullStringStringAttributeAttributeGetterCallback, TestObjectPythonV8Internal::treatNullAsNullStringStringAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7692     {"treatReturnedNullStringAsNullStringAttribute", TestObjectPythonV8Internal::treatReturnedNullStringAsNullStringAttributeAttributeGetterCallback, TestObjectPythonV8Internal::treatReturnedNullStringAsNullStringAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7693     {"treatReturnedNullStringAsUndefinedStringAttribute", TestObjectPythonV8Internal::treatReturnedNullStringAsUndefinedStringAttributeAttributeGetterCallback, TestObjectPythonV8Internal::treatReturnedNullStringAsUndefinedStringAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7694     {"urlStringAttribute", TestObjectPythonV8Internal::urlStringAttributeAttributeGetterCallback, TestObjectPythonV8Internal::urlStringAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7695     {"urlStringAttribute", TestObjectPythonV8Internal::urlStringAttributeAttributeGetterCallback, TestObjectPythonV8Internal::urlStringAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7696     {"unforgeableLongAttribute", TestObjectPythonV8Internal::unforgeableLongAttributeAttributeGetterCallback, TestObjectPythonV8Internal::unforgeableLongAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::PROHIBITS_OVERWRITING), static_cast<v8::PropertyAttribute>(v8::DontDelete), 0 /* on instance */},
7697     {"anotherStringAttribute", TestObjectPythonV8Internal::anotherStringAttributeAttributeGetterCallback, TestObjectPythonV8Internal::anotherStringAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7698     {"testInterfacePythonAttribute", TestObjectPythonV8Internal::testInterfacePythonAttributeAttributeGetterCallback, TestObjectPythonV8Internal::testInterfacePythonAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7699     {"testInterfaceWillBeGarbageCollectedAttribute", TestObjectPythonV8Internal::testInterfaceWillBeGarbageCollectedAttributeAttributeGetterCallback, TestObjectPythonV8Internal::testInterfaceWillBeGarbageCollectedAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7700     {"testInterfaceWillBeGarbageCollectedOrNullAttribute", TestObjectPythonV8Internal::testInterfaceWillBeGarbageCollectedOrNullAttributeAttributeGetterCallback, TestObjectPythonV8Internal::testInterfaceWillBeGarbageCollectedOrNullAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */},
7701 };
7702
7703 static const V8DOMConfiguration::AccessorConfiguration V8TestObjectPythonAccessors[] = {
7704     {"exposeJSAccessorsLongAttribute", TestObjectPythonV8Internal::exposeJSAccessorsLongAttributeAttributeGetterCallback, TestObjectPythonV8Internal::exposeJSAccessorsLongAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None)},
7705 };
7706
7707 static const V8DOMConfiguration::MethodConfiguration V8TestObjectPythonMethods[] = {
7708     {"voidMethod", TestObjectPythonV8Internal::voidMethodMethodCallback, 0, 0},
7709     {"dateMethod", TestObjectPythonV8Internal::dateMethodMethodCallback, 0, 0},
7710     {"stringMethod", TestObjectPythonV8Internal::stringMethodMethodCallback, 0, 0},
7711     {"readonlyDOMTimeStampMethod", TestObjectPythonV8Internal::readonlyDOMTimeStampMethodMethodCallback, 0, 0},
7712     {"booleanMethod", TestObjectPythonV8Internal::booleanMethodMethodCallback, 0, 0},
7713     {"byteMethod", TestObjectPythonV8Internal::byteMethodMethodCallback, 0, 0},
7714     {"doubleMethod", TestObjectPythonV8Internal::doubleMethodMethodCallback, 0, 0},
7715     {"floatMethod", TestObjectPythonV8Internal::floatMethodMethodCallback, 0, 0},
7716     {"longMethod", TestObjectPythonV8Internal::longMethodMethodCallback, 0, 0},
7717     {"longLongMethod", TestObjectPythonV8Internal::longLongMethodMethodCallback, 0, 0},
7718     {"octetMethod", TestObjectPythonV8Internal::octetMethodMethodCallback, 0, 0},
7719     {"shortMethod", TestObjectPythonV8Internal::shortMethodMethodCallback, 0, 0},
7720     {"unsignedLongMethod", TestObjectPythonV8Internal::unsignedLongMethodMethodCallback, 0, 0},
7721     {"unsignedLongLongMethod", TestObjectPythonV8Internal::unsignedLongLongMethodMethodCallback, 0, 0},
7722     {"unsignedShortMethod", TestObjectPythonV8Internal::unsignedShortMethodMethodCallback, 0, 0},
7723     {"voidMethodDateArg", TestObjectPythonV8Internal::voidMethodDateArgMethodCallback, 0, 1},
7724     {"voidMethodStringArg", TestObjectPythonV8Internal::voidMethodStringArgMethodCallback, 0, 1},
7725     {"voidMethodBooleanArg", TestObjectPythonV8Internal::voidMethodBooleanArgMethodCallback, 0, 1},
7726     {"voidMethodByteArg", TestObjectPythonV8Internal::voidMethodByteArgMethodCallback, 0, 1},
7727     {"voidMethodDoubleArg", TestObjectPythonV8Internal::voidMethodDoubleArgMethodCallback, 0, 1},
7728     {"voidMethodFloatArg", TestObjectPythonV8Internal::voidMethodFloatArgMethodCallback, 0, 1},
7729     {"voidMethodLongArg", TestObjectPythonV8Internal::voidMethodLongArgMethodCallback, 0, 1},
7730     {"voidMethodLongLongArg", TestObjectPythonV8Internal::voidMethodLongLongArgMethodCallback, 0, 1},
7731     {"voidMethodOctetArg", TestObjectPythonV8Internal::voidMethodOctetArgMethodCallback, 0, 1},
7732     {"voidMethodShortArg", TestObjectPythonV8Internal::voidMethodShortArgMethodCallback, 0, 1},
7733     {"voidMethodUnsignedLongArg", TestObjectPythonV8Internal::voidMethodUnsignedLongArgMethodCallback, 0, 1},
7734     {"voidMethodUnsignedLongLongArg", TestObjectPythonV8Internal::voidMethodUnsignedLongLongArgMethodCallback, 0, 1},
7735     {"voidMethodUnsignedShortArg", TestObjectPythonV8Internal::voidMethodUnsignedShortArgMethodCallback, 0, 1},
7736     {"testInterfaceEmptyMethod", TestObjectPythonV8Internal::testInterfaceEmptyMethodMethodCallback, 0, 0},
7737     {"voidMethodTestInterfaceEmptyArg", TestObjectPythonV8Internal::voidMethodTestInterfaceEmptyArgMethodCallback, 0, 1},
7738     {"voidMethodLongArgTestInterfaceEmptyArg", TestObjectPythonV8Internal::voidMethodLongArgTestInterfaceEmptyArgMethodCallback, 0, 2},
7739     {"voidCallbackFunctionMethod", TestObjectPythonV8Internal::voidCallbackFunctionMethodMethodCallback, 0, 0},
7740     {"anyCallbackFunctionOptionalAnyArgMethod", TestObjectPythonV8Internal::anyCallbackFunctionOptionalAnyArgMethodMethodCallback, 0, 0},
7741     {"voidMethodVoidCallbackFunctionArg", TestObjectPythonV8Internal::voidMethodVoidCallbackFunctionArgMethodCallback, 0, 1},
7742     {"voidMethodAnyCallbackFunctionOptionalAnyArg", TestObjectPythonV8Internal::voidMethodAnyCallbackFunctionOptionalAnyArgMethodCallback, 0, 1},
7743     {"compareHowMethod", TestObjectPythonV8Internal::compareHowMethodMethodCallback, 0, 0},
7744     {"anyMethod", TestObjectPythonV8Internal::anyMethodMethodCallback, 0, 0},
7745     {"voidMethodCompareHowArg", TestObjectPythonV8Internal::voidMethodCompareHowArgMethodCallback, 0, 1},
7746     {"voidMethodEventTargetArg", TestObjectPythonV8Internal::voidMethodEventTargetArgMethodCallback, 0, 1},
7747     {"voidMethodMediaQueryListListenerArg", TestObjectPythonV8Internal::voidMethodMediaQueryListListenerArgMethodCallback, 0, 1},
7748     {"voidMethodAnyArg", TestObjectPythonV8Internal::voidMethodAnyArgMethodCallback, 0, 1},
7749     {"voidMethodAttrArg", TestObjectPythonV8Internal::voidMethodAttrArgMethodCallback, 0, 1},
7750     {"voidMethodDocumentArg", TestObjectPythonV8Internal::voidMethodDocumentArgMethodCallback, 0, 1},
7751     {"voidMethodDocumentTypeArg", TestObjectPythonV8Internal::voidMethodDocumentTypeArgMethodCallback, 0, 1},
7752     {"voidMethodElementArg", TestObjectPythonV8Internal::voidMethodElementArgMethodCallback, 0, 1},
7753     {"voidMethodNodeArg", TestObjectPythonV8Internal::voidMethodNodeArgMethodCallback, 0, 1},
7754     {"arrayBufferMethod", TestObjectPythonV8Internal::arrayBufferMethodMethodCallback, 0, 0},
7755     {"arrayBufferViewMethod", TestObjectPythonV8Internal::arrayBufferViewMethodMethodCallback, 0, 0},
7756     {"float32ArrayMethod", TestObjectPythonV8Internal::float32ArrayMethodMethodCallback, 0, 0},
7757     {"int32ArrayMethod", TestObjectPythonV8Internal::int32ArrayMethodMethodCallback, 0, 0},
7758     {"uint8ArrayMethod", TestObjectPythonV8Internal::uint8ArrayMethodMethodCallback, 0, 0},
7759     {"voidMethodArrayBufferArg", TestObjectPythonV8Internal::voidMethodArrayBufferArgMethodCallback, 0, 1},
7760     {"voidMethodArrayBufferOrNullArg", TestObjectPythonV8Internal::voidMethodArrayBufferOrNullArgMethodCallback, 0, 1},
7761     {"voidMethodArrayBufferViewArg", TestObjectPythonV8Internal::voidMethodArrayBufferViewArgMethodCallback, 0, 1},
7762     {"voidMethodFloat32ArrayArg", TestObjectPythonV8Internal::voidMethodFloat32ArrayArgMethodCallback, 0, 1},
7763     {"voidMethodInt32ArrayArg", TestObjectPythonV8Internal::voidMethodInt32ArrayArgMethodCallback, 0, 1},
7764     {"voidMethodUint8ArrayArg", TestObjectPythonV8Internal::voidMethodUint8ArrayArgMethodCallback, 0, 1},
7765     {"longArrayMethod", TestObjectPythonV8Internal::longArrayMethodMethodCallback, 0, 0},
7766     {"stringArrayMethod", TestObjectPythonV8Internal::stringArrayMethodMethodCallback, 0, 0},
7767     {"testInterfaceEmptyArrayMethod", TestObjectPythonV8Internal::testInterfaceEmptyArrayMethodMethodCallback, 0, 0},
7768     {"voidMethodArrayLongArg", TestObjectPythonV8Internal::voidMethodArrayLongArgMethodCallback, 0, 1},
7769     {"voidMethodArrayStringArg", TestObjectPythonV8Internal::voidMethodArrayStringArgMethodCallback, 0, 1},
7770     {"voidMethodArrayTestInterfaceEmptyArg", TestObjectPythonV8Internal::voidMethodArrayTestInterfaceEmptyArgMethodCallback, 0, 1},
7771     {"longSequenceMethod", TestObjectPythonV8Internal::longSequenceMethodMethodCallback, 0, 0},
7772     {"stringSequenceMethod", TestObjectPythonV8Internal::stringSequenceMethodMethodCallback, 0, 0},
7773     {"testInterfaceEmptySequenceMethod", TestObjectPythonV8Internal::testInterfaceEmptySequenceMethodMethodCallback, 0, 0},
7774     {"voidMethodSequenceLongArg", TestObjectPythonV8Internal::voidMethodSequenceLongArgMethodCallback, 0, 1},
7775     {"voidMethodSequenceStringArg", TestObjectPythonV8Internal::voidMethodSequenceStringArgMethodCallback, 0, 1},
7776     {"voidMethodSequenceTestInterfaceEmptyArg", TestObjectPythonV8Internal::voidMethodSequenceTestInterfaceEmptyArgMethodCallback, 0, 1},
7777     {"voidMethodTestInterfaceEmptyOrNullArg", TestObjectPythonV8Internal::voidMethodTestInterfaceEmptyOrNullArgMethodCallback, 0, 1},
7778     {"voidMethodTestCallbackInterfaceArg", TestObjectPythonV8Internal::voidMethodTestCallbackInterfaceArgMethodCallback, 0, 1},
7779     {"voidMethodOptionalTestCallbackInterfaceArg", TestObjectPythonV8Internal::voidMethodOptionalTestCallbackInterfaceArgMethodCallback, 0, 0},
7780     {"voidMethodTestCallbackInterfaceOrNullArg", TestObjectPythonV8Internal::voidMethodTestCallbackInterfaceOrNullArgMethodCallback, 0, 1},
7781     {"testEnumMethod", TestObjectPythonV8Internal::testEnumMethodMethodCallback, 0, 0},
7782     {"voidMethodTestEnumArg", TestObjectPythonV8Internal::voidMethodTestEnumArgMethodCallback, 0, 1},
7783     {"dictionaryMethod", TestObjectPythonV8Internal::dictionaryMethodMethodCallback, 0, 0},
7784     {"nodeFilterMethod", TestObjectPythonV8Internal::nodeFilterMethodMethodCallback, 0, 0},
7785     {"promiseMethod", TestObjectPythonV8Internal::promiseMethodMethodCallback, 0, 0},
7786     {"serializedScriptValueMethod", TestObjectPythonV8Internal::serializedScriptValueMethodMethodCallback, 0, 0},
7787     {"xPathNSResolverMethod", TestObjectPythonV8Internal::xPathNSResolverMethodMethodCallback, 0, 0},
7788     {"voidMethodDictionaryArg", TestObjectPythonV8Internal::voidMethodDictionaryArgMethodCallback, 0, 1},
7789     {"voidMethodEventListenerArg", TestObjectPythonV8Internal::voidMethodEventListenerArgMethodCallback, 0, 1},
7790     {"voidMethodNodeFilterArg", TestObjectPythonV8Internal::voidMethodNodeFilterArgMethodCallback, 0, 1},
7791     {"voidMethodPromiseArg", TestObjectPythonV8Internal::voidMethodPromiseArgMethodCallback, 0, 1},
7792     {"voidMethodSerializedScriptValueArg", TestObjectPythonV8Internal::voidMethodSerializedScriptValueArgMethodCallback, 0, 1},
7793     {"voidMethodXPathNSResolverArg", TestObjectPythonV8Internal::voidMethodXPathNSResolverArgMethodCallback, 0, 1},
7794     {"voidMethodSequenceDictionaryArg", TestObjectPythonV8Internal::voidMethodSequenceDictionaryArgMethodCallback, 0, 1},
7795     {"voidMethodStringArgLongArg", TestObjectPythonV8Internal::voidMethodStringArgLongArgMethodCallback, 0, 2},
7796     {"voidMethodOptionalStringArg", TestObjectPythonV8Internal::voidMethodOptionalStringArgMethodCallback, 0, 0},
7797     {"voidMethodOptionalTestInterfaceEmptyArg", TestObjectPythonV8Internal::voidMethodOptionalTestInterfaceEmptyArgMethodCallback, 0, 0},
7798     {"voidMethodOptionalLongArg", TestObjectPythonV8Internal::voidMethodOptionalLongArgMethodCallback, 0, 0},
7799     {"stringMethodOptionalLongArg", TestObjectPythonV8Internal::stringMethodOptionalLongArgMethodCallback, 0, 0},
7800     {"testInterfaceEmptyMethodOptionalLongArg", TestObjectPythonV8Internal::testInterfaceEmptyMethodOptionalLongArgMethodCallback, 0, 0},
7801     {"longMethodOptionalLongArg", TestObjectPythonV8Internal::longMethodOptionalLongArgMethodCallback, 0, 0},
7802     {"voidMethodLongArgOptionalLongArg", TestObjectPythonV8Internal::voidMethodLongArgOptionalLongArgMethodCallback, 0, 1},
7803     {"voidMethodLongArgOptionalLongArgOptionalLongArg", TestObjectPythonV8Internal::voidMethodLongArgOptionalLongArgOptionalLongArgMethodCallback, 0, 1},
7804     {"voidMethodLongArgOptionalTestInterfaceEmptyArg", TestObjectPythonV8Internal::voidMethodLongArgOptionalTestInterfaceEmptyArgMethodCallback, 0, 1},
7805     {"voidMethodTestInterfaceEmptyArgOptionalLongArg", TestObjectPythonV8Internal::voidMethodTestInterfaceEmptyArgOptionalLongArgMethodCallback, 0, 1},
7806     {"voidMethodOptionalDictionaryArg", TestObjectPythonV8Internal::voidMethodOptionalDictionaryArgMethodCallback, 0, 0},
7807     {"voidMethodVariadicStringArg", TestObjectPythonV8Internal::voidMethodVariadicStringArgMethodCallback, 0, 1},
7808     {"voidMethodStringArgVariadicStringArg", TestObjectPythonV8Internal::voidMethodStringArgVariadicStringArgMethodCallback, 0, 2},
7809     {"voidMethodVariadicTestInterfaceEmptyArg", TestObjectPythonV8Internal::voidMethodVariadicTestInterfaceEmptyArgMethodCallback, 0, 1},
7810     {"voidMethodTestInterfaceEmptyArgVariadicTestInterfaceEmptyArg", TestObjectPythonV8Internal::voidMethodTestInterfaceEmptyArgVariadicTestInterfaceEmptyArgMethodCallback, 0, 2},
7811     {"voidMethodVariadicTestInterfaceWillBeGarbageCollectedArg", TestObjectPythonV8Internal::voidMethodVariadicTestInterfaceWillBeGarbageCollectedArgMethodCallback, 0, 1},
7812     {"overloadedMethodA", TestObjectPythonV8Internal::overloadedMethodAMethodCallback, 0, 1},
7813     {"overloadedMethodB", TestObjectPythonV8Internal::overloadedMethodBMethodCallback, 0, 1},
7814     {"overloadedMethodC", TestObjectPythonV8Internal::overloadedMethodCMethodCallback, 0, 1},
7815     {"overloadedMethodD", TestObjectPythonV8Internal::overloadedMethodDMethodCallback, 0, 1},
7816     {"overloadedMethodE", TestObjectPythonV8Internal::overloadedMethodEMethodCallback, 0, 1},
7817     {"overloadedMethodF", TestObjectPythonV8Internal::overloadedMethodFMethodCallback, 0, 1},
7818     {"overloadedMethodG", TestObjectPythonV8Internal::overloadedMethodGMethodCallback, 0, 0},
7819     {"overloadedMethodH", TestObjectPythonV8Internal::overloadedMethodHMethodCallback, 0, 0},
7820     {"overloadedPerWorldBindingsMethod", TestObjectPythonV8Internal::overloadedPerWorldBindingsMethodMethodCallback, TestObjectPythonV8Internal::overloadedPerWorldBindingsMethodMethodCallbackForMainWorld, 0},
7821     {"voidMethodClampUnsignedShortArg", TestObjectPythonV8Internal::voidMethodClampUnsignedShortArgMethodCallback, 0, 1},
7822     {"voidMethodClampUnsignedLongArg", TestObjectPythonV8Internal::voidMethodClampUnsignedLongArgMethodCallback, 0, 1},
7823     {"voidMethodDefaultUndefinedTestInterfaceEmptyArg", TestObjectPythonV8Internal::voidMethodDefaultUndefinedTestInterfaceEmptyArgMethodCallback, 0, 0},
7824     {"voidMethodDefaultUndefinedLongArg", TestObjectPythonV8Internal::voidMethodDefaultUndefinedLongArgMethodCallback, 0, 0},
7825     {"voidMethodDefaultUndefinedStringArg", TestObjectPythonV8Internal::voidMethodDefaultUndefinedStringArgMethodCallback, 0, 0},
7826     {"voidMethodDefaultNullStringStringArg", TestObjectPythonV8Internal::voidMethodDefaultNullStringStringArgMethodCallback, 0, 0},
7827     {"voidMethodEnforceRangeLongArg", TestObjectPythonV8Internal::voidMethodEnforceRangeLongArgMethodCallback, 0, 1},
7828     {"voidMethodTreatNullAsNullStringStringArg", TestObjectPythonV8Internal::voidMethodTreatNullAsNullStringStringArgMethodCallback, 0, 1},
7829     {"voidMethodTreatNullAsNullStringTreatUndefinedAsNullStringStringArg", TestObjectPythonV8Internal::voidMethodTreatNullAsNullStringTreatUndefinedAsNullStringStringArgMethodCallback, 0, 1},
7830     {"activityLoggingAccessForAllWorldsMethod", TestObjectPythonV8Internal::activityLoggingAccessForAllWorldsMethodMethodCallback, 0, 0},
7831     {"callWithScriptStateVoidMethod", TestObjectPythonV8Internal::callWithScriptStateVoidMethodMethodCallback, 0, 0},
7832     {"callWithScriptStateLongMethod", TestObjectPythonV8Internal::callWithScriptStateLongMethodMethodCallback, 0, 0},
7833     {"callWithExecutionContextVoidMethod", TestObjectPythonV8Internal::callWithExecutionContextVoidMethodMethodCallback, 0, 0},
7834     {"callWithScriptStateExecutionContextVoidMethod", TestObjectPythonV8Internal::callWithScriptStateExecutionContextVoidMethodMethodCallback, 0, 0},
7835     {"callWithScriptStateScriptArgumentsVoidMethod", TestObjectPythonV8Internal::callWithScriptStateScriptArgumentsVoidMethodMethodCallback, 0, 0},
7836     {"callWithScriptStateScriptArgumentsVoidMethodOptionalBooleanArg", TestObjectPythonV8Internal::callWithScriptStateScriptArgumentsVoidMethodOptionalBooleanArgMethodCallback, 0, 0},
7837     {"callWithActiveWindow", TestObjectPythonV8Internal::callWithActiveWindowMethodCallback, 0, 0},
7838     {"callWithActiveWindowScriptWindow", TestObjectPythonV8Internal::callWithActiveWindowScriptWindowMethodCallback, 0, 0},
7839     {"checkSecurityForNodeVoidMethod", TestObjectPythonV8Internal::checkSecurityForNodeVoidMethodMethodCallback, 0, 0},
7840 #if ENABLE(CONDITION)
7841     {"conditionalConditionVoidMethod", TestObjectPythonV8Internal::conditionalConditionVoidMethodMethodCallback, 0, 0},
7842 #endif // ENABLE(CONDITION)
7843 #if ENABLE(CONDITION_1) && ENABLE(CONDITION_2)
7844     {"conditionalCondition1AndCondition2VoidMethod", TestObjectPythonV8Internal::conditionalCondition1AndCondition2VoidMethodMethodCallback, 0, 0},
7845 #endif // ENABLE(CONDITION_1) && ENABLE(CONDITION_2)
7846     {"customVoidMethod", TestObjectPythonV8Internal::customVoidMethodMethodCallback, 0, 0},
7847 #if ENABLE(CONDITION)
7848     {"conditionalConditionCustomVoidMethod", TestObjectPythonV8Internal::conditionalConditionCustomVoidMethodMethodCallback, 0, 0},
7849 #endif // ENABLE(CONDITION)
7850     {"customElementCallbacksVoidMethod", TestObjectPythonV8Internal::customElementCallbacksVoidMethodMethodCallback, 0, 0},
7851     {"deprecatedVoidMethod", TestObjectPythonV8Internal::deprecatedVoidMethodMethodCallback, 0, 0},
7852     {"implementedAsVoidMethod", TestObjectPythonV8Internal::implementedAsVoidMethodMethodCallback, 0, 0},
7853     {"measureAsVoidMethod", TestObjectPythonV8Internal::measureAsVoidMethodMethodCallback, 0, 0},
7854     {"perWorldBindingsVoidMethod", TestObjectPythonV8Internal::perWorldBindingsVoidMethodMethodCallback, TestObjectPythonV8Internal::perWorldBindingsVoidMethodMethodCallbackForMainWorld, 0},
7855     {"perWorldBindingsVoidMethodTestInterfaceEmptyArg", TestObjectPythonV8Internal::perWorldBindingsVoidMethodTestInterfaceEmptyArgMethodCallback, TestObjectPythonV8Internal::perWorldBindingsVoidMethodTestInterfaceEmptyArgMethodCallbackForMainWorld, 1},
7856     {"activityLoggingForAllWorldsPerWorldBindingsVoidMethod", TestObjectPythonV8Internal::activityLoggingForAllWorldsPerWorldBindingsVoidMethodMethodCallback, TestObjectPythonV8Internal::activityLoggingForAllWorldsPerWorldBindingsVoidMethodMethodCallbackForMainWorld, 0},
7857     {"activityLoggingForIsolatedWorldsPerWorldBindingsVoidMethod", TestObjectPythonV8Internal::activityLoggingForIsolatedWorldsPerWorldBindingsVoidMethodMethodCallback, TestObjectPythonV8Internal::activityLoggingForIsolatedWorldsPerWorldBindingsVoidMethodMethodCallbackForMainWorld, 0},
7858     {"raisesExceptionVoidMethod", TestObjectPythonV8Internal::raisesExceptionVoidMethodMethodCallback, 0, 0},
7859     {"raisesExceptionStringMethod", TestObjectPythonV8Internal::raisesExceptionStringMethodMethodCallback, 0, 0},
7860     {"raisesExceptionVoidMethodOptionalLongArg", TestObjectPythonV8Internal::raisesExceptionVoidMethodOptionalLongArgMethodCallback, 0, 0},
7861     {"raisesExceptionVoidMethodTestCallbackInterfaceArg", TestObjectPythonV8Internal::raisesExceptionVoidMethodTestCallbackInterfaceArgMethodCallback, 0, 1},
7862     {"raisesExceptionVoidMethodOptionalTestCallbackInterfaceArg", TestObjectPythonV8Internal::raisesExceptionVoidMethodOptionalTestCallbackInterfaceArgMethodCallback, 0, 0},
7863     {"raisesExceptionTestInterfaceEmptyVoidMethod", TestObjectPythonV8Internal::raisesExceptionTestInterfaceEmptyVoidMethodMethodCallback, 0, 0},
7864     {"strictTypeCheckingVoidMethodTestInterfaceEmptyArg", TestObjectPythonV8Internal::strictTypeCheckingVoidMethodTestInterfaceEmptyArgMethodCallback, 0, 1},
7865     {"strictTypeCheckingVoidMethodTestInterfaceEmptyOrNullArg", TestObjectPythonV8Internal::strictTypeCheckingVoidMethodTestInterfaceEmptyOrNullArgMethodCallback, 0, 1},
7866     {"treatReturnedNullStringAsNullStringMethod", TestObjectPythonV8Internal::treatReturnedNullStringAsNullStringMethodMethodCallback, 0, 0},
7867     {"treatReturnedNullStringAsUndefinedStringMethod", TestObjectPythonV8Internal::treatReturnedNullStringAsUndefinedStringMethodMethodCallback, 0, 0},
7868     {"voidMethodTestInterfaceWillBeGarbageCollectedSequenceArg", TestObjectPythonV8Internal::voidMethodTestInterfaceWillBeGarbageCollectedSequenceArgMethodCallback, 0, 1},
7869     {"voidMethodTestInterfaceWillBeGarbageCollectedArrayArg", TestObjectPythonV8Internal::voidMethodTestInterfaceWillBeGarbageCollectedArrayArgMethodCallback, 0, 1},
7870 };
7871
7872 static void configureV8TestObjectPythonTemplate(v8::Handle<v8::FunctionTemplate> functionTemplate, v8::Isolate* isolate)
7873 {
7874     functionTemplate->ReadOnlyPrototype();
7875
7876     v8::Local<v8::Signature> defaultSignature;
7877     defaultSignature = V8DOMConfiguration::installDOMClassTemplate(functionTemplate, "TestObjectPython", v8::Local<v8::FunctionTemplate>(), V8TestObjectPython::internalFieldCount,
7878         V8TestObjectPythonAttributes, WTF_ARRAY_LENGTH(V8TestObjectPythonAttributes),
7879         V8TestObjectPythonAccessors, WTF_ARRAY_LENGTH(V8TestObjectPythonAccessors),
7880         V8TestObjectPythonMethods, WTF_ARRAY_LENGTH(V8TestObjectPythonMethods),
7881         isolate);
7882     v8::Local<v8::ObjectTemplate> ALLOW_UNUSED instanceTemplate = functionTemplate->InstanceTemplate();
7883     v8::Local<v8::ObjectTemplate> ALLOW_UNUSED prototypeTemplate = functionTemplate->PrototypeTemplate();
7884     if (RuntimeEnabledFeatures::featureNameEnabled()) {
7885         static const V8DOMConfiguration::AttributeConfiguration attributeConfiguration =\
7886         {"runtimeEnabledLongAttribute", TestObjectPythonV8Internal::runtimeEnabledLongAttributeAttributeGetterCallback, TestObjectPythonV8Internal::runtimeEnabledLongAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */};
7887         V8DOMConfiguration::installAttribute(instanceTemplate, prototypeTemplate, attributeConfiguration, isolate);
7888     }
7889 #if ENABLE(CONDITION)
7890     if (RuntimeEnabledFeatures::featureNameEnabled()) {
7891         static const V8DOMConfiguration::AttributeConfiguration attributeConfiguration =\
7892         {"conditionalRuntimeEnabledLongAttribute", TestObjectPythonV8Internal::conditionalRuntimeEnabledLongAttributeAttributeGetterCallback, TestObjectPythonV8Internal::conditionalRuntimeEnabledLongAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */};
7893         V8DOMConfiguration::installAttribute(instanceTemplate, prototypeTemplate, attributeConfiguration, isolate);
7894     }
7895 #endif // ENABLE(CONDITION)
7896     static const V8DOMConfiguration::ConstantConfiguration V8TestObjectPythonConstants[] = {
7897         {"CONST_VALUE_0", 0},
7898         {"CONST_VALUE_1", 1},
7899         {"CONST_VALUE_2", 2},
7900         {"CONST_VALUE_4", 4},
7901         {"CONST_VALUE_8", 8},
7902         {"CONST_VALUE_9", -1},
7903         {"CONST_VALUE_10", "my constant string"},
7904         {"CONST_VALUE_11", 0xffffffff},
7905         {"CONST_VALUE_12", 0x01},
7906         {"CONST_VALUE_13", 0X20},
7907         {"CONST_VALUE_14", 0x1abc},
7908         {"CONST_VALUE_15", 010},
7909         {"CONST_VALUE_16", -010},
7910         {"CONST_VALUE_16", -0x1A},
7911         {"CONST_VALUE_17", -0X1a},
7912         {"DEPRECATED_CONSTANT", 1},
7913         {"CONST_JAVASCRIPT", 1},
7914     };
7915     V8DOMConfiguration::installConstants(functionTemplate, prototypeTemplate, V8TestObjectPythonConstants, WTF_ARRAY_LENGTH(V8TestObjectPythonConstants), isolate);
7916     if (RuntimeEnabledFeatures::featureNameEnabled()) {
7917         static const V8DOMConfiguration::ConstantConfiguration constantConfiguration = {"FEATURE_ENABLED_CONST", static_cast<signed int>(1)};
7918         V8DOMConfiguration::installConstants(functionTemplate, prototypeTemplate, &constantConfiguration, 1, isolate);
7919     }
7920     COMPILE_ASSERT(0 == TestObjectPython::CONST_VALUE_0, TheValueOfTestObjectPython_CONST_VALUE_0DoesntMatchWithImplementation);
7921     COMPILE_ASSERT(1 == TestObjectPython::CONST_VALUE_1, TheValueOfTestObjectPython_CONST_VALUE_1DoesntMatchWithImplementation);
7922     COMPILE_ASSERT(2 == TestObjectPython::CONST_VALUE_2, TheValueOfTestObjectPython_CONST_VALUE_2DoesntMatchWithImplementation);
7923     COMPILE_ASSERT(4 == TestObjectPython::CONST_VALUE_4, TheValueOfTestObjectPython_CONST_VALUE_4DoesntMatchWithImplementation);
7924     COMPILE_ASSERT(8 == TestObjectPython::CONST_VALUE_8, TheValueOfTestObjectPython_CONST_VALUE_8DoesntMatchWithImplementation);
7925     COMPILE_ASSERT(-1 == TestObjectPython::CONST_VALUE_9, TheValueOfTestObjectPython_CONST_VALUE_9DoesntMatchWithImplementation);
7926     COMPILE_ASSERT("my constant string" == TestObjectPython::CONST_VALUE_10, TheValueOfTestObjectPython_CONST_VALUE_10DoesntMatchWithImplementation);
7927     COMPILE_ASSERT(0xffffffff == TestObjectPython::CONST_VALUE_11, TheValueOfTestObjectPython_CONST_VALUE_11DoesntMatchWithImplementation);
7928     COMPILE_ASSERT(0x01 == TestObjectPython::CONST_VALUE_12, TheValueOfTestObjectPython_CONST_VALUE_12DoesntMatchWithImplementation);
7929     COMPILE_ASSERT(0X20 == TestObjectPython::CONST_VALUE_13, TheValueOfTestObjectPython_CONST_VALUE_13DoesntMatchWithImplementation);
7930     COMPILE_ASSERT(0x1abc == TestObjectPython::CONST_VALUE_14, TheValueOfTestObjectPython_CONST_VALUE_14DoesntMatchWithImplementation);
7931     COMPILE_ASSERT(010 == TestObjectPython::CONST_VALUE_15, TheValueOfTestObjectPython_CONST_VALUE_15DoesntMatchWithImplementation);
7932     COMPILE_ASSERT(-010 == TestObjectPython::CONST_VALUE_16, TheValueOfTestObjectPython_CONST_VALUE_16DoesntMatchWithImplementation);
7933     COMPILE_ASSERT(-0x1A == TestObjectPython::CONST_VALUE_16, TheValueOfTestObjectPython_CONST_VALUE_16DoesntMatchWithImplementation);
7934     COMPILE_ASSERT(-0X1a == TestObjectPython::CONST_VALUE_17, TheValueOfTestObjectPython_CONST_VALUE_17DoesntMatchWithImplementation);
7935     COMPILE_ASSERT(1 == TestObjectPython::DEPRECATED_CONSTANT, TheValueOfTestObjectPython_DEPRECATED_CONSTANTDoesntMatchWithImplementation);
7936     COMPILE_ASSERT(1 == TestObjectPython::FEATURE_ENABLED_CONST, TheValueOfTestObjectPython_FEATURE_ENABLED_CONSTDoesntMatchWithImplementation);
7937     COMPILE_ASSERT(1 == TestObjectPython::CONST_IMPL, TheValueOfTestObjectPython_CONST_IMPLDoesntMatchWithImplementation);
7938     functionTemplate->Set(v8AtomicString(isolate, "staticVoidMethod"), v8::FunctionTemplate::New(isolate, TestObjectPythonV8Internal::staticVoidMethodMethodCallback, v8Undefined(), v8::Local<v8::Signature>(), 0));
7939     functionTemplate->Set(v8AtomicString(isolate, "overloadedStaticMethod"), v8::FunctionTemplate::New(isolate, TestObjectPythonV8Internal::overloadedStaticMethodMethodCallback, v8Undefined(), v8::Local<v8::Signature>(), 1));
7940 #if ENABLE(CONDITION)
7941     functionTemplate->Set(v8AtomicString(isolate, "conditionalConditionStaticVoidMethod"), v8::FunctionTemplate::New(isolate, TestObjectPythonV8Internal::conditionalConditionStaticVoidMethodMethodCallback, v8Undefined(), v8::Local<v8::Signature>(), 0));
7942 #endif // ENABLE(CONDITION)
7943     prototypeTemplate->Set(v8AtomicString(isolate, "doNotCheckSignatureVoidMethod"), v8::FunctionTemplate::New(isolate, TestObjectPythonV8Internal::doNotCheckSignatureVoidMethodMethodCallback, v8Undefined(), v8::Local<v8::Signature>(), 0));
7944     prototypeTemplate->Set(v8AtomicString(isolate, "notEnumerableVoidMethod"), v8::FunctionTemplate::New(isolate, TestObjectPythonV8Internal::notEnumerableVoidMethodMethodCallback, v8Undefined(), defaultSignature, 0), static_cast<v8::PropertyAttribute>(v8::DontDelete | v8::DontEnum));
7945     prototypeTemplate->Set(v8AtomicString(isolate, "readOnlyVoidMethod"), v8::FunctionTemplate::New(isolate, TestObjectPythonV8Internal::readOnlyVoidMethodMethodCallback, v8Undefined(), defaultSignature, 0), static_cast<v8::PropertyAttribute>(v8::DontDelete | v8::ReadOnly));
7946     prototypeTemplate->Set(v8AtomicString(isolate, "notEnumerableReadOnlyVoidMethod"), v8::FunctionTemplate::New(isolate, TestObjectPythonV8Internal::notEnumerableReadOnlyVoidMethodMethodCallback, v8Undefined(), defaultSignature, 0), static_cast<v8::PropertyAttribute>(v8::DontDelete | v8::DontEnum | v8::ReadOnly));
7947     if (RuntimeEnabledFeatures::featureNameEnabled())
7948         prototypeTemplate->Set(v8AtomicString(isolate, "runtimeEnabledVoidMethod"), v8::FunctionTemplate::New(isolate, TestObjectPythonV8Internal::runtimeEnabledVoidMethodMethodCallback, v8Undefined(), defaultSignature, 0));
7949     if (DOMWrapperWorld::current(isolate)->isMainWorld()) {
7950         if (RuntimeEnabledFeatures::featureNameEnabled())
7951             prototypeTemplate->Set(v8AtomicString(isolate, "perWorldBindingsRuntimeEnabledVoidMethod"), v8::FunctionTemplate::New(isolate, TestObjectPythonV8Internal::perWorldBindingsRuntimeEnabledVoidMethodMethodCallbackForMainWorld, v8Undefined(), defaultSignature, 0));
7952     } else {
7953         if (RuntimeEnabledFeatures::featureNameEnabled())
7954             prototypeTemplate->Set(v8AtomicString(isolate, "perWorldBindingsRuntimeEnabledVoidMethod"), v8::FunctionTemplate::New(isolate, TestObjectPythonV8Internal::perWorldBindingsRuntimeEnabledVoidMethodMethodCallback, v8Undefined(), defaultSignature, 0));
7955     }
7956     instanceTemplate->Set(v8AtomicString(isolate, "unforgeableVoidMethod"), v8::FunctionTemplate::New(isolate, TestObjectPythonV8Internal::unforgeableVoidMethodMethodCallback, v8Undefined(), defaultSignature, 0));
7957     functionTemplate->SetNativeDataProperty(v8AtomicString(isolate, "staticStringAttribute"), TestObjectPythonV8Internal::staticStringAttributeAttributeGetterCallback, TestObjectPythonV8Internal::staticStringAttributeAttributeSetterCallback, v8::External::New(isolate, 0), static_cast<v8::PropertyAttribute>(v8::None), v8::Handle<v8::AccessorSignature>(), static_cast<v8::AccessControl>(v8::DEFAULT));
7958     functionTemplate->SetNativeDataProperty(v8AtomicString(isolate, "staticLongAttribute"), TestObjectPythonV8Internal::staticLongAttributeAttributeGetterCallback, TestObjectPythonV8Internal::staticLongAttributeAttributeSetterCallback, v8::External::New(isolate, 0), static_cast<v8::PropertyAttribute>(v8::None), v8::Handle<v8::AccessorSignature>(), static_cast<v8::AccessControl>(v8::DEFAULT));
7959
7960     // Custom toString template
7961     functionTemplate->Set(v8AtomicString(isolate, "toString"), V8PerIsolateData::current()->toStringTemplate());
7962 }
7963
7964 v8::Handle<v8::FunctionTemplate> V8TestObjectPython::domTemplate(v8::Isolate* isolate)
7965 {
7966     V8PerIsolateData* data = V8PerIsolateData::from(isolate);
7967     v8::Local<v8::FunctionTemplate> result = data->existingDOMTemplate(const_cast<WrapperTypeInfo*>(&wrapperTypeInfo));
7968     if (!result.IsEmpty())
7969         return result;
7970
7971     TRACE_EVENT_SCOPED_SAMPLING_STATE("Blink", "BuildDOMTemplate");
7972     result = v8::FunctionTemplate::New(isolate, V8ObjectConstructor::isValidConstructorMode);
7973     configureV8TestObjectPythonTemplate(result, isolate);
7974     data->setDOMTemplate(const_cast<WrapperTypeInfo*>(&wrapperTypeInfo), result);
7975     return result;
7976 }
7977
7978 bool V8TestObjectPython::hasInstance(v8::Handle<v8::Value> v8Value, v8::Isolate* isolate)
7979 {
7980     return V8PerIsolateData::from(isolate)->hasInstance(&wrapperTypeInfo, v8Value);
7981 }
7982
7983 v8::Handle<v8::Object> V8TestObjectPython::findInstanceInPrototypeChain(v8::Handle<v8::Value> v8Value, v8::Isolate* isolate)
7984 {
7985     return V8PerIsolateData::from(isolate)->findInstanceInPrototypeChain(&wrapperTypeInfo, v8Value);
7986 }
7987
7988 TestObjectPython* V8TestObjectPython::toNativeWithTypeCheck(v8::Isolate* isolate, v8::Handle<v8::Value> value)
7989 {
7990     return hasInstance(value, isolate) ? fromInternalPointer(v8::Handle<v8::Object>::Cast(value)->GetAlignedPointerFromInternalField(v8DOMWrapperObjectIndex)) : 0;
7991 }
7992
7993 void V8TestObjectPython::installPerContextEnabledProperties(v8::Handle<v8::Object> instanceTemplate, TestObjectPython* impl, v8::Isolate* isolate)
7994 {
7995     v8::Local<v8::Object> prototypeTemplate = v8::Local<v8::Object>::Cast(instanceTemplate->GetPrototype());
7996     if (ContextFeatures::featureNameEnabled(impl->document())) {
7997         static const V8DOMConfiguration::AttributeConfiguration attributeConfiguration =\
7998         {"perContextEnabledLongAttribute", TestObjectPythonV8Internal::perContextEnabledLongAttributeAttributeGetterCallback, TestObjectPythonV8Internal::perContextEnabledLongAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */};
7999         V8DOMConfiguration::installAttribute(instanceTemplate, prototypeTemplate, attributeConfiguration, isolate);
8000     }
8001     if (ContextFeatures::featureNameEnabled(impl->document())) {
8002         static const V8DOMConfiguration::AttributeConfiguration attributeConfiguration =\
8003         {"perContextEnabledRuntimeEnabledLongAttribute", TestObjectPythonV8Internal::perContextEnabledRuntimeEnabledLongAttributeAttributeGetterCallback, TestObjectPythonV8Internal::perContextEnabledRuntimeEnabledLongAttributeAttributeSetterCallback, 0, 0, 0, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */};
8004         V8DOMConfiguration::installAttribute(instanceTemplate, prototypeTemplate, attributeConfiguration, isolate);
8005     }
8006 }
8007
8008 void V8TestObjectPython::installPerContextEnabledMethods(v8::Handle<v8::Object> prototypeTemplate, v8::Isolate* isolate)
8009 {
8010     v8::Local<v8::Signature> defaultSignature = v8::Signature::New(isolate, domTemplate(isolate));
8011
8012     ExecutionContext* context = toExecutionContext(prototypeTemplate->CreationContext());
8013     if (context && context->isDocument() && ContextFeatures::featureNameEnabled(toDocument(context)))
8014         prototypeTemplate->Set(v8AtomicString(isolate, "perContextEnabledVoidMethod"), v8::FunctionTemplate::New(isolate, TestObjectPythonV8Internal::perContextEnabledVoidMethodMethodCallback, v8Undefined(), defaultSignature, 0)->GetFunction());
8015 }
8016
8017 v8::Handle<v8::Object> V8TestObjectPython::createWrapper(PassRefPtr<TestObjectPython> impl, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
8018 {
8019     ASSERT(impl);
8020     ASSERT(!DOMDataStore::containsWrapper<V8TestObjectPython>(impl.get(), isolate));
8021     if (ScriptWrappable::wrapperCanBeStoredInObject(impl.get())) {
8022         const WrapperTypeInfo* actualInfo = ScriptWrappable::getTypeInfoFromObject(impl.get());
8023         // Might be a XXXConstructor::wrapperTypeInfo instead of an XXX::wrapperTypeInfo. These will both have
8024         // the same object de-ref functions, though, so use that as the basis of the check.
8025         RELEASE_ASSERT_WITH_SECURITY_IMPLICATION(actualInfo->derefObjectFunction == wrapperTypeInfo.derefObjectFunction);
8026     }
8027
8028     v8::Handle<v8::Object> wrapper = V8DOMWrapper::createWrapper(creationContext, &wrapperTypeInfo, toInternalPointer(impl.get()), isolate);
8029     if (UNLIKELY(wrapper.IsEmpty()))
8030         return wrapper;
8031
8032     installPerContextEnabledProperties(wrapper, impl.get(), isolate);
8033     V8DOMWrapper::associateObjectWithWrapper<V8TestObjectPython>(impl, &wrapperTypeInfo, wrapper, isolate, WrapperConfiguration::Independent);
8034     return wrapper;
8035 }
8036
8037 void V8TestObjectPython::derefObject(void* object)
8038 {
8039     fromInternalPointer(object)->deref();
8040 }
8041
8042 template<>
8043 v8::Handle<v8::Value> toV8NoInline(TestObjectPython* impl, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
8044 {
8045     return toV8(impl, creationContext, isolate);
8046 }
8047
8048 } // namespace WebCore