1 /* 2 * Copyright (C) 2010 Google Inc. All rights reserved. 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions 6 * are met: 7 * 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY 15 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 16 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 17 * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY 18 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 19 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 20 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 21 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 23 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 24 */ 25 26 #include "config.h" 27 #include "bindings/v8/Dictionary.h" 28 29 #include "bindings/core/v8/V8DOMError.h" 30 #include "bindings/core/v8/V8EventTarget.h" 31 #include "bindings/core/v8/V8MediaKeyError.h" 32 #include "bindings/core/v8/V8MessagePort.h" 33 #include "bindings/core/v8/V8Storage.h" 34 #include "bindings/core/v8/V8TextTrack.h" 35 #include "bindings/core/v8/V8VoidCallback.h" 36 #include "bindings/core/v8/V8Window.h" 37 #include "bindings/modules/v8/V8Gamepad.h" 38 #include "bindings/modules/v8/V8HeaderMap.h" 39 #include "bindings/modules/v8/V8IDBKeyRange.h" 40 #include "bindings/modules/v8/V8MIDIPort.h" 41 #include "bindings/modules/v8/V8MediaStream.h" 42 #include "bindings/modules/v8/V8SpeechRecognitionResult.h" 43 #include "bindings/modules/v8/V8SpeechRecognitionResultList.h" 44 #include "bindings/v8/ArrayValue.h" 45 #include "bindings/v8/ExceptionMessages.h" 46 #include "bindings/v8/ExceptionState.h" 47 #include "bindings/v8/V8Binding.h" 48 #include "bindings/v8/custom/V8ArrayBufferViewCustom.h" 49 #include "bindings/v8/custom/V8Uint8ArrayCustom.h" 50 #include "core/html/track/TrackBase.h" 51 #include "modules/gamepad/Gamepad.h" 52 #include "modules/indexeddb/IDBKeyRange.h" 53 #include "modules/mediastream/MediaStream.h" 54 #include "modules/speech/SpeechRecognitionResult.h" 55 #include "modules/speech/SpeechRecognitionResultList.h" 56 #include "wtf/MathExtras.h" 57 58 namespace WebCore { 59 60 Dictionary::Dictionary() 61 : m_isolate(0) 62 { 63 } 64 65 Dictionary::Dictionary(const v8::Handle<v8::Value>& options, v8::Isolate* isolate) 66 : m_options(options) 67 , m_isolate(isolate) 68 { 69 ASSERT(m_isolate); 70 } 71 72 Dictionary::~Dictionary() 73 { 74 } 75 76 Dictionary& Dictionary::operator=(const Dictionary& optionsObject) 77 { 78 m_options = optionsObject.m_options; 79 m_isolate = optionsObject.m_isolate; 80 return *this; 81 } 82 83 bool Dictionary::isObject() const 84 { 85 return !isUndefinedOrNull() && m_options->IsObject(); 86 } 87 88 bool Dictionary::isUndefinedOrNull() const 89 { 90 if (m_options.IsEmpty()) 91 return true; 92 return WebCore::isUndefinedOrNull(m_options); 93 } 94 95 bool Dictionary::hasProperty(const String& key) const 96 { 97 if (isUndefinedOrNull()) 98 return false; 99 v8::Local<v8::Object> options = m_options->ToObject(); 100 ASSERT(!options.IsEmpty()); 101 102 ASSERT(m_isolate); 103 ASSERT(m_isolate == v8::Isolate::GetCurrent()); 104 v8::Handle<v8::String> v8Key = v8String(m_isolate, key); 105 if (!options->Has(v8Key)) 106 return false; 107 108 return true; 109 } 110 111 bool Dictionary::getKey(const String& key, v8::Local<v8::Value>& value) const 112 { 113 if (isUndefinedOrNull()) 114 return false; 115 v8::Local<v8::Object> options = m_options->ToObject(); 116 ASSERT(!options.IsEmpty()); 117 118 ASSERT(m_isolate); 119 ASSERT(m_isolate == v8::Isolate::GetCurrent()); 120 v8::Handle<v8::String> v8Key = v8String(m_isolate, key); 121 if (!options->Has(v8Key)) 122 return false; 123 value = options->Get(v8Key); 124 if (value.IsEmpty()) 125 return false; 126 return true; 127 } 128 129 bool Dictionary::get(const String& key, v8::Local<v8::Value>& value) const 130 { 131 return getKey(key, value); 132 } 133 134 bool Dictionary::get(const String& key, bool& value) const 135 { 136 v8::Local<v8::Value> v8Value; 137 if (!getKey(key, v8Value)) 138 return false; 139 140 v8::Local<v8::Boolean> v8Bool = v8Value->ToBoolean(); 141 if (v8Bool.IsEmpty()) 142 return false; 143 value = v8Bool->Value(); 144 return true; 145 } 146 147 bool Dictionary::convert(ConversionContext& context, const String& key, bool& value) const 148 { 149 ConversionContextScope scope(context); 150 get(key, value); 151 return true; 152 } 153 154 bool Dictionary::get(const String& key, int32_t& value) const 155 { 156 v8::Local<v8::Value> v8Value; 157 if (!getKey(key, v8Value)) 158 return false; 159 160 v8::Local<v8::Int32> v8Int32 = v8Value->ToInt32(); 161 if (v8Int32.IsEmpty()) 162 return false; 163 value = v8Int32->Value(); 164 return true; 165 } 166 167 bool Dictionary::get(const String& key, double& value, bool& hasValue) const 168 { 169 v8::Local<v8::Value> v8Value; 170 if (!getKey(key, v8Value)) { 171 hasValue = false; 172 return false; 173 } 174 175 hasValue = true; 176 TONATIVE_DEFAULT(v8::Local<v8::Number>, v8Number, v8Value->ToNumber(), false); 177 if (v8Number.IsEmpty()) 178 return false; 179 value = v8Number->Value(); 180 return true; 181 } 182 183 bool Dictionary::get(const String& key, double& value) const 184 { 185 bool unused; 186 return get(key, value, unused); 187 } 188 189 bool Dictionary::convert(ConversionContext& context, const String& key, double& value) const 190 { 191 ConversionContextScope scope(context); 192 193 bool hasValue = false; 194 if (!get(key, value, hasValue) && hasValue) { 195 context.throwTypeError(ExceptionMessages::incorrectPropertyType(key, "is not of type 'double'.")); 196 return false; 197 } 198 return true; 199 } 200 201 template<typename StringType> 202 inline bool Dictionary::getStringType(const String& key, StringType& value) const 203 { 204 v8::Local<v8::Value> v8Value; 205 if (!getKey(key, v8Value)) 206 return false; 207 208 TOSTRING_DEFAULT(V8StringResource<>, stringValue, v8Value, false); 209 value = stringValue; 210 return true; 211 } 212 213 bool Dictionary::get(const String& key, String& value) const 214 { 215 return getStringType(key, value); 216 } 217 218 bool Dictionary::get(const String& key, AtomicString& value) const 219 { 220 return getStringType(key, value); 221 } 222 223 bool Dictionary::convert(ConversionContext& context, const String& key, String& value) const 224 { 225 ConversionContextScope scope(context); 226 227 v8::Local<v8::Value> v8Value; 228 if (!getKey(key, v8Value)) 229 return true; 230 231 TOSTRING_DEFAULT(V8StringResource<>, stringValue, v8Value, false); 232 value = stringValue; 233 return true; 234 } 235 236 bool Dictionary::get(const String& key, ScriptValue& value) const 237 { 238 v8::Local<v8::Value> v8Value; 239 if (!getKey(key, v8Value)) 240 return false; 241 242 value = ScriptValue(ScriptState::current(m_isolate), v8Value); 243 return true; 244 } 245 246 bool Dictionary::convert(ConversionContext& context, const String& key, ScriptValue& value) const 247 { 248 ConversionContextScope scope(context); 249 250 get(key, value); 251 return true; 252 } 253 254 bool Dictionary::get(const String& key, unsigned short& value) const 255 { 256 v8::Local<v8::Value> v8Value; 257 if (!getKey(key, v8Value)) 258 return false; 259 260 v8::Local<v8::Int32> v8Int32 = v8Value->ToInt32(); 261 if (v8Int32.IsEmpty()) 262 return false; 263 value = static_cast<unsigned short>(v8Int32->Value()); 264 return true; 265 } 266 267 bool Dictionary::get(const String& key, short& value) const 268 { 269 v8::Local<v8::Value> v8Value; 270 if (!getKey(key, v8Value)) 271 return false; 272 273 v8::Local<v8::Int32> v8Int32 = v8Value->ToInt32(); 274 if (v8Int32.IsEmpty()) 275 return false; 276 value = static_cast<short>(v8Int32->Value()); 277 return true; 278 } 279 280 bool Dictionary::get(const String& key, unsigned& value) const 281 { 282 v8::Local<v8::Value> v8Value; 283 if (!getKey(key, v8Value)) 284 return false; 285 286 v8::Local<v8::Int32> v8Int32 = v8Value->ToInt32(); 287 if (v8Int32.IsEmpty()) 288 return false; 289 value = static_cast<unsigned>(v8Int32->Value()); 290 return true; 291 } 292 293 bool Dictionary::get(const String& key, unsigned long& value) const 294 { 295 v8::Local<v8::Value> v8Value; 296 if (!getKey(key, v8Value)) 297 return false; 298 299 v8::Local<v8::Integer> v8Integer = v8Value->ToInteger(); 300 if (v8Integer.IsEmpty()) 301 return false; 302 value = static_cast<unsigned long>(v8Integer->Value()); 303 return true; 304 } 305 306 bool Dictionary::get(const String& key, unsigned long long& value) const 307 { 308 v8::Local<v8::Value> v8Value; 309 if (!getKey(key, v8Value)) 310 return false; 311 312 TONATIVE_DEFAULT(v8::Local<v8::Number>, v8Number, v8Value->ToNumber(), false); 313 if (v8Number.IsEmpty()) 314 return false; 315 double d = v8Number->Value(); 316 doubleToInteger(d, value); 317 return true; 318 } 319 320 bool Dictionary::get(const String& key, RefPtrWillBeMember<LocalDOMWindow>& value) const 321 { 322 v8::Local<v8::Value> v8Value; 323 if (!getKey(key, v8Value)) 324 return false; 325 326 // We need to handle a DOMWindow specially, because a DOMWindow wrapper 327 // exists on a prototype chain of v8Value. 328 value = toDOMWindow(v8Value, m_isolate); 329 return true; 330 } 331 332 bool Dictionary::get(const String& key, RefPtrWillBeMember<Storage>& value) const 333 { 334 v8::Local<v8::Value> v8Value; 335 if (!getKey(key, v8Value)) 336 return false; 337 338 value = V8Storage::toNativeWithTypeCheck(m_isolate, v8Value); 339 return true; 340 } 341 342 bool Dictionary::get(const String& key, MessagePortArray& value) const 343 { 344 v8::Local<v8::Value> v8Value; 345 if (!getKey(key, v8Value)) 346 return false; 347 348 ASSERT(m_isolate); 349 ASSERT(m_isolate == v8::Isolate::GetCurrent()); 350 if (WebCore::isUndefinedOrNull(v8Value)) 351 return true; 352 bool success = false; 353 value = toRefPtrNativeArray<MessagePort, V8MessagePort>(v8Value, key, m_isolate, &success); 354 return success; 355 } 356 357 bool Dictionary::convert(ConversionContext& context, const String& key, MessagePortArray& value) const 358 { 359 ConversionContextScope scope(context); 360 361 v8::Local<v8::Value> v8Value; 362 if (!getKey(key, v8Value)) 363 return true; 364 365 return get(key, value); 366 } 367 368 bool Dictionary::get(const String& key, HashSet<AtomicString>& value) const 369 { 370 v8::Local<v8::Value> v8Value; 371 if (!getKey(key, v8Value)) 372 return false; 373 374 // FIXME: Support array-like objects 375 if (!v8Value->IsArray()) 376 return false; 377 378 ASSERT(m_isolate); 379 ASSERT(m_isolate == v8::Isolate::GetCurrent()); 380 v8::Local<v8::Array> v8Array = v8::Local<v8::Array>::Cast(v8Value); 381 for (size_t i = 0; i < v8Array->Length(); ++i) { 382 v8::Local<v8::Value> indexedValue = v8Array->Get(v8::Integer::New(m_isolate, i)); 383 TOSTRING_DEFAULT(V8StringResource<>, stringValue, indexedValue, false); 384 value.add(stringValue); 385 } 386 387 return true; 388 } 389 390 bool Dictionary::convert(ConversionContext& context, const String& key, HashSet<AtomicString>& value) const 391 { 392 ConversionContextScope scope(context); 393 394 v8::Local<v8::Value> v8Value; 395 if (!getKey(key, v8Value)) 396 return true; 397 398 if (context.isNullable() && WebCore::isUndefinedOrNull(v8Value)) 399 return true; 400 401 if (!v8Value->IsArray()) { 402 context.throwTypeError(ExceptionMessages::notASequenceTypeProperty(key)); 403 return false; 404 } 405 406 return get(key, value); 407 } 408 409 bool Dictionary::getWithUndefinedOrNullCheck(const String& key, String& value) const 410 { 411 v8::Local<v8::Value> v8Value; 412 if (!getKey(key, v8Value) || WebCore::isUndefinedOrNull(v8Value)) 413 return false; 414 415 TOSTRING_DEFAULT(V8StringResource<>, stringValue, v8Value, false); 416 value = stringValue; 417 return true; 418 } 419 420 bool Dictionary::get(const String& key, RefPtr<Uint8Array>& value) const 421 { 422 v8::Local<v8::Value> v8Value; 423 if (!getKey(key, v8Value)) 424 return false; 425 426 value = V8Uint8Array::toNativeWithTypeCheck(m_isolate, v8Value); 427 return true; 428 } 429 430 bool Dictionary::get(const String& key, RefPtr<ArrayBufferView>& value) const 431 { 432 v8::Local<v8::Value> v8Value; 433 if (!getKey(key, v8Value)) 434 return false; 435 436 value = V8ArrayBufferView::toNativeWithTypeCheck(m_isolate, v8Value); 437 return true; 438 } 439 440 bool Dictionary::get(const String& key, RefPtrWillBeMember<MIDIPort>& value) const 441 { 442 v8::Local<v8::Value> v8Value; 443 if (!getKey(key, v8Value)) 444 return false; 445 446 value = V8MIDIPort::toNativeWithTypeCheck(m_isolate, v8Value); 447 return true; 448 } 449 450 bool Dictionary::get(const String& key, RefPtr<MediaKeyError>& value) const 451 { 452 v8::Local<v8::Value> v8Value; 453 if (!getKey(key, v8Value)) 454 return false; 455 456 value = V8MediaKeyError::toNativeWithTypeCheck(m_isolate, v8Value); 457 return true; 458 } 459 460 bool Dictionary::get(const String& key, RefPtrWillBeMember<TrackBase>& value) const 461 { 462 v8::Local<v8::Value> v8Value; 463 if (!getKey(key, v8Value)) 464 return false; 465 466 TrackBase* source = 0; 467 if (v8Value->IsObject()) { 468 v8::Handle<v8::Object> wrapper = v8::Handle<v8::Object>::Cast(v8Value); 469 470 // FIXME: this will need to be changed so it can also return an AudioTrack or a VideoTrack once 471 // we add them. 472 v8::Handle<v8::Object> track = V8TextTrack::findInstanceInPrototypeChain(wrapper, m_isolate); 473 if (!track.IsEmpty()) 474 source = V8TextTrack::toNative(track); 475 } 476 value = source; 477 return true; 478 } 479 480 bool Dictionary::get(const String& key, Member<SpeechRecognitionResult>& value) const 481 { 482 v8::Local<v8::Value> v8Value; 483 if (!getKey(key, v8Value)) 484 return false; 485 486 value = V8SpeechRecognitionResult::toNativeWithTypeCheck(m_isolate, v8Value); 487 return true; 488 } 489 490 bool Dictionary::get(const String& key, Member<SpeechRecognitionResultList>& value) const 491 { 492 v8::Local<v8::Value> v8Value; 493 if (!getKey(key, v8Value)) 494 return false; 495 496 value = V8SpeechRecognitionResultList::toNativeWithTypeCheck(m_isolate, v8Value); 497 return true; 498 } 499 500 bool Dictionary::get(const String& key, Member<Gamepad>& value) const 501 { 502 v8::Local<v8::Value> v8Value; 503 if (!getKey(key, v8Value)) 504 return false; 505 506 value = V8Gamepad::toNativeWithTypeCheck(m_isolate, v8Value); 507 return true; 508 } 509 510 bool Dictionary::get(const String& key, RefPtr<MediaStream>& value) const 511 { 512 v8::Local<v8::Value> v8Value; 513 if (!getKey(key, v8Value)) 514 return false; 515 516 value = V8MediaStream::toNativeWithTypeCheck(m_isolate, v8Value); 517 return true; 518 } 519 520 bool Dictionary::get(const String& key, RefPtrWillBeMember<EventTarget>& value) const 521 { 522 v8::Local<v8::Value> v8Value; 523 if (!getKey(key, v8Value)) 524 return false; 525 526 value = nullptr; 527 // We need to handle a LocalDOMWindow specially, because a LocalDOMWindow wrapper 528 // exists on a prototype chain of v8Value. 529 if (v8Value->IsObject()) { 530 v8::Handle<v8::Object> wrapper = v8::Handle<v8::Object>::Cast(v8Value); 531 v8::Handle<v8::Object> window = V8Window::findInstanceInPrototypeChain(wrapper, m_isolate); 532 if (!window.IsEmpty()) { 533 value = toWrapperTypeInfo(window)->toEventTarget(window); 534 return true; 535 } 536 } 537 538 if (V8DOMWrapper::isDOMWrapper(v8Value)) { 539 v8::Handle<v8::Object> wrapper = v8::Handle<v8::Object>::Cast(v8Value); 540 value = toWrapperTypeInfo(wrapper)->toEventTarget(wrapper); 541 } 542 return true; 543 } 544 545 bool Dictionary::get(const String& key, Dictionary& value) const 546 { 547 v8::Local<v8::Value> v8Value; 548 if (!getKey(key, v8Value)) 549 return false; 550 551 if (v8Value->IsObject()) { 552 ASSERT(m_isolate); 553 ASSERT(m_isolate == v8::Isolate::GetCurrent()); 554 value = Dictionary(v8Value, m_isolate); 555 } 556 557 return true; 558 } 559 560 bool Dictionary::get(const String& key, RefPtr<HeaderMap>& value) const 561 { 562 v8::Local<v8::Value> v8Value; 563 if (!getKey(key, v8Value)) 564 return false; 565 566 value = V8HeaderMap::toNativeWithTypeCheck(m_isolate, v8Value); 567 return true; 568 } 569 570 bool Dictionary::convert(ConversionContext& context, const String& key, Dictionary& value) const 571 { 572 ConversionContextScope scope(context); 573 574 v8::Local<v8::Value> v8Value; 575 if (!getKey(key, v8Value)) 576 return true; 577 578 if (v8Value->IsObject()) 579 return get(key, value); 580 581 if (context.isNullable() && WebCore::isUndefinedOrNull(v8Value)) 582 return true; 583 584 context.throwTypeError(ExceptionMessages::incorrectPropertyType(key, "does not have a Dictionary type.")); 585 return false; 586 } 587 588 bool Dictionary::get(const String& key, Vector<String>& value) const 589 { 590 v8::Local<v8::Value> v8Value; 591 if (!getKey(key, v8Value)) 592 return false; 593 594 if (!v8Value->IsArray()) 595 return false; 596 597 v8::Local<v8::Array> v8Array = v8::Local<v8::Array>::Cast(v8Value); 598 for (size_t i = 0; i < v8Array->Length(); ++i) { 599 v8::Local<v8::Value> indexedValue = v8Array->Get(v8::Uint32::New(m_isolate, i)); 600 TOSTRING_DEFAULT(V8StringResource<>, stringValue, indexedValue, false); 601 value.append(stringValue); 602 } 603 604 return true; 605 } 606 607 bool Dictionary::convert(ConversionContext& context, const String& key, Vector<String>& value) const 608 { 609 ConversionContextScope scope(context); 610 611 v8::Local<v8::Value> v8Value; 612 if (!getKey(key, v8Value)) 613 return true; 614 615 if (context.isNullable() && WebCore::isUndefinedOrNull(v8Value)) 616 return true; 617 618 if (!v8Value->IsArray()) { 619 context.throwTypeError(ExceptionMessages::notASequenceTypeProperty(key)); 620 return false; 621 } 622 623 return get(key, value); 624 } 625 626 bool Dictionary::get(const String& key, ArrayValue& value) const 627 { 628 v8::Local<v8::Value> v8Value; 629 if (!getKey(key, v8Value)) 630 return false; 631 632 if (!v8Value->IsArray()) 633 return false; 634 635 ASSERT(m_isolate); 636 ASSERT(m_isolate == v8::Isolate::GetCurrent()); 637 value = ArrayValue(v8::Local<v8::Array>::Cast(v8Value), m_isolate); 638 return true; 639 } 640 641 bool Dictionary::convert(ConversionContext& context, const String& key, ArrayValue& value) const 642 { 643 ConversionContextScope scope(context); 644 645 v8::Local<v8::Value> v8Value; 646 if (!getKey(key, v8Value)) 647 return true; 648 649 if (context.isNullable() && WebCore::isUndefinedOrNull(v8Value)) 650 return true; 651 652 if (!v8Value->IsArray()) { 653 context.throwTypeError(ExceptionMessages::notASequenceTypeProperty(key)); 654 return false; 655 } 656 657 return get(key, value); 658 } 659 660 bool Dictionary::get(const String& key, RefPtrWillBeMember<DOMError>& value) const 661 { 662 v8::Local<v8::Value> v8Value; 663 if (!getKey(key, v8Value)) 664 return false; 665 666 value = V8DOMError::toNativeWithTypeCheck(m_isolate, v8Value); 667 return true; 668 } 669 670 bool Dictionary::getOwnPropertiesAsStringHashMap(HashMap<String, String>& hashMap) const 671 { 672 if (!isObject()) 673 return false; 674 675 v8::Handle<v8::Object> options = m_options->ToObject(); 676 if (options.IsEmpty()) 677 return false; 678 679 v8::Local<v8::Array> properties = options->GetOwnPropertyNames(); 680 if (properties.IsEmpty()) 681 return true; 682 for (uint32_t i = 0; i < properties->Length(); ++i) { 683 v8::Local<v8::String> key = properties->Get(i)->ToString(); 684 if (!options->Has(key)) 685 continue; 686 687 v8::Local<v8::Value> value = options->Get(key); 688 TOSTRING_DEFAULT(V8StringResource<>, stringKey, key, false); 689 TOSTRING_DEFAULT(V8StringResource<>, stringValue, value, false); 690 if (!static_cast<const String&>(stringKey).isEmpty()) 691 hashMap.set(stringKey, stringValue); 692 } 693 694 return true; 695 } 696 697 bool Dictionary::getOwnPropertyNames(Vector<String>& names) const 698 { 699 if (!isObject()) 700 return false; 701 702 v8::Handle<v8::Object> options = m_options->ToObject(); 703 if (options.IsEmpty()) 704 return false; 705 706 v8::Local<v8::Array> properties = options->GetOwnPropertyNames(); 707 if (properties.IsEmpty()) 708 return true; 709 for (uint32_t i = 0; i < properties->Length(); ++i) { 710 v8::Local<v8::String> key = properties->Get(i)->ToString(); 711 if (!options->Has(key)) 712 continue; 713 TOSTRING_DEFAULT(V8StringResource<>, stringKey, key, false); 714 names.append(stringKey); 715 } 716 717 return true; 718 } 719 720 void Dictionary::ConversionContext::resetPerPropertyContext() 721 { 722 if (m_dirty) { 723 m_dirty = false; 724 m_isNullable = false; 725 m_propertyTypeName = ""; 726 } 727 } 728 729 Dictionary::ConversionContext& Dictionary::ConversionContext::setConversionType(const String& typeName, bool isNullable) 730 { 731 ASSERT(!m_dirty); 732 m_dirty = true; 733 m_isNullable = isNullable; 734 m_propertyTypeName = typeName; 735 736 return *this; 737 } 738 739 void Dictionary::ConversionContext::throwTypeError(const String& detail) 740 { 741 exceptionState().throwTypeError(detail); 742 } 743 744 } // namespace WebCore 745
