1/* 2 This file is part of the Blink open source project. 3 This file has been auto-generated by CodeGeneratorV8.pm. DO NOT MODIFY! 4 5 This library is free software; you can redistribute it and/or 6 modify it under the terms of the GNU Library General Public 7 License as published by the Free Software Foundation; either 8 version 2 of the License, or (at your option) any later version. 9 10 This library is distributed in the hope that it will be useful, 11 but WITHOUT ANY WARRANTY; without even the implied warranty of 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 13 Library General Public License for more details. 14 15 You should have received a copy of the GNU Library General Public License 16 along with this library; see the file COPYING.LIB. If not, write to 17 the Free Software Foundation, Inc., 59 Temple Place - Suite 330, 18 Boston, MA 02111-1307, USA. 19*/ 20 21#include "config.h" 22#if ENABLE(Condition1) || ENABLE(Condition2) 23#include "V8TestInterface.h" 24 25#include "RuntimeEnabledFeatures.h" 26#include "V8Node.h" 27#include "V8NodeList.h" 28#include "V8TestObject.h" 29#include "bindings/bindings/tests/idls/TestImplements.h" 30#include "bindings/bindings/tests/idls/TestPartialInterface.h" 31#include "bindings/v8/ExceptionState.h" 32#include "bindings/v8/ScriptController.h" 33#include "bindings/v8/V8Binding.h" 34#include "bindings/v8/V8DOMConfiguration.h" 35#include "bindings/v8/V8DOMWrapper.h" 36#include "bindings/v8/V8ObjectConstructor.h" 37#include "core/dom/ContextFeatures.h" 38#include "core/dom/Document.h" 39#include "core/page/Frame.h" 40#include "core/platform/chromium/TraceEvent.h" 41#include "wtf/GetPtr.h" 42#include "wtf/RefPtr.h" 43#include "wtf/UnusedParam.h" 44 45namespace WebCore { 46 47static void initializeScriptWrappableForInterface(TestInterface* object) 48{ 49 if (ScriptWrappable::wrapperCanBeStoredInObject(object)) 50 ScriptWrappable::setTypeInfoInObject(object, &V8TestInterface::info); 51 else 52 ASSERT_NOT_REACHED(); 53} 54 55} // namespace WebCore 56 57// In ScriptWrappable::init, the use of a local function declaration has an issue on Windows: 58// the local declaration does not pick up the surrounding namespace. Therefore, we provide this function 59// in the global namespace. 60// (More info on the MSVC bug here: http://connect.microsoft.com/VisualStudio/feedback/details/664619/the-namespace-of-local-function-declarations-in-c) 61void webCoreInitializeScriptWrappableForInterface(WebCore::TestInterface* object) 62{ 63 WebCore::initializeScriptWrappableForInterface(object); 64} 65 66namespace WebCore { 67WrapperTypeInfo V8TestInterface::info = { V8TestInterface::GetTemplate, V8TestInterface::derefObject, V8TestInterface::toActiveDOMObject, 0, 0, V8TestInterface::installPerContextPrototypeProperties, 0, WrapperTypeObjectPrototype }; 68 69namespace TestInterfaceV8Internal { 70 71template <typename T> void V8_USE(T) { } 72 73#if ENABLE(Condition22) || ENABLE(Condition23) 74 75static void implementsStaticReadOnlyAttrAttrGetter(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info) 76{ 77 v8SetReturnValueInt(info, TestImplements::implementsStaticReadOnlyAttr()); 78 return; 79} 80 81#endif // ENABLE(Condition22) || ENABLE(Condition23) 82 83#if ENABLE(Condition22) || ENABLE(Condition23) 84 85static void implementsStaticReadOnlyAttrAttrGetterCallback(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info) 86{ 87 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); 88 TestInterfaceV8Internal::implementsStaticReadOnlyAttrAttrGetter(name, info); 89 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); 90} 91 92#endif // ENABLE(Condition22) || ENABLE(Condition23) 93 94#if ENABLE(Condition22) || ENABLE(Condition23) 95 96static void implementsStaticAttrAttrGetter(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info) 97{ 98 v8SetReturnValueString(info, TestImplements::implementsStaticAttr(), info.GetIsolate()); 99 return; 100} 101 102#endif // ENABLE(Condition22) || ENABLE(Condition23) 103 104#if ENABLE(Condition22) || ENABLE(Condition23) 105 106static void implementsStaticAttrAttrGetterCallback(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info) 107{ 108 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); 109 TestInterfaceV8Internal::implementsStaticAttrAttrGetter(name, info); 110 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); 111} 112 113#endif // ENABLE(Condition22) || ENABLE(Condition23) 114 115#if ENABLE(Condition22) || ENABLE(Condition23) 116 117static void implementsStaticAttrAttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info) 118{ 119 V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, v, value); 120 TestImplements::setImplementsStaticAttr(v); 121 return; 122} 123 124#endif // ENABLE(Condition22) || ENABLE(Condition23) 125 126#if ENABLE(Condition22) || ENABLE(Condition23) 127 128static void implementsStaticAttrAttrSetterCallback(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info) 129{ 130 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); 131 TestInterfaceV8Internal::implementsStaticAttrAttrSetter(name, value, info); 132 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); 133} 134 135#endif // ENABLE(Condition22) || ENABLE(Condition23) 136 137#if ENABLE(Condition22) || ENABLE(Condition23) 138 139static void implementsStr1AttrGetter(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info) 140{ 141 TestInterface* imp = V8TestInterface::toNative(info.Holder()); 142 v8SetReturnValueString(info, TestImplements::implementsStr1(imp), info.GetIsolate()); 143 return; 144} 145 146#endif // ENABLE(Condition22) || ENABLE(Condition23) 147 148#if ENABLE(Condition22) || ENABLE(Condition23) 149 150static void implementsStr1AttrGetterCallback(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info) 151{ 152 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); 153 TestInterfaceV8Internal::implementsStr1AttrGetter(name, info); 154 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); 155} 156 157#endif // ENABLE(Condition22) || ENABLE(Condition23) 158 159#if ENABLE(Condition22) || ENABLE(Condition23) 160 161static void implementsStr2AttrGetter(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info) 162{ 163 TestInterface* imp = V8TestInterface::toNative(info.Holder()); 164 v8SetReturnValueString(info, TestImplements::implementsStr2(imp), info.GetIsolate()); 165 return; 166} 167 168#endif // ENABLE(Condition22) || ENABLE(Condition23) 169 170#if ENABLE(Condition22) || ENABLE(Condition23) 171 172static void implementsStr2AttrGetterCallback(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info) 173{ 174 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); 175 TestInterfaceV8Internal::implementsStr2AttrGetter(name, info); 176 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); 177} 178 179#endif // ENABLE(Condition22) || ENABLE(Condition23) 180 181#if ENABLE(Condition22) || ENABLE(Condition23) 182 183static void implementsStr2AttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info) 184{ 185 TestInterface* imp = V8TestInterface::toNative(info.Holder()); 186 V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, v, value); 187 TestImplements::setImplementsStr2(imp, v); 188 return; 189} 190 191#endif // ENABLE(Condition22) || ENABLE(Condition23) 192 193#if ENABLE(Condition22) || ENABLE(Condition23) 194 195static void implementsStr2AttrSetterCallback(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info) 196{ 197 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); 198 TestInterfaceV8Internal::implementsStr2AttrSetter(name, value, info); 199 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); 200} 201 202#endif // ENABLE(Condition22) || ENABLE(Condition23) 203 204#if ENABLE(Condition22) || ENABLE(Condition23) 205 206static void implementsStr3AttrGetterCallback(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info) 207{ 208 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); 209 V8TestInterface::implementsStr3AttrGetterCustom(name, info); 210 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); 211} 212 213#endif // ENABLE(Condition22) || ENABLE(Condition23) 214 215#if ENABLE(Condition22) || ENABLE(Condition23) 216 217static void implementsStr3AttrSetterCallback(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info) 218{ 219 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); 220 V8TestInterface::implementsStr3AttrSetterCustom(name, value, info); 221 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); 222} 223 224#endif // ENABLE(Condition22) || ENABLE(Condition23) 225 226#if ENABLE(Condition22) || ENABLE(Condition23) 227 228static void implementsNodeAttrGetter(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info) 229{ 230 TestInterface* imp = V8TestInterface::toNative(info.Holder()); 231 v8SetReturnValue(info, toV8Fast(TestImplements::implementsNode(imp), info, imp)); 232 return; 233} 234 235#endif // ENABLE(Condition22) || ENABLE(Condition23) 236 237#if ENABLE(Condition22) || ENABLE(Condition23) 238 239static void implementsNodeAttrGetterCallback(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info) 240{ 241 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); 242 TestInterfaceV8Internal::implementsNodeAttrGetter(name, info); 243 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); 244} 245 246#endif // ENABLE(Condition22) || ENABLE(Condition23) 247 248#if ENABLE(Condition22) || ENABLE(Condition23) 249 250static void implementsNodeAttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info) 251{ 252 TestInterface* imp = V8TestInterface::toNative(info.Holder()); 253 V8TRYCATCH_VOID(Node*, v, V8Node::HasInstance(value, info.GetIsolate(), worldType(info.GetIsolate())) ? V8Node::toNative(v8::Handle<v8::Object>::Cast(value)) : 0); 254 TestImplements::setImplementsNode(imp, WTF::getPtr(v)); 255 return; 256} 257 258#endif // ENABLE(Condition22) || ENABLE(Condition23) 259 260#if ENABLE(Condition22) || ENABLE(Condition23) 261 262static void implementsNodeAttrSetterCallback(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info) 263{ 264 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); 265 TestInterfaceV8Internal::implementsNodeAttrSetter(name, value, info); 266 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); 267} 268 269#endif // ENABLE(Condition22) || ENABLE(Condition23) 270 271#if ENABLE(Condition22) || ENABLE(Condition23) 272 273static void Node23AttrGetter(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info) 274{ 275 TestInterface* imp = V8TestInterface::toNative(info.Holder()); 276 v8SetReturnValue(info, toV8Fast(TestImplements::node23(imp), info, imp)); 277 return; 278} 279 280#endif // ENABLE(Condition22) || ENABLE(Condition23) 281 282#if ENABLE(Condition22) || ENABLE(Condition23) 283 284static void Node23AttrGetterCallback(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info) 285{ 286 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); 287 TestInterfaceV8Internal::Node23AttrGetter(name, info); 288 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); 289} 290 291#endif // ENABLE(Condition22) || ENABLE(Condition23) 292 293#if ENABLE(Condition22) || ENABLE(Condition23) 294 295static void Node23AttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info) 296{ 297 TestInterface* imp = V8TestInterface::toNative(info.Holder()); 298 V8TRYCATCH_VOID(Node*, v, V8Node::HasInstance(value, info.GetIsolate(), worldType(info.GetIsolate())) ? V8Node::toNative(v8::Handle<v8::Object>::Cast(value)) : 0); 299 TestImplements::setNode23(imp, WTF::getPtr(v)); 300 return; 301} 302 303#endif // ENABLE(Condition22) || ENABLE(Condition23) 304 305#if ENABLE(Condition22) || ENABLE(Condition23) 306 307static void Node23AttrSetterCallback(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info) 308{ 309 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); 310 TestInterfaceV8Internal::Node23AttrSetter(name, value, info); 311 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); 312} 313 314#endif // ENABLE(Condition22) || ENABLE(Condition23) 315 316#if ENABLE(Condition22) || ENABLE(Condition23) 317 318static void Node24AttrGetter(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info) 319{ 320 TestInterface* imp = V8TestInterface::toNative(info.Holder()); 321 v8SetReturnValue(info, toV8Fast(TestImplements::node24(imp), info, imp)); 322 return; 323} 324 325#endif // ENABLE(Condition22) || ENABLE(Condition23) 326 327#if ENABLE(Condition22) || ENABLE(Condition23) 328 329static void Node24AttrGetterCallback(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info) 330{ 331 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); 332 TestInterfaceV8Internal::Node24AttrGetter(name, info); 333 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); 334} 335 336#endif // ENABLE(Condition22) || ENABLE(Condition23) 337 338#if ENABLE(Condition22) || ENABLE(Condition23) 339 340static void Node24AttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info) 341{ 342 TestInterface* imp = V8TestInterface::toNative(info.Holder()); 343 V8TRYCATCH_VOID(Node*, v, V8Node::HasInstance(value, info.GetIsolate(), worldType(info.GetIsolate())) ? V8Node::toNative(v8::Handle<v8::Object>::Cast(value)) : 0); 344 TestImplements::setNode24(imp, WTF::getPtr(v)); 345 return; 346} 347 348#endif // ENABLE(Condition22) || ENABLE(Condition23) 349 350#if ENABLE(Condition22) || ENABLE(Condition23) 351 352static void Node24AttrSetterCallback(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info) 353{ 354 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); 355 TestInterfaceV8Internal::Node24AttrSetter(name, value, info); 356 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); 357} 358 359#endif // ENABLE(Condition22) || ENABLE(Condition23) 360 361#if ENABLE(Condition22) || ENABLE(Condition23) 362 363static void Node25AttrGetter(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info) 364{ 365 TestInterface* imp = V8TestInterface::toNative(info.Holder()); 366 v8SetReturnValue(info, toV8Fast(TestImplements::node25(imp), info, imp)); 367 return; 368} 369 370#endif // ENABLE(Condition22) || ENABLE(Condition23) 371 372#if ENABLE(Condition22) || ENABLE(Condition23) 373 374static void Node25AttrGetterCallback(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info) 375{ 376 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); 377 TestInterfaceV8Internal::Node25AttrGetter(name, info); 378 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); 379} 380 381#endif // ENABLE(Condition22) || ENABLE(Condition23) 382 383#if ENABLE(Condition22) || ENABLE(Condition23) 384 385static void Node25AttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info) 386{ 387 TestInterface* imp = V8TestInterface::toNative(info.Holder()); 388 V8TRYCATCH_VOID(Node*, v, V8Node::HasInstance(value, info.GetIsolate(), worldType(info.GetIsolate())) ? V8Node::toNative(v8::Handle<v8::Object>::Cast(value)) : 0); 389 TestImplements::setNode25(imp, WTF::getPtr(v)); 390 return; 391} 392 393#endif // ENABLE(Condition22) || ENABLE(Condition23) 394 395#if ENABLE(Condition22) || ENABLE(Condition23) 396 397static void Node25AttrSetterCallback(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info) 398{ 399 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); 400 TestInterfaceV8Internal::Node25AttrSetter(name, value, info); 401 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); 402} 403 404#endif // ENABLE(Condition22) || ENABLE(Condition23) 405 406#if ENABLE(Condition11) || ENABLE(Condition12) 407 408static void supplementalStaticReadOnlyAttrAttrGetter(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info) 409{ 410 v8SetReturnValueInt(info, TestPartialInterface::supplementalStaticReadOnlyAttr()); 411 return; 412} 413 414#endif // ENABLE(Condition11) || ENABLE(Condition12) 415 416#if ENABLE(Condition11) || ENABLE(Condition12) 417 418static void supplementalStaticReadOnlyAttrAttrGetterCallback(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info) 419{ 420 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); 421 TestInterfaceV8Internal::supplementalStaticReadOnlyAttrAttrGetter(name, info); 422 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); 423} 424 425#endif // ENABLE(Condition11) || ENABLE(Condition12) 426 427#if ENABLE(Condition11) || ENABLE(Condition12) 428 429static void supplementalStaticAttrAttrGetter(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info) 430{ 431 v8SetReturnValueString(info, TestPartialInterface::supplementalStaticAttr(), info.GetIsolate()); 432 return; 433} 434 435#endif // ENABLE(Condition11) || ENABLE(Condition12) 436 437#if ENABLE(Condition11) || ENABLE(Condition12) 438 439static void supplementalStaticAttrAttrGetterCallback(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info) 440{ 441 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); 442 TestInterfaceV8Internal::supplementalStaticAttrAttrGetter(name, info); 443 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); 444} 445 446#endif // ENABLE(Condition11) || ENABLE(Condition12) 447 448#if ENABLE(Condition11) || ENABLE(Condition12) 449 450static void supplementalStaticAttrAttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info) 451{ 452 V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, v, value); 453 TestPartialInterface::setSupplementalStaticAttr(v); 454 return; 455} 456 457#endif // ENABLE(Condition11) || ENABLE(Condition12) 458 459#if ENABLE(Condition11) || ENABLE(Condition12) 460 461static void supplementalStaticAttrAttrSetterCallback(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info) 462{ 463 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); 464 TestInterfaceV8Internal::supplementalStaticAttrAttrSetter(name, value, info); 465 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); 466} 467 468#endif // ENABLE(Condition11) || ENABLE(Condition12) 469 470#if ENABLE(Condition11) || ENABLE(Condition12) 471 472static void supplementalStr1AttrGetter(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info) 473{ 474 TestInterface* imp = V8TestInterface::toNative(info.Holder()); 475 v8SetReturnValueString(info, TestPartialInterface::supplementalStr1(imp), info.GetIsolate()); 476 return; 477} 478 479#endif // ENABLE(Condition11) || ENABLE(Condition12) 480 481#if ENABLE(Condition11) || ENABLE(Condition12) 482 483static void supplementalStr1AttrGetterCallback(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info) 484{ 485 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); 486 TestInterfaceV8Internal::supplementalStr1AttrGetter(name, info); 487 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); 488} 489 490#endif // ENABLE(Condition11) || ENABLE(Condition12) 491 492#if ENABLE(Condition11) || ENABLE(Condition12) 493 494static void supplementalStr2AttrGetter(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info) 495{ 496 TestInterface* imp = V8TestInterface::toNative(info.Holder()); 497 v8SetReturnValueString(info, TestPartialInterface::supplementalStr2(imp), info.GetIsolate()); 498 return; 499} 500 501#endif // ENABLE(Condition11) || ENABLE(Condition12) 502 503#if ENABLE(Condition11) || ENABLE(Condition12) 504 505static void supplementalStr2AttrGetterCallback(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info) 506{ 507 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); 508 TestInterfaceV8Internal::supplementalStr2AttrGetter(name, info); 509 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); 510} 511 512#endif // ENABLE(Condition11) || ENABLE(Condition12) 513 514#if ENABLE(Condition11) || ENABLE(Condition12) 515 516static void supplementalStr2AttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info) 517{ 518 TestInterface* imp = V8TestInterface::toNative(info.Holder()); 519 V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, v, value); 520 TestPartialInterface::setSupplementalStr2(imp, v); 521 return; 522} 523 524#endif // ENABLE(Condition11) || ENABLE(Condition12) 525 526#if ENABLE(Condition11) || ENABLE(Condition12) 527 528static void supplementalStr2AttrSetterCallback(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info) 529{ 530 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); 531 TestInterfaceV8Internal::supplementalStr2AttrSetter(name, value, info); 532 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); 533} 534 535#endif // ENABLE(Condition11) || ENABLE(Condition12) 536 537#if ENABLE(Condition11) || ENABLE(Condition12) 538 539static void supplementalStr3AttrGetterCallback(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info) 540{ 541 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); 542 V8TestInterface::supplementalStr3AttrGetterCustom(name, info); 543 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); 544} 545 546#endif // ENABLE(Condition11) || ENABLE(Condition12) 547 548#if ENABLE(Condition11) || ENABLE(Condition12) 549 550static void supplementalStr3AttrSetterCallback(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info) 551{ 552 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); 553 V8TestInterface::supplementalStr3AttrSetterCustom(name, value, info); 554 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); 555} 556 557#endif // ENABLE(Condition11) || ENABLE(Condition12) 558 559#if ENABLE(Condition11) || ENABLE(Condition12) 560 561static void supplementalNodeAttrGetter(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info) 562{ 563 TestInterface* imp = V8TestInterface::toNative(info.Holder()); 564 v8SetReturnValue(info, toV8Fast(TestPartialInterface::supplementalNode(imp), info, imp)); 565 return; 566} 567 568#endif // ENABLE(Condition11) || ENABLE(Condition12) 569 570#if ENABLE(Condition11) || ENABLE(Condition12) 571 572static void supplementalNodeAttrGetterCallback(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info) 573{ 574 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); 575 TestInterfaceV8Internal::supplementalNodeAttrGetter(name, info); 576 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); 577} 578 579#endif // ENABLE(Condition11) || ENABLE(Condition12) 580 581#if ENABLE(Condition11) || ENABLE(Condition12) 582 583static void supplementalNodeAttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info) 584{ 585 TestInterface* imp = V8TestInterface::toNative(info.Holder()); 586 V8TRYCATCH_VOID(Node*, v, V8Node::HasInstance(value, info.GetIsolate(), worldType(info.GetIsolate())) ? V8Node::toNative(v8::Handle<v8::Object>::Cast(value)) : 0); 587 TestPartialInterface::setSupplementalNode(imp, WTF::getPtr(v)); 588 return; 589} 590 591#endif // ENABLE(Condition11) || ENABLE(Condition12) 592 593#if ENABLE(Condition11) || ENABLE(Condition12) 594 595static void supplementalNodeAttrSetterCallback(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info) 596{ 597 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); 598 TestInterfaceV8Internal::supplementalNodeAttrSetter(name, value, info); 599 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); 600} 601 602#endif // ENABLE(Condition11) || ENABLE(Condition12) 603 604#if ENABLE(Condition11) || ENABLE(Condition12) 605 606static void Node13AttrGetter(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info) 607{ 608 TestInterface* imp = V8TestInterface::toNative(info.Holder()); 609 v8SetReturnValue(info, toV8Fast(TestPartialInterface::node13(imp), info, imp)); 610 return; 611} 612 613#endif // ENABLE(Condition11) || ENABLE(Condition12) 614 615#if ENABLE(Condition11) || ENABLE(Condition12) 616 617static void Node13AttrGetterCallback(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info) 618{ 619 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); 620 TestInterfaceV8Internal::Node13AttrGetter(name, info); 621 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); 622} 623 624#endif // ENABLE(Condition11) || ENABLE(Condition12) 625 626#if ENABLE(Condition11) || ENABLE(Condition12) 627 628static void Node13AttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info) 629{ 630 TestInterface* imp = V8TestInterface::toNative(info.Holder()); 631 V8TRYCATCH_VOID(Node*, v, V8Node::HasInstance(value, info.GetIsolate(), worldType(info.GetIsolate())) ? V8Node::toNative(v8::Handle<v8::Object>::Cast(value)) : 0); 632 TestPartialInterface::setNode13(imp, WTF::getPtr(v)); 633 return; 634} 635 636#endif // ENABLE(Condition11) || ENABLE(Condition12) 637 638#if ENABLE(Condition11) || ENABLE(Condition12) 639 640static void Node13AttrSetterCallback(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info) 641{ 642 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); 643 TestInterfaceV8Internal::Node13AttrSetter(name, value, info); 644 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); 645} 646 647#endif // ENABLE(Condition11) || ENABLE(Condition12) 648 649#if ENABLE(Condition11) || ENABLE(Condition12) 650 651static void Node14AttrGetter(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info) 652{ 653 TestInterface* imp = V8TestInterface::toNative(info.Holder()); 654 v8SetReturnValue(info, toV8Fast(TestPartialInterface::node14(imp), info, imp)); 655 return; 656} 657 658#endif // ENABLE(Condition11) || ENABLE(Condition12) 659 660#if ENABLE(Condition11) || ENABLE(Condition12) 661 662static void Node14AttrGetterCallback(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info) 663{ 664 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); 665 TestInterfaceV8Internal::Node14AttrGetter(name, info); 666 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); 667} 668 669#endif // ENABLE(Condition11) || ENABLE(Condition12) 670 671#if ENABLE(Condition11) || ENABLE(Condition12) 672 673static void Node14AttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info) 674{ 675 TestInterface* imp = V8TestInterface::toNative(info.Holder()); 676 V8TRYCATCH_VOID(Node*, v, V8Node::HasInstance(value, info.GetIsolate(), worldType(info.GetIsolate())) ? V8Node::toNative(v8::Handle<v8::Object>::Cast(value)) : 0); 677 TestPartialInterface::setNode14(imp, WTF::getPtr(v)); 678 return; 679} 680 681#endif // ENABLE(Condition11) || ENABLE(Condition12) 682 683#if ENABLE(Condition11) || ENABLE(Condition12) 684 685static void Node14AttrSetterCallback(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info) 686{ 687 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); 688 TestInterfaceV8Internal::Node14AttrSetter(name, value, info); 689 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); 690} 691 692#endif // ENABLE(Condition11) || ENABLE(Condition12) 693 694#if ENABLE(Condition11) || ENABLE(Condition12) 695 696static void Node15AttrGetter(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info) 697{ 698 TestInterface* imp = V8TestInterface::toNative(info.Holder()); 699 v8SetReturnValue(info, toV8Fast(TestPartialInterface::node15(imp), info, imp)); 700 return; 701} 702 703#endif // ENABLE(Condition11) || ENABLE(Condition12) 704 705#if ENABLE(Condition11) || ENABLE(Condition12) 706 707static void Node15AttrGetterCallback(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info) 708{ 709 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter"); 710 TestInterfaceV8Internal::Node15AttrGetter(name, info); 711 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); 712} 713 714#endif // ENABLE(Condition11) || ENABLE(Condition12) 715 716#if ENABLE(Condition11) || ENABLE(Condition12) 717 718static void Node15AttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info) 719{ 720 TestInterface* imp = V8TestInterface::toNative(info.Holder()); 721 V8TRYCATCH_VOID(Node*, v, V8Node::HasInstance(value, info.GetIsolate(), worldType(info.GetIsolate())) ? V8Node::toNative(v8::Handle<v8::Object>::Cast(value)) : 0); 722 TestPartialInterface::setNode15(imp, WTF::getPtr(v)); 723 return; 724} 725 726#endif // ENABLE(Condition11) || ENABLE(Condition12) 727 728#if ENABLE(Condition11) || ENABLE(Condition12) 729 730static void Node15AttrSetterCallback(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<void>& info) 731{ 732 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter"); 733 TestInterfaceV8Internal::Node15AttrSetter(name, value, info); 734 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); 735} 736 737#endif // ENABLE(Condition11) || ENABLE(Condition12) 738 739#if ENABLE(Condition22) || ENABLE(Condition23) 740 741static void implementsMethod1Method(const v8::FunctionCallbackInfo<v8::Value>& args) 742{ 743 TestInterface* imp = V8TestInterface::toNative(args.Holder()); 744 TestImplements::implementsMethod1(imp); 745 746 return; 747} 748 749#endif // ENABLE(Condition22) || ENABLE(Condition23) 750 751#if ENABLE(Condition22) || ENABLE(Condition23) 752 753static void implementsMethod1MethodCallback(const v8::FunctionCallbackInfo<v8::Value>& args) 754{ 755 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 756 TestInterfaceV8Internal::implementsMethod1Method(args); 757 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); 758} 759 760#endif // ENABLE(Condition22) || ENABLE(Condition23) 761 762#if ENABLE(Condition22) || ENABLE(Condition23) 763 764static void implementsMethod2Method(const v8::FunctionCallbackInfo<v8::Value>& args) 765{ 766 if (args.Length() < 2) { 767 throwNotEnoughArgumentsError(args.GetIsolate()); 768 return; 769 } 770 TestInterface* imp = V8TestInterface::toNative(args.Holder()); 771 ExceptionState es(args.GetIsolate()); 772 V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, strArg, args[0]); 773 V8TRYCATCH_VOID(TestObj*, objArg, V8TestObject::HasInstance(args[1], args.GetIsolate(), worldType(args.GetIsolate())) ? V8TestObject::toNative(v8::Handle<v8::Object>::Cast(args[1])) : 0); 774 ScriptExecutionContext* scriptContext = getScriptExecutionContext(); 775 RefPtr<TestObj> result = TestImplements::implementsMethod2(scriptContext, imp, strArg, objArg, es); 776 if (es.throwIfNeeded()) 777 return; 778 v8SetReturnValue(args, toV8(result.release(), args.Holder(), args.GetIsolate())); 779 return; 780} 781 782#endif // ENABLE(Condition22) || ENABLE(Condition23) 783 784#if ENABLE(Condition22) || ENABLE(Condition23) 785 786static void implementsMethod2MethodCallback(const v8::FunctionCallbackInfo<v8::Value>& args) 787{ 788 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 789 TestInterfaceV8Internal::implementsMethod2Method(args); 790 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); 791} 792 793#endif // ENABLE(Condition22) || ENABLE(Condition23) 794 795#if ENABLE(Condition22) || ENABLE(Condition23) 796 797static void implementsMethod3MethodCallback(const v8::FunctionCallbackInfo<v8::Value>& args) 798{ 799 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 800 V8TestInterface::implementsMethod3MethodCustom(args); 801 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); 802} 803 804#endif // ENABLE(Condition22) || ENABLE(Condition23) 805 806#if ENABLE(Condition22) || ENABLE(Condition23) 807 808static void implementsMethod4Method(const v8::FunctionCallbackInfo<v8::Value>& args) 809{ 810 TestImplements::implementsMethod4(); 811 812 return; 813} 814 815#endif // ENABLE(Condition22) || ENABLE(Condition23) 816 817#if ENABLE(Condition22) || ENABLE(Condition23) 818 819static void implementsMethod4MethodCallback(const v8::FunctionCallbackInfo<v8::Value>& args) 820{ 821 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 822 TestInterfaceV8Internal::implementsMethod4Method(args); 823 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); 824} 825 826#endif // ENABLE(Condition22) || ENABLE(Condition23) 827 828#if ENABLE(Condition11) || ENABLE(Condition12) 829 830static void supplementalMethod1Method(const v8::FunctionCallbackInfo<v8::Value>& args) 831{ 832 TestInterface* imp = V8TestInterface::toNative(args.Holder()); 833 TestPartialInterface::supplementalMethod1(imp); 834 835 return; 836} 837 838#endif // ENABLE(Condition11) || ENABLE(Condition12) 839 840#if ENABLE(Condition11) || ENABLE(Condition12) 841 842static void supplementalMethod1MethodCallback(const v8::FunctionCallbackInfo<v8::Value>& args) 843{ 844 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 845 TestInterfaceV8Internal::supplementalMethod1Method(args); 846 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); 847} 848 849#endif // ENABLE(Condition11) || ENABLE(Condition12) 850 851#if ENABLE(Condition11) || ENABLE(Condition12) 852 853static void supplementalMethod2Method(const v8::FunctionCallbackInfo<v8::Value>& args) 854{ 855 if (args.Length() < 2) { 856 throwNotEnoughArgumentsError(args.GetIsolate()); 857 return; 858 } 859 TestInterface* imp = V8TestInterface::toNative(args.Holder()); 860 ExceptionState es(args.GetIsolate()); 861 V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, strArg, args[0]); 862 V8TRYCATCH_VOID(TestObj*, objArg, V8TestObject::HasInstance(args[1], args.GetIsolate(), worldType(args.GetIsolate())) ? V8TestObject::toNative(v8::Handle<v8::Object>::Cast(args[1])) : 0); 863 ScriptExecutionContext* scriptContext = getScriptExecutionContext(); 864 RefPtr<TestObj> result = TestPartialInterface::supplementalMethod2(scriptContext, imp, strArg, objArg, es); 865 if (es.throwIfNeeded()) 866 return; 867 v8SetReturnValue(args, toV8(result.release(), args.Holder(), args.GetIsolate())); 868 return; 869} 870 871#endif // ENABLE(Condition11) || ENABLE(Condition12) 872 873#if ENABLE(Condition11) || ENABLE(Condition12) 874 875static void supplementalMethod2MethodCallback(const v8::FunctionCallbackInfo<v8::Value>& args) 876{ 877 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 878 TestInterfaceV8Internal::supplementalMethod2Method(args); 879 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); 880} 881 882#endif // ENABLE(Condition11) || ENABLE(Condition12) 883 884#if ENABLE(Condition11) || ENABLE(Condition12) 885 886static void supplementalMethod3MethodCallback(const v8::FunctionCallbackInfo<v8::Value>& args) 887{ 888 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 889 V8TestInterface::supplementalMethod3MethodCustom(args); 890 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); 891} 892 893#endif // ENABLE(Condition11) || ENABLE(Condition12) 894 895#if ENABLE(Condition11) || ENABLE(Condition12) 896 897static void supplementalMethod4Method(const v8::FunctionCallbackInfo<v8::Value>& args) 898{ 899 TestPartialInterface::supplementalMethod4(); 900 901 return; 902} 903 904#endif // ENABLE(Condition11) || ENABLE(Condition12) 905 906#if ENABLE(Condition11) || ENABLE(Condition12) 907 908static void supplementalMethod4MethodCallback(const v8::FunctionCallbackInfo<v8::Value>& args) 909{ 910 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod"); 911 TestInterfaceV8Internal::supplementalMethod4Method(args); 912 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); 913} 914 915#endif // ENABLE(Condition11) || ENABLE(Condition12) 916 917static void constructor(const v8::FunctionCallbackInfo<v8::Value>& args) 918{ 919 if (args.Length() < 1) { 920 throwNotEnoughArgumentsError(args.GetIsolate()); 921 return; 922 } 923 ExceptionState es(args.GetIsolate()); 924 V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, str1, args[0]); 925 V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(V8StringResource<>, str2, args[1]); 926 927 ScriptExecutionContext* context = getScriptExecutionContext(); 928 RefPtr<TestInterface> impl = TestInterface::create(context, str1, str2, es); 929 v8::Handle<v8::Object> wrapper = args.Holder(); 930 if (es.throwIfNeeded()) 931 return; 932 933 V8DOMWrapper::associateObjectWithWrapper<V8TestInterface>(impl.release(), &V8TestInterface::info, wrapper, args.GetIsolate(), WrapperConfiguration::Dependent); 934 args.GetReturnValue().Set(wrapper); 935} 936 937static void namedPropertyGetter(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info) 938{ 939 if (!info.Holder()->GetRealNamedPropertyInPrototypeChain(name).IsEmpty()) 940 return; 941 if (info.Holder()->HasRealNamedCallbackProperty(name)) 942 return; 943 if (info.Holder()->HasRealNamedProperty(name)) 944 return; 945 946 ASSERT(V8DOMWrapper::maybeDOMWrapper(info.Holder())); 947 TestInterface* collection = V8TestInterface::toNative(info.Holder()); 948 AtomicString propertyName = toWebCoreAtomicString(name); 949 bool element0Enabled = false; 950 RefPtr<Node> element0; 951 bool element1Enabled = false; 952 RefPtr<NodeList> element1; 953 collection->getItem(propertyName, element0Enabled, element0, element1Enabled, element1); 954 if (element0Enabled) { 955 v8SetReturnValue(info, toV8Fast(element0.release(), info, collection)); 956 return; 957 } 958 959 if (element1Enabled) { 960 v8SetReturnValue(info, toV8Fast(element1.release(), info, collection)); 961 return; 962 } 963 964 return; 965} 966 967static void namedPropertyGetterCallback(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info) 968{ 969 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMNamedProperty"); 970 TestInterfaceV8Internal::namedPropertyGetter(name, info); 971 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); 972} 973 974static void namedPropertySetterCallback(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<v8::Value>& info) 975{ 976 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMNamedProperty"); 977 V8TestInterface::namedPropertySetterCustom(name, value, info); 978 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); 979} 980 981static void namedPropertyEnumerator(const v8::PropertyCallbackInfo<v8::Array>& info) 982{ 983 ExceptionState es(info.GetIsolate()); 984 TestInterface* collection = V8TestInterface::toNative(info.Holder()); 985 Vector<String> names; 986 collection->namedPropertyEnumerator(names, es); 987 if (es.throwIfNeeded()) 988 return; 989 v8::Handle<v8::Array> v8names = v8::Array::New(names.size()); 990 for (size_t i = 0; i < names.size(); ++i) 991 v8names->Set(v8::Integer::New(i, info.GetIsolate()), v8String(names[i], info.GetIsolate())); 992 v8SetReturnValue(info, v8names); 993} 994 995static void namedPropertyQuery(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Integer>& info) 996{ 997 TestInterface* collection = V8TestInterface::toNative(info.Holder()); 998 AtomicString propertyName = toWebCoreAtomicString(name); 999 ExceptionState es(info.GetIsolate()); 1000 bool result = collection->namedPropertyQuery(propertyName, es); 1001 if (es.throwIfNeeded()) 1002 return; 1003 if (!result) 1004 return; 1005 v8SetReturnValueInt(info, v8::None); 1006} 1007 1008static void namedPropertyEnumeratorCallback(const v8::PropertyCallbackInfo<v8::Array>& info) 1009{ 1010 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMNamedProperty"); 1011 TestInterfaceV8Internal::namedPropertyEnumerator(info); 1012 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); 1013} 1014 1015static void namedPropertyQueryCallback(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Integer>& info) 1016{ 1017 TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMNamedProperty"); 1018 TestInterfaceV8Internal::namedPropertyQuery(name, info); 1019 TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution"); 1020} 1021 1022} // namespace TestInterfaceV8Internal 1023 1024static const V8DOMConfiguration::BatchedAttribute V8TestInterfaceAttrs[] = { 1025#if ENABLE(Condition22) || ENABLE(Condition23) 1026 // Attribute 'implementsStaticReadOnlyAttr' 1027 {"implementsStaticReadOnlyAttr", TestInterfaceV8Internal::implementsStaticReadOnlyAttrAttrGetterCallback, 0, 0, 0, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */}, 1028#endif // ENABLE(Condition22) || ENABLE(Condition23) 1029#if ENABLE(Condition22) || ENABLE(Condition23) 1030 // Attribute 'implementsStaticAttr' 1031 {"implementsStaticAttr", TestInterfaceV8Internal::implementsStaticAttrAttrGetterCallback, TestInterfaceV8Internal::implementsStaticAttrAttrSetterCallback, 0, 0, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */}, 1032#endif // ENABLE(Condition22) || ENABLE(Condition23) 1033#if ENABLE(Condition22) || ENABLE(Condition23) 1034 // Attribute 'implementsStr1' 1035 {"implementsStr1", TestInterfaceV8Internal::implementsStr1AttrGetterCallback, 0, 0, 0, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */}, 1036#endif // ENABLE(Condition22) || ENABLE(Condition23) 1037#if ENABLE(Condition22) || ENABLE(Condition23) 1038 // Attribute 'implementsStr2' 1039 {"implementsStr2", TestInterfaceV8Internal::implementsStr2AttrGetterCallback, TestInterfaceV8Internal::implementsStr2AttrSetterCallback, 0, 0, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */}, 1040#endif // ENABLE(Condition22) || ENABLE(Condition23) 1041#if ENABLE(Condition22) || ENABLE(Condition23) 1042 // Attribute 'implementsStr3' 1043 {"implementsStr3", TestInterfaceV8Internal::implementsStr3AttrGetterCallback, TestInterfaceV8Internal::implementsStr3AttrSetterCallback, 0, 0, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */}, 1044#endif // ENABLE(Condition22) || ENABLE(Condition23) 1045#if ENABLE(Condition22) || ENABLE(Condition23) 1046 // Attribute 'implementsNode' 1047 {"implementsNode", TestInterfaceV8Internal::implementsNodeAttrGetterCallback, TestInterfaceV8Internal::implementsNodeAttrSetterCallback, 0, 0, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */}, 1048#endif // ENABLE(Condition22) || ENABLE(Condition23) 1049#if ENABLE(Condition11) || ENABLE(Condition12) 1050 // Attribute 'supplementalStaticReadOnlyAttr' 1051 {"supplementalStaticReadOnlyAttr", TestInterfaceV8Internal::supplementalStaticReadOnlyAttrAttrGetterCallback, 0, 0, 0, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */}, 1052#endif // ENABLE(Condition11) || ENABLE(Condition12) 1053#if ENABLE(Condition11) || ENABLE(Condition12) 1054 // Attribute 'supplementalStaticAttr' 1055 {"supplementalStaticAttr", TestInterfaceV8Internal::supplementalStaticAttrAttrGetterCallback, TestInterfaceV8Internal::supplementalStaticAttrAttrSetterCallback, 0, 0, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */}, 1056#endif // ENABLE(Condition11) || ENABLE(Condition12) 1057#if ENABLE(Condition11) || ENABLE(Condition12) 1058 // Attribute 'supplementalStr1' 1059 {"supplementalStr1", TestInterfaceV8Internal::supplementalStr1AttrGetterCallback, 0, 0, 0, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */}, 1060#endif // ENABLE(Condition11) || ENABLE(Condition12) 1061#if ENABLE(Condition11) || ENABLE(Condition12) 1062 // Attribute 'supplementalStr2' 1063 {"supplementalStr2", TestInterfaceV8Internal::supplementalStr2AttrGetterCallback, TestInterfaceV8Internal::supplementalStr2AttrSetterCallback, 0, 0, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */}, 1064#endif // ENABLE(Condition11) || ENABLE(Condition12) 1065#if ENABLE(Condition11) || ENABLE(Condition12) 1066 // Attribute 'supplementalStr3' 1067 {"supplementalStr3", TestInterfaceV8Internal::supplementalStr3AttrGetterCallback, TestInterfaceV8Internal::supplementalStr3AttrSetterCallback, 0, 0, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */}, 1068#endif // ENABLE(Condition11) || ENABLE(Condition12) 1069#if ENABLE(Condition11) || ENABLE(Condition12) 1070 // Attribute 'supplementalNode' 1071 {"supplementalNode", TestInterfaceV8Internal::supplementalNodeAttrGetterCallback, TestInterfaceV8Internal::supplementalNodeAttrSetterCallback, 0, 0, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */}, 1072#endif // ENABLE(Condition11) || ENABLE(Condition12) 1073}; 1074 1075static const V8DOMConfiguration::BatchedMethod V8TestInterfaceMethods[] = { 1076#if ENABLE(Condition22) || ENABLE(Condition23) 1077 {"implementsMethod1", TestInterfaceV8Internal::implementsMethod1MethodCallback, 0, 0}, 1078#endif // ENABLE(Condition22) || ENABLE(Condition23) 1079#if ENABLE(Condition22) || ENABLE(Condition23) 1080 {"implementsMethod3", TestInterfaceV8Internal::implementsMethod3MethodCallback, 0, 0}, 1081#endif // ENABLE(Condition22) || ENABLE(Condition23) 1082#if ENABLE(Condition11) || ENABLE(Condition12) 1083 {"supplementalMethod1", TestInterfaceV8Internal::supplementalMethod1MethodCallback, 0, 0}, 1084#endif // ENABLE(Condition11) || ENABLE(Condition12) 1085#if ENABLE(Condition11) || ENABLE(Condition12) 1086 {"supplementalMethod3", TestInterfaceV8Internal::supplementalMethod3MethodCallback, 0, 0}, 1087#endif // ENABLE(Condition11) || ENABLE(Condition12) 1088}; 1089 1090static const V8DOMConfiguration::BatchedConstant V8TestInterfaceConsts[] = { 1091#if ENABLE(Condition22) || ENABLE(Condition23) 1092 {"IMPLEMENTSCONSTANT1", 1}, 1093#endif 1094#if ENABLE(Condition22) || ENABLE(Condition23) 1095 {"IMPLEMENTSCONSTANT2", 2}, 1096#endif 1097#if ENABLE(Condition11) || ENABLE(Condition12) 1098 {"SUPPLEMENTALCONSTANT1", 1}, 1099#endif 1100#if ENABLE(Condition11) || ENABLE(Condition12) 1101 {"SUPPLEMENTALCONSTANT2", 2}, 1102#endif 1103}; 1104 1105 1106#if ENABLE(Condition22) || ENABLE(Condition23) 1107COMPILE_ASSERT(1 == TestImplements::IMPLEMENTSCONSTANT1, TestInterfaceEnumIMPLEMENTSCONSTANT1IsWrongUseDoNotCheckConstants); 1108#endif 1109#if ENABLE(Condition22) || ENABLE(Condition23) 1110COMPILE_ASSERT(2 == TestImplements::CONST_IMPL, TestInterfaceEnumCONST_IMPLIsWrongUseDoNotCheckConstants); 1111#endif 1112#if ENABLE(Condition11) || ENABLE(Condition12) 1113COMPILE_ASSERT(1 == TestPartialInterface::SUPPLEMENTALCONSTANT1, TestInterfaceEnumSUPPLEMENTALCONSTANT1IsWrongUseDoNotCheckConstants); 1114#endif 1115#if ENABLE(Condition11) || ENABLE(Condition12) 1116COMPILE_ASSERT(2 == TestPartialInterface::CONST_IMPL, TestInterfaceEnumCONST_IMPLIsWrongUseDoNotCheckConstants); 1117#endif 1118 1119void V8TestInterface::constructorCallback(const v8::FunctionCallbackInfo<v8::Value>& args) 1120{ 1121 TRACE_EVENT_SCOPED_SAMPLING_STATE("Blink", "DOMConstructor"); 1122 if (!args.IsConstructCall()) { 1123 throwTypeError("DOM object constructor cannot be called as a function.", args.GetIsolate()); 1124 return; 1125 } 1126 1127 if (ConstructorMode::current() == ConstructorMode::WrapExistingObject) { 1128 args.GetReturnValue().Set(args.Holder()); 1129 return; 1130 } 1131 1132 TestInterfaceV8Internal::constructor(args); 1133} 1134 1135static v8::Handle<v8::FunctionTemplate> ConfigureV8TestInterfaceTemplate(v8::Handle<v8::FunctionTemplate> desc, v8::Isolate* isolate, WrapperWorldType currentWorldType) 1136{ 1137 desc->ReadOnlyPrototype(); 1138 1139 v8::Local<v8::Signature> defaultSignature; 1140 defaultSignature = V8DOMConfiguration::configureTemplate(desc, "TestInterface", v8::Local<v8::FunctionTemplate>(), V8TestInterface::internalFieldCount, 1141 V8TestInterfaceAttrs, WTF_ARRAY_LENGTH(V8TestInterfaceAttrs), 1142 V8TestInterfaceMethods, WTF_ARRAY_LENGTH(V8TestInterfaceMethods), isolate, currentWorldType); 1143 UNUSED_PARAM(defaultSignature); // In some cases, it will not be used. 1144 desc->SetCallHandler(V8TestInterface::constructorCallback); 1145 desc->SetLength(1); 1146 v8::Local<v8::ObjectTemplate> instance = desc->InstanceTemplate(); 1147 v8::Local<v8::ObjectTemplate> proto = desc->PrototypeTemplate(); 1148 UNUSED_PARAM(instance); // In some cases, it will not be used. 1149 UNUSED_PARAM(proto); // In some cases, it will not be used. 1150 1151#if ENABLE(Condition22) || ENABLE(Condition23) 1152 if (RuntimeEnabledFeatures::condition23Enabled()) { 1153 static const V8DOMConfiguration::BatchedAttribute attrData =\ 1154 // Attribute 'Node23' 1155 {"Node23", TestInterfaceV8Internal::Node23AttrGetterCallback, TestInterfaceV8Internal::Node23AttrSetterCallback, 0, 0, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */}; 1156 V8DOMConfiguration::configureAttribute(instance, proto, attrData, isolate, currentWorldType); 1157 } 1158 1159#endif // ENABLE(Condition22) || ENABLE(Condition23) 1160 1161#if ENABLE(Condition11) || ENABLE(Condition12) 1162 if (RuntimeEnabledFeatures::condition13Enabled()) { 1163 static const V8DOMConfiguration::BatchedAttribute attrData =\ 1164 // Attribute 'Node13' 1165 {"Node13", TestInterfaceV8Internal::Node13AttrGetterCallback, TestInterfaceV8Internal::Node13AttrSetterCallback, 0, 0, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */}; 1166 V8DOMConfiguration::configureAttribute(instance, proto, attrData, isolate, currentWorldType); 1167 } 1168 1169#endif // ENABLE(Condition11) || ENABLE(Condition12) 1170 desc->InstanceTemplate()->SetNamedPropertyHandler(TestInterfaceV8Internal::namedPropertyGetterCallback, TestInterfaceV8Internal::namedPropertySetterCallback, TestInterfaceV8Internal::namedPropertyQueryCallback, 0, TestInterfaceV8Internal::namedPropertyEnumeratorCallback); 1171#if ENABLE(Condition22) || ENABLE(Condition23) 1172 1173 // Custom Signature 'implementsMethod2' 1174 const int implementsMethod2Argc = 2; 1175 v8::Handle<v8::FunctionTemplate> implementsMethod2Argv[implementsMethod2Argc] = { v8::Handle<v8::FunctionTemplate>(), V8PerIsolateData::from(isolate)->rawTemplate(&V8TestObject::info, currentWorldType) }; 1176 v8::Handle<v8::Signature> implementsMethod2Signature = v8::Signature::New(desc, implementsMethod2Argc, implementsMethod2Argv); 1177 proto->Set(v8::String::NewSymbol("implementsMethod2"), v8::FunctionTemplate::New(TestInterfaceV8Internal::implementsMethod2MethodCallback, v8Undefined(), implementsMethod2Signature, 2)); 1178#endif // ENABLE(Condition22) || ENABLE(Condition23) 1179#if ENABLE(Condition22) || ENABLE(Condition23) 1180 desc->Set(v8::String::NewSymbol("implementsMethod4"), v8::FunctionTemplate::New(TestInterfaceV8Internal::implementsMethod4MethodCallback, v8Undefined(), v8::Local<v8::Signature>(), 0)); 1181#endif // ENABLE(Condition22) || ENABLE(Condition23) 1182#if ENABLE(Condition11) || ENABLE(Condition12) 1183 1184 // Custom Signature 'supplementalMethod2' 1185 const int supplementalMethod2Argc = 2; 1186 v8::Handle<v8::FunctionTemplate> supplementalMethod2Argv[supplementalMethod2Argc] = { v8::Handle<v8::FunctionTemplate>(), V8PerIsolateData::from(isolate)->rawTemplate(&V8TestObject::info, currentWorldType) }; 1187 v8::Handle<v8::Signature> supplementalMethod2Signature = v8::Signature::New(desc, supplementalMethod2Argc, supplementalMethod2Argv); 1188 proto->Set(v8::String::NewSymbol("supplementalMethod2"), v8::FunctionTemplate::New(TestInterfaceV8Internal::supplementalMethod2MethodCallback, v8Undefined(), supplementalMethod2Signature, 2)); 1189#endif // ENABLE(Condition11) || ENABLE(Condition12) 1190#if ENABLE(Condition11) || ENABLE(Condition12) 1191 desc->Set(v8::String::NewSymbol("supplementalMethod4"), v8::FunctionTemplate::New(TestInterfaceV8Internal::supplementalMethod4MethodCallback, v8Undefined(), v8::Local<v8::Signature>(), 0)); 1192#endif // ENABLE(Condition11) || ENABLE(Condition12) 1193 V8DOMConfiguration::batchConfigureConstants(desc, proto, V8TestInterfaceConsts, WTF_ARRAY_LENGTH(V8TestInterfaceConsts), isolate); 1194 1195 // Custom toString template 1196 desc->Set(v8::String::NewSymbol("toString"), V8PerIsolateData::current()->toStringTemplate()); 1197 return desc; 1198} 1199 1200v8::Handle<v8::FunctionTemplate> V8TestInterface::GetTemplate(v8::Isolate* isolate, WrapperWorldType currentWorldType) 1201{ 1202 V8PerIsolateData* data = V8PerIsolateData::from(isolate); 1203 V8PerIsolateData::TemplateMap::iterator result = data->templateMap(currentWorldType).find(&info); 1204 if (result != data->templateMap(currentWorldType).end()) 1205 return result->value.newLocal(isolate); 1206 1207 TRACE_EVENT_SCOPED_SAMPLING_STATE("Blink", "BuildDOMTemplate"); 1208 v8::HandleScope handleScope(isolate); 1209 v8::Handle<v8::FunctionTemplate> templ = 1210 ConfigureV8TestInterfaceTemplate(data->rawTemplate(&info, currentWorldType), isolate, currentWorldType); 1211 data->templateMap(currentWorldType).add(&info, UnsafePersistent<v8::FunctionTemplate>(isolate, templ)); 1212 return handleScope.Close(templ); 1213} 1214 1215bool V8TestInterface::HasInstance(v8::Handle<v8::Value> value, v8::Isolate* isolate, WrapperWorldType currentWorldType) 1216{ 1217 return V8PerIsolateData::from(isolate)->hasInstance(&info, value, currentWorldType); 1218} 1219 1220bool V8TestInterface::HasInstanceInAnyWorld(v8::Handle<v8::Value> value, v8::Isolate* isolate) 1221{ 1222 return V8PerIsolateData::from(isolate)->hasInstance(&info, value, MainWorld) 1223 || V8PerIsolateData::from(isolate)->hasInstance(&info, value, IsolatedWorld) 1224 || V8PerIsolateData::from(isolate)->hasInstance(&info, value, WorkerWorld); 1225} 1226 1227void V8TestInterface::installPerContextProperties(v8::Handle<v8::Object> instance, TestInterface* impl, v8::Isolate* isolate) 1228{ 1229 v8::Local<v8::Object> proto = v8::Local<v8::Object>::Cast(instance->GetPrototype()); 1230 1231#if ENABLE(Condition22) || ENABLE(Condition23) 1232 if (ContextFeatures::condition24Enabled(impl->document())) { 1233 static const V8DOMConfiguration::BatchedAttribute attrData =\ 1234 // Attribute 'Node24' 1235 {"Node24", TestInterfaceV8Internal::Node24AttrGetterCallback, TestInterfaceV8Internal::Node24AttrSetterCallback, 0, 0, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */}; 1236 V8DOMConfiguration::configureAttribute(instance, proto, attrData, isolate); 1237 } 1238#endif // ENABLE(Condition22) || ENABLE(Condition23) 1239 1240#if ENABLE(Condition22) || ENABLE(Condition23) 1241 if (ContextFeatures::condition26Enabled(impl->document()) && RuntimeEnabledFeatures::condition25Enabled()) { 1242 static const V8DOMConfiguration::BatchedAttribute attrData =\ 1243 // Attribute 'Node25' 1244 {"Node25", TestInterfaceV8Internal::Node25AttrGetterCallback, TestInterfaceV8Internal::Node25AttrSetterCallback, 0, 0, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */}; 1245 V8DOMConfiguration::configureAttribute(instance, proto, attrData, isolate); 1246 } 1247#endif // ENABLE(Condition22) || ENABLE(Condition23) 1248 1249#if ENABLE(Condition11) || ENABLE(Condition12) 1250 if (ContextFeatures::condition14Enabled(impl->document())) { 1251 static const V8DOMConfiguration::BatchedAttribute attrData =\ 1252 // Attribute 'Node14' 1253 {"Node14", TestInterfaceV8Internal::Node14AttrGetterCallback, TestInterfaceV8Internal::Node14AttrSetterCallback, 0, 0, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */}; 1254 V8DOMConfiguration::configureAttribute(instance, proto, attrData, isolate); 1255 } 1256#endif // ENABLE(Condition11) || ENABLE(Condition12) 1257 1258#if ENABLE(Condition11) || ENABLE(Condition12) 1259 if (ContextFeatures::condition16Enabled(impl->document()) && RuntimeEnabledFeatures::condition15Enabled()) { 1260 static const V8DOMConfiguration::BatchedAttribute attrData =\ 1261 // Attribute 'Node15' 1262 {"Node15", TestInterfaceV8Internal::Node15AttrGetterCallback, TestInterfaceV8Internal::Node15AttrSetterCallback, 0, 0, 0 /* no data */, static_cast<v8::AccessControl>(v8::DEFAULT), static_cast<v8::PropertyAttribute>(v8::None), 0 /* on instance */}; 1263 V8DOMConfiguration::configureAttribute(instance, proto, attrData, isolate); 1264 } 1265#endif // ENABLE(Condition11) || ENABLE(Condition12) 1266} 1267 1268ActiveDOMObject* V8TestInterface::toActiveDOMObject(v8::Handle<v8::Object> object) 1269{ 1270 return toNative(object); 1271} 1272 1273 1274v8::Handle<v8::Object> V8TestInterface::createWrapper(PassRefPtr<TestInterface> impl, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate) 1275{ 1276 ASSERT(impl.get()); 1277 ASSERT(DOMDataStore::getWrapper<V8TestInterface>(impl.get(), isolate).IsEmpty()); 1278 if (ScriptWrappable::wrapperCanBeStoredInObject(impl.get())) { 1279 const WrapperTypeInfo* actualInfo = ScriptWrappable::getTypeInfoFromObject(impl.get()); 1280 // Might be a XXXConstructor::info instead of an XXX::info. These will both have 1281 // the same object de-ref functions, though, so use that as the basis of the check. 1282 RELEASE_ASSERT_WITH_SECURITY_IMPLICATION(actualInfo->derefObjectFunction == info.derefObjectFunction); 1283 } 1284 1285 1286 v8::Handle<v8::Object> wrapper = V8DOMWrapper::createWrapper(creationContext, &info, toInternalPointer(impl.get()), isolate); 1287 if (UNLIKELY(wrapper.IsEmpty())) 1288 return wrapper; 1289 installPerContextProperties(wrapper, impl.get(), isolate); 1290 V8DOMWrapper::associateObjectWithWrapper<V8TestInterface>(impl, &info, wrapper, isolate, WrapperConfiguration::Dependent); 1291 return wrapper; 1292} 1293void V8TestInterface::derefObject(void* object) 1294{ 1295 fromInternalPointer(object)->deref(); 1296} 1297 1298} // namespace WebCore 1299 1300#endif // ENABLE(Condition1) || ENABLE(Condition2) 1301