src/third_party/WebKit/Source/bindings/core/v8/DictionaryHelperForCore.cpp

   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
  28 #include "bindings/core/v8/ArrayValue.h"
  29 #include "bindings/core/v8/DictionaryHelperForBindings.h"
  30 #include "bindings/core/v8/ExceptionMessages.h"
  31 #include "bindings/core/v8/ExceptionState.h"
  32 #include "bindings/core/v8/V8Binding.h"
  33 #include "bindings/core/v8/V8DOMError.h"
  34 #include "bindings/core/v8/V8Element.h"
  35 #include "bindings/core/v8/V8EventTarget.h"
  36 #include "bindings/core/v8/V8MediaKeyError.h"
  37 #include "bindings/core/v8/V8MessagePort.h"
  38 #include "bindings/core/v8/V8Path2D.h"
  39 #include "bindings/core/v8/V8Storage.h"
  40 #include "bindings/core/v8/V8TextTrack.h"
  41 #include "bindings/core/v8/V8VoidCallback.h"
  42 #include "bindings/core/v8/V8Window.h"
  43 #include "bindings/core/v8/custom/V8ArrayBufferViewCustom.h"
  44 #include "bindings/core/v8/custom/V8Uint8ArrayCustom.h"
  45 #include "core/html/track/TrackBase.h"
  46 #include "wtf/MathExtras.h"
  47
  48 namespace blink {
  49
  50 template <>
  51 bool DictionaryHelper::get(const Dictionary& dictionary, const String& key, v8::Local<v8::Value>& value)
  52 {
  53     return dictionary.get(key, value);
  54 }
  55
  56 template <>
  57 bool DictionaryHelper::get(const Dictionary& dictionary, const String& key, Dictionary& value)
  58 {
  59     return dictionary.get(key, value);
  60 }
  61
  62 template <>
  63 bool DictionaryHelper::get(const Dictionary& dictionary, const String& key, bool& value)
  64 {
  65     v8::Local<v8::Value> v8Value;
  66     if (!dictionary.get(key, v8Value))
  67         return false;
  68
  69     v8::Local<v8::Boolean> v8Bool = v8Value->ToBoolean();
  70     if (v8Bool.IsEmpty())
  71         return false;
  72     value = v8Bool->Value();
  73     return true;
  74 }
  75
  76 template <>
  77 bool DictionaryHelper::convert(const Dictionary& dictionary, Dictionary::ConversionContext& context, const String& key, bool& value)
  78 {
  79     Dictionary::ConversionContextScope scope(context);
  80     DictionaryHelper::get(dictionary, key, value);
  81     return true;
  82 }
  83
  84 template <>
  85 bool DictionaryHelper::get(const Dictionary& dictionary, const String& key, int32_t& value)
  86 {
  87     v8::Local<v8::Value> v8Value;
  88     if (!dictionary.get(key, v8Value))
  89         return false;
  90
  91     v8::Local<v8::Int32> v8Int32 = v8Value->ToInt32();
  92     if (v8Int32.IsEmpty())
  93         return false;
  94     value = v8Int32->Value();
  95     return true;
  96 }
  97
  98 template <>
  99 bool DictionaryHelper::get(const Dictionary& dictionary, const String& key, double& value, bool& hasValue)
 100 {
 101     v8::Local<v8::Value> v8Value;
 102     if (!dictionary.get(key, v8Value)) {
 103         hasValue = false;
 104         return false;
 105     }
 106
 107     hasValue = true;
 108     TONATIVE_DEFAULT(v8::Local<v8::Number>, v8Number, v8Value->ToNumber(), false);
 109     if (v8Number.IsEmpty())
 110         return false;
 111     value = v8Number->Value();
 112     return true;
 113 }
 114
 115 template <>
 116 bool DictionaryHelper::get(const Dictionary& dictionary, const String& key, double& value)
 117 {
 118     bool unused;
 119     return DictionaryHelper::get(dictionary, key, value, unused);
 120 }
 121
 122 template <>
 123 bool DictionaryHelper::convert(const Dictionary& dictionary, Dictionary::ConversionContext& context, const String& key, double& value)
 124 {
 125     Dictionary::ConversionContextScope scope(context);
 126
 127     bool hasValue = false;
 128     if (!DictionaryHelper::get(dictionary, key, value, hasValue) && hasValue) {
 129         context.throwTypeError(ExceptionMessages::incorrectPropertyType(key, "is not of type 'double'."));
 130         return false;
 131     }
 132     return true;
 133 }
 134
 135 template<typename StringType>
 136 bool getStringType(const Dictionary& dictionary, const String& key, StringType& value)
 137 {
 138     v8::Local<v8::Value> v8Value;
 139     if (!dictionary.get(key, v8Value))
 140         return false;
 141
 142     TOSTRING_DEFAULT(V8StringResource<>, stringValue, v8Value, false);
 143     value = stringValue;
 144     return true;
 145 }
 146
 147 template <>
 148 bool DictionaryHelper::get(const Dictionary& dictionary, const String& key, String& value)
 149 {
 150     return getStringType(dictionary, key, value);
 151 }
 152
 153 template <>
 154 bool DictionaryHelper::get(const Dictionary& dictionary, const String& key, AtomicString& value)
 155 {
 156     return getStringType(dictionary, key, value);
 157 }
 158
 159 template <>
 160 bool DictionaryHelper::convert(const Dictionary& dictionary, Dictionary::ConversionContext& context, const String& key, String& value)
 161 {
 162     Dictionary::ConversionContextScope scope(context);
 163
 164     v8::Local<v8::Value> v8Value;
 165     if (!dictionary.get(key, v8Value))
 166         return true;
 167
 168     TOSTRING_DEFAULT(V8StringResource<>, stringValue, v8Value, false);
 169     value = stringValue;
 170     return true;
 171 }
 172
 173 template <>
 174 bool DictionaryHelper::get(const Dictionary& dictionary, const String& key, ScriptValue& value)
 175 {
 176     v8::Local<v8::Value> v8Value;
 177     if (!dictionary.get(key, v8Value))
 178         return false;
 179
 180     value = ScriptValue(ScriptState::current(dictionary.isolate()), v8Value);
 181     return true;
 182 }
 183
 184 template <>
 185 bool DictionaryHelper::convert(const Dictionary& dictionary, Dictionary::ConversionContext& context, const String& key, ScriptValue& value)
 186 {
 187     Dictionary::ConversionContextScope scope(context);
 188
 189     DictionaryHelper::get(dictionary, key, value);
 190     return true;
 191 }
 192
 193 template<typename NumericType>
 194 bool getNumericType(const Dictionary& dictionary, const String& key, NumericType& value)
 195 {
 196     v8::Local<v8::Value> v8Value;
 197     if (!dictionary.get(key, v8Value))
 198         return false;
 199
 200     v8::Local<v8::Int32> v8Int32 = v8Value->ToInt32();
 201     if (v8Int32.IsEmpty())
 202         return false;
 203     value = static_cast<NumericType>(v8Int32->Value());
 204     return true;
 205 }
 206
 207 template <>
 208 bool DictionaryHelper::get(const Dictionary& dictionary, const String& key, short& value)
 209 {
 210     return getNumericType<short>(dictionary, key, value);
 211 }
 212
 213 template <>
 214 bool DictionaryHelper::get(const Dictionary& dictionary, const String& key, unsigned short& value)
 215 {
 216     return getNumericType<unsigned short>(dictionary, key, value);
 217 }
 218
 219 template <>
 220 bool DictionaryHelper::get(const Dictionary& dictionary, const String& key, unsigned& value)
 221 {
 222     return getNumericType<unsigned>(dictionary, key, value);
 223 }
 224
 225 template <>
 226 bool DictionaryHelper::get(const Dictionary& dictionary, const String& key, unsigned long& value)
 227 {
 228     v8::Local<v8::Value> v8Value;
 229     if (!dictionary.get(key, v8Value))
 230         return false;
 231
 232     v8::Local<v8::Integer> v8Integer = v8Value->ToInteger();
 233     if (v8Integer.IsEmpty())
 234         return false;
 235     value = static_cast<unsigned long>(v8Integer->Value());
 236     return true;
 237 }
 238
 239 template <>
 240 bool DictionaryHelper::get(const Dictionary& dictionary, const String& key, unsigned long long& value)
 241 {
 242     v8::Local<v8::Value> v8Value;
 243     if (!dictionary.get(key, v8Value))
 244         return false;
 245
 246     TONATIVE_DEFAULT(v8::Local<v8::Number>, v8Number, v8Value->ToNumber(), false);
 247     if (v8Number.IsEmpty())
 248         return false;
 249     double d = v8Number->Value();
 250     doubleToInteger(d, value);
 251     return true;
 252 }
 253
 254 template <>
 255 bool DictionaryHelper::get(const Dictionary& dictionary, const String& key, RefPtrWillBeMember<LocalDOMWindow>& value)
 256 {
 257     v8::Local<v8::Value> v8Value;
 258     if (!dictionary.get(key, v8Value))
 259         return false;
 260
 261     // We need to handle a DOMWindow specially, because a DOMWindow wrapper
 262     // exists on a prototype chain of v8Value.
 263     value = toDOMWindow(v8Value, dictionary.isolate());
 264     return true;
 265 }
 266
 267 template <>
 268 bool DictionaryHelper::get(const Dictionary& dictionary, const String& key, HashSet<AtomicString>& value)
 269 {
 270     v8::Local<v8::Value> v8Value;
 271     if (!dictionary.get(key, v8Value))
 272         return false;
 273
 274     // FIXME: Support array-like objects
 275     if (!v8Value->IsArray())
 276         return false;
 277
 278     ASSERT(dictionary.isolate());
 279     ASSERT(dictionary.isolate() == v8::Isolate::GetCurrent());
 280     v8::Local<v8::Array> v8Array = v8::Local<v8::Array>::Cast(v8Value);
 281     for (size_t i = 0; i < v8Array->Length(); ++i) {
 282         v8::Local<v8::Value> indexedValue = v8Array->Get(v8::Integer::New(dictionary.isolate(), i));
 283         TOSTRING_DEFAULT(V8StringResource<>, stringValue, indexedValue, false);
 284         value.add(stringValue);
 285     }
 286
 287     return true;
 288 }
 289
 290 template <>
 291 bool DictionaryHelper::convert(const Dictionary& dictionary, Dictionary::ConversionContext& context, const String& key, HashSet<AtomicString>& value)
 292 {
 293     Dictionary::ConversionContextScope scope(context);
 294
 295     v8::Local<v8::Value> v8Value;
 296     if (!dictionary.get(key, v8Value))
 297         return true;
 298
 299     if (context.isNullable() && blink::isUndefinedOrNull(v8Value))
 300         return true;
 301
 302     if (!v8Value->IsArray()) {
 303         context.throwTypeError(ExceptionMessages::notASequenceTypeProperty(key));
 304         return false;
 305     }
 306
 307     return DictionaryHelper::get(dictionary, key, value);
 308 }
 309
 310 template <>
 311 bool DictionaryHelper::get(const Dictionary& dictionary, const String& key, RefPtrWillBeMember<TrackBase>& value)
 312 {
 313     v8::Local<v8::Value> v8Value;
 314     if (!dictionary.get(key, v8Value))
 315         return false;
 316
 317     TrackBase* source = 0;
 318     if (v8Value->IsObject()) {
 319         v8::Handle<v8::Object> wrapper = v8::Handle<v8::Object>::Cast(v8Value);
 320
 321         // FIXME: this will need to be changed so it can also return an AudioTrack or a VideoTrack once
 322         // we add them.
 323         v8::Handle<v8::Object> track = V8TextTrack::findInstanceInPrototypeChain(wrapper, dictionary.isolate());
 324         if (!track.IsEmpty())
 325             source = V8TextTrack::toImpl(track);
 326     }
 327     value = source;
 328     return true;
 329 }
 330
 331 template <>
 332 bool DictionaryHelper::get(const Dictionary& dictionary, const String& key, RefPtrWillBeMember<EventTarget>& value)
 333 {
 334     v8::Local<v8::Value> v8Value;
 335     if (!dictionary.get(key, v8Value))
 336         return false;
 337
 338     value = nullptr;
 339     // We need to handle a LocalDOMWindow specially, because a LocalDOMWindow wrapper
 340     // exists on a prototype chain of v8Value.
 341     if (v8Value->IsObject()) {
 342         v8::Handle<v8::Object> wrapper = v8::Handle<v8::Object>::Cast(v8Value);
 343         v8::Handle<v8::Object> window = V8Window::findInstanceInPrototypeChain(wrapper, dictionary.isolate());
 344         if (!window.IsEmpty()) {
 345             value = toWrapperTypeInfo(window)->toEventTarget(window);
 346             return true;
 347         }
 348     }
 349
 350     if (V8DOMWrapper::isDOMWrapper(v8Value)) {
 351         v8::Handle<v8::Object> wrapper = v8::Handle<v8::Object>::Cast(v8Value);
 352         value = toWrapperTypeInfo(wrapper)->toEventTarget(wrapper);
 353     }
 354     return true;
 355 }
 356
 357 template <>
 358 bool DictionaryHelper::get(const Dictionary& dictionary, const String& key, Vector<String>& value)
 359 {
 360     v8::Local<v8::Value> v8Value;
 361     if (!dictionary.get(key, v8Value))
 362         return false;
 363
 364     if (!v8Value->IsArray())
 365         return false;
 366
 367     v8::Local<v8::Array> v8Array = v8::Local<v8::Array>::Cast(v8Value);
 368     for (size_t i = 0; i < v8Array->Length(); ++i) {
 369         v8::Local<v8::Value> indexedValue = v8Array->Get(v8::Uint32::New(dictionary.isolate(), i));
 370         TOSTRING_DEFAULT(V8StringResource<>, stringValue, indexedValue, false);
 371         value.append(stringValue);
 372     }
 373
 374     return true;
 375 }
 376
 377 template <>
 378 bool DictionaryHelper::convert(const Dictionary& dictionary, Dictionary::ConversionContext& context, const String& key, Vector<String>& value)
 379 {
 380     Dictionary::ConversionContextScope scope(context);
 381
 382     v8::Local<v8::Value> v8Value;
 383     if (!dictionary.get(key, v8Value))
 384         return true;
 385
 386     if (context.isNullable() && blink::isUndefinedOrNull(v8Value))
 387         return true;
 388
 389     if (!v8Value->IsArray()) {
 390         context.throwTypeError(ExceptionMessages::notASequenceTypeProperty(key));
 391         return false;
 392     }
 393
 394     return DictionaryHelper::get(dictionary, key, value);
 395 }
 396
 397 template <>
 398 bool DictionaryHelper::get(const Dictionary& dictionary, const String& key, ArrayValue& value)
 399 {
 400     v8::Local<v8::Value> v8Value;
 401     if (!dictionary.get(key, v8Value))
 402         return false;
 403
 404     if (!v8Value->IsArray())
 405         return false;
 406
 407     ASSERT(dictionary.isolate());
 408     ASSERT(dictionary.isolate() == v8::Isolate::GetCurrent());
 409     value = ArrayValue(v8::Local<v8::Array>::Cast(v8Value), dictionary.isolate());
 410     return true;
 411 }
 412
 413 template <>
 414 bool DictionaryHelper::convert(const Dictionary& dictionary, Dictionary::ConversionContext& context, const String& key, ArrayValue& value)
 415 {
 416     Dictionary::ConversionContextScope scope(context);
 417
 418     v8::Local<v8::Value> v8Value;
 419     if (!dictionary.get(key, v8Value))
 420         return true;
 421
 422     if (context.isNullable() && blink::isUndefinedOrNull(v8Value))
 423         return true;
 424
 425     if (!v8Value->IsArray()) {
 426         context.throwTypeError(ExceptionMessages::notASequenceTypeProperty(key));
 427         return false;
 428     }
 429
 430     return DictionaryHelper::get(dictionary, key, value);
 431 }
 432
 433 template <>
 434 struct DictionaryHelperTraits<Uint8Array> {
 435     typedef V8Uint8Array type;
 436 };
 437
 438 template <>
 439 struct DictionaryHelperTraits<ArrayBufferView> {
 440     typedef V8ArrayBufferView type;
 441 };
 442
 443 template <>
 444 struct DictionaryHelperTraits<MediaKeyError> {
 445     typedef V8MediaKeyError type;
 446 };
 447
 448 template <>
 449 struct DictionaryHelperTraits<DOMError> {
 450     typedef V8DOMError type;
 451 };
 452
 453 template <>
 454 struct DictionaryHelperTraits<Storage> {
 455     typedef V8Storage type;
 456 };
 457
 458 template <>
 459 struct DictionaryHelperTraits<Element> {
 460     typedef V8Element type;
 461 };
 462
 463 template <>
 464 struct DictionaryHelperTraits<Path2D> {
 465     typedef V8Path2D type;
 466 };
 467
 468 template bool DictionaryHelper::get(const Dictionary&, const String& key, RefPtr<Uint8Array>& value);
 469 template bool DictionaryHelper::get(const Dictionary&, const String& key, RefPtr<ArrayBufferView>& value);
 470 template bool DictionaryHelper::get(const Dictionary&, const String& key, RefPtrWillBeMember<MediaKeyError>& value);
 471 template bool DictionaryHelper::get(const Dictionary&, const String& key, RefPtrWillBeMember<DOMError>& value);
 472 template bool DictionaryHelper::get(const Dictionary&, const String& key, RefPtrWillBeMember<Storage>& value);
 473 template bool DictionaryHelper::get(const Dictionary&, const String& key, RefPtrWillBeMember<Element>& value);
 474 template bool DictionaryHelper::get(const Dictionary&, const String& key, RawPtr<Element>& value);
 475 template bool DictionaryHelper::get(const Dictionary&, const String& key, RefPtrWillBeMember<Path2D>& value);
 476 template bool DictionaryHelper::get(const Dictionary&, const String& key, RawPtr<Path2D>& value);
 477
 478 template <typename T>
 479 struct IntegralTypeTraits {
 480 };
 481
 482 template <>
 483 struct IntegralTypeTraits<uint8_t> {
 484     static inline uint8_t toIntegral(v8::Handle<v8::Value> value, IntegerConversionConfiguration configuration, ExceptionState& exceptionState)
 485     {
 486         return toUInt8(value, configuration, exceptionState);
 487     }
 488     static const String typeName() { return "UInt8"; }
 489 };
 490
 491 template <>
 492 struct IntegralTypeTraits<int8_t> {
 493     static inline int8_t toIntegral(v8::Handle<v8::Value> value, IntegerConversionConfiguration configuration, ExceptionState& exceptionState)
 494     {
 495         return toInt8(value, configuration, exceptionState);
 496     }
 497     static const String typeName() { return "Int8"; }
 498 };
 499
 500 template <>
 501 struct IntegralTypeTraits<unsigned short> {
 502     static inline uint16_t toIntegral(v8::Handle<v8::Value> value, IntegerConversionConfiguration configuration, ExceptionState& exceptionState)
 503     {
 504         return toUInt16(value, configuration, exceptionState);
 505     }
 506     static const String typeName() { return "UInt16"; }
 507 };
 508
 509 template <>
 510 struct IntegralTypeTraits<short> {
 511     static inline int16_t toIntegral(v8::Handle<v8::Value> value, IntegerConversionConfiguration configuration, ExceptionState& exceptionState)
 512     {
 513         return toInt16(value, configuration, exceptionState);
 514     }
 515     static const String typeName() { return "Int16"; }
 516 };
 517
 518 template <>
 519 struct IntegralTypeTraits<unsigned> {
 520     static inline uint32_t toIntegral(v8::Handle<v8::Value> value, IntegerConversionConfiguration configuration, ExceptionState& exceptionState)
 521     {
 522         return toUInt32(value, configuration, exceptionState);
 523     }
 524     static const String typeName() { return "UInt32"; }
 525 };
 526
 527 template <>
 528 struct IntegralTypeTraits<unsigned long> {
 529     static inline uint32_t toIntegral(v8::Handle<v8::Value> value, IntegerConversionConfiguration configuration, ExceptionState& exceptionState)
 530     {
 531         return toUInt32(value, configuration, exceptionState);
 532     }
 533     static const String typeName() { return "UInt32"; }
 534 };
 535
 536 template <>
 537 struct IntegralTypeTraits<int> {
 538     static inline int32_t toIntegral(v8::Handle<v8::Value> value, IntegerConversionConfiguration configuration, ExceptionState& exceptionState)
 539     {
 540         return toInt32(value, configuration, exceptionState);
 541     }
 542     static const String typeName() { return "Int32"; }
 543 };
 544
 545 template <>
 546 struct IntegralTypeTraits<long> {
 547     static inline int32_t toIntegral(v8::Handle<v8::Value> value, IntegerConversionConfiguration configuration, ExceptionState& exceptionState)
 548     {
 549         return toInt32(value, configuration, exceptionState);
 550     }
 551     static const String typeName() { return "Int32"; }
 552 };
 553
 554 template <>
 555 struct IntegralTypeTraits<unsigned long long> {
 556     static inline unsigned long long toIntegral(v8::Handle<v8::Value> value, IntegerConversionConfiguration configuration, ExceptionState& exceptionState)
 557     {
 558         return toUInt64(value, configuration, exceptionState);
 559     }
 560     static const String typeName() { return "UInt64"; }
 561 };
 562
 563 template <>
 564 struct IntegralTypeTraits<long long> {
 565     static inline long long toIntegral(v8::Handle<v8::Value> value, IntegerConversionConfiguration configuration, ExceptionState& exceptionState)
 566     {
 567         return toInt64(value, configuration, exceptionState);
 568     }
 569     static const String typeName() { return "Int64"; }
 570 };
 571
 572 template<typename T>
 573 bool DictionaryHelper::convert(const Dictionary& dictionary, Dictionary::ConversionContext& context, const String& key, T& value)
 574 {
 575     Dictionary::ConversionContextScope scope(context);
 576
 577     v8::Local<v8::Value> v8Value;
 578     if (!dictionary.get(key, v8Value))
 579         return true;
 580
 581     value = IntegralTypeTraits<T>::toIntegral(v8Value, NormalConversion, context.exceptionState());
 582     if (context.exceptionState().throwIfNeeded())
 583         return false;
 584
 585     return true;
 586 }
 587
 588 template bool DictionaryHelper::convert(const Dictionary&, Dictionary::ConversionContext&, const String& key, uint8_t& value);
 589 template bool DictionaryHelper::convert(const Dictionary&, Dictionary::ConversionContext&, const String& key, int8_t& value);
 590 template bool DictionaryHelper::convert(const Dictionary&, Dictionary::ConversionContext&, const String& key, unsigned short& value);
 591 template bool DictionaryHelper::convert(const Dictionary&, Dictionary::ConversionContext&, const String& key, short& value);
 592 template bool DictionaryHelper::convert(const Dictionary&, Dictionary::ConversionContext&, const String& key, unsigned& value);
 593 template bool DictionaryHelper::convert(const Dictionary&, Dictionary::ConversionContext&, const String& key, unsigned long& value);
 594 template bool DictionaryHelper::convert(const Dictionary&, Dictionary::ConversionContext&, const String& key, int& value);
 595 template bool DictionaryHelper::convert(const Dictionary&, Dictionary::ConversionContext&, const String& key, long& value);
 596 template bool DictionaryHelper::convert(const Dictionary&, Dictionary::ConversionContext&, const String& key, long long& value);
 597 template bool DictionaryHelper::convert(const Dictionary&, Dictionary::ConversionContext&, const String& key, unsigned long long& value);
 598
 599 template<typename T>
 600 bool DictionaryHelper::convert(const Dictionary& dictionary, Dictionary::ConversionContext& context, const String& key, Nullable<T>& value)
 601 {
 602     Dictionary::ConversionContextScope scope(context);
 603
 604     v8::Local<v8::Value> v8Value;
 605     if (!dictionary.get(key, v8Value))
 606         return true;
 607
 608     if (context.isNullable() && blink::isUndefinedOrNull(v8Value)) {
 609         value = Nullable<T>();
 610         return true;
 611     }
 612
 613     T converted = IntegralTypeTraits<T>::toIntegral(v8Value, NormalConversion, context.exceptionState());
 614
 615     if (context.exceptionState().throwIfNeeded())
 616         return false;
 617
 618     value = Nullable<T>(converted);
 619     return true;
 620 }
 621
 622 template bool DictionaryHelper::convert(const Dictionary&, Dictionary::ConversionContext&, const String& key, Nullable<uint8_t>& value);
 623 template bool DictionaryHelper::convert(const Dictionary&, Dictionary::ConversionContext&, const String& key, Nullable<int8_t>& value);
 624 template bool DictionaryHelper::convert(const Dictionary&, Dictionary::ConversionContext&, const String& key, Nullable<unsigned short>& value);
 625 template bool DictionaryHelper::convert(const Dictionary&, Dictionary::ConversionContext&, const String& key, Nullable<short>& value);
 626 template bool DictionaryHelper::convert(const Dictionary&, Dictionary::ConversionContext&, const String& key, Nullable<unsigned>& value);
 627 template bool DictionaryHelper::convert(const Dictionary&, Dictionary::ConversionContext&, const String& key, Nullable<unsigned long>& value);
 628 template bool DictionaryHelper::convert(const Dictionary&, Dictionary::ConversionContext&, const String& key, Nullable<int>& value);
 629 template bool DictionaryHelper::convert(const Dictionary&, Dictionary::ConversionContext&, const String& key, Nullable<long>& value);
 630 template bool DictionaryHelper::convert(const Dictionary&, Dictionary::ConversionContext&, const String& key, Nullable<long long>& value);
 631 template bool DictionaryHelper::convert(const Dictionary&, Dictionary::ConversionContext&, const String& key, Nullable<unsigned long long>& value);
 632
 633 template bool DictionaryHelper::convert(const Dictionary&, Dictionary::ConversionContext&, const String& key, RefPtrWillBeMember<LocalDOMWindow>& value);
 634 template bool DictionaryHelper::convert(const Dictionary&, Dictionary::ConversionContext&, const String& key, RefPtrWillBeMember<Storage>& value);
 635 template bool DictionaryHelper::convert(const Dictionary&, Dictionary::ConversionContext&, const String& key, RefPtr<Uint8Array>& value);
 636 template bool DictionaryHelper::convert(const Dictionary&, Dictionary::ConversionContext&, const String& key, RefPtr<ArrayBufferView>& value);
 637 template bool DictionaryHelper::convert(const Dictionary&, Dictionary::ConversionContext&, const String& key, RefPtrWillBeMember<MediaKeyError>& value);
 638 template bool DictionaryHelper::convert(const Dictionary&, Dictionary::ConversionContext&, const String& key, RefPtrWillBeMember<TrackBase>& value);
 639 template bool DictionaryHelper::convert(const Dictionary&, Dictionary::ConversionContext&, const String& key, RefPtrWillBeMember<EventTarget>& value);
 640
 641 template <>
 642 bool DictionaryHelper::convert(const Dictionary& dictionary, Dictionary::ConversionContext& context, const String& key, MessagePortArray& value)
 643 {
 644     Dictionary::ConversionContextScope scope(context);
 645
 646     v8::Local<v8::Value> v8Value;
 647     if (!dictionary.get(key, v8Value))
 648         return true;
 649
 650     ASSERT(dictionary.isolate());
 651     ASSERT(dictionary.isolate() == v8::Isolate::GetCurrent());
 652
 653     if (isUndefinedOrNull(v8Value))
 654         return true;
 655
 656     value = toRefPtrWillBeMemberNativeArray<MessagePort, V8MessagePort>(v8Value, key, dictionary.isolate(), context.exceptionState());
 657
 658     if (context.exceptionState().throwIfNeeded())
 659         return false;
 660
 661     return true;
 662 }
 663
 664 } // namespace blink