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/V8ArrayBufferView.h"
  33 #include "bindings/core/v8/V8Binding.h"
  34 #include "bindings/core/v8/V8DOMError.h"
  35 #include "bindings/core/v8/V8Element.h"
  36 #include "bindings/core/v8/V8EventTarget.h"
  37 #include "bindings/core/v8/V8MediaKeyError.h"
  38 #include "bindings/core/v8/V8MessagePort.h"
  39 #include "bindings/core/v8/V8Path2D.h"
  40 #include "bindings/core/v8/V8Storage.h"
  41 #include "bindings/core/v8/V8TextTrack.h"
  42 #include "bindings/core/v8/V8Uint8Array.h"
  43 #include "bindings/core/v8/V8VoidCallback.h"
  44 #include "bindings/core/v8/V8Window.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::get(const Dictionary& dictionary, const String& key, Vector<Vector<String> >& value, ExceptionState& exceptionState)
 379 {
 380     v8::Local<v8::Value> v8Value;
 381     if (!dictionary.get(key, v8Value))
 382         return false;
 383
 384     if (!v8Value->IsArray())
 385         return false;
 386
 387     v8::Local<v8::Array> v8Array = v8::Local<v8::Array>::Cast(v8Value);
 388     for (size_t i = 0; i < v8Array->Length(); ++i) {
 389         v8::Local<v8::Value> v8IndexedValue = v8Array->Get(v8::Uint32::New(dictionary.isolate(), i));
 390         Vector<String> indexedValue = toImplArray<String>(v8IndexedValue, i, dictionary.isolate(), exceptionState);
 391         if (exceptionState.hadException())
 392             return false;
 393         value.append(indexedValue);
 394     }
 395
 396     return true;
 397 }
 398
 399 template <>
 400 bool DictionaryHelper::convert(const Dictionary& dictionary, Dictionary::ConversionContext& context, const String& key, Vector<String>& value)
 401 {
 402     Dictionary::ConversionContextScope scope(context);
 403
 404     v8::Local<v8::Value> v8Value;
 405     if (!dictionary.get(key, v8Value))
 406         return true;
 407
 408     if (context.isNullable() && blink::isUndefinedOrNull(v8Value))
 409         return true;
 410
 411     if (!v8Value->IsArray()) {
 412         context.throwTypeError(ExceptionMessages::notASequenceTypeProperty(key));
 413         return false;
 414     }
 415
 416     return DictionaryHelper::get(dictionary, key, value);
 417 }
 418
 419 template <>
 420 bool DictionaryHelper::get(const Dictionary& dictionary, const String& key, ArrayValue& value)
 421 {
 422     v8::Local<v8::Value> v8Value;
 423     if (!dictionary.get(key, v8Value))
 424         return false;
 425
 426     if (!v8Value->IsArray())
 427         return false;
 428
 429     ASSERT(dictionary.isolate());
 430     ASSERT(dictionary.isolate() == v8::Isolate::GetCurrent());
 431     value = ArrayValue(v8::Local<v8::Array>::Cast(v8Value), dictionary.isolate());
 432     return true;
 433 }
 434
 435 template <>
 436 bool DictionaryHelper::convert(const Dictionary& dictionary, Dictionary::ConversionContext& context, const String& key, ArrayValue& value)
 437 {
 438     Dictionary::ConversionContextScope scope(context);
 439
 440     v8::Local<v8::Value> v8Value;
 441     if (!dictionary.get(key, v8Value))
 442         return true;
 443
 444     if (context.isNullable() && blink::isUndefinedOrNull(v8Value))
 445         return true;
 446
 447     if (!v8Value->IsArray()) {
 448         context.throwTypeError(ExceptionMessages::notASequenceTypeProperty(key));
 449         return false;
 450     }
 451
 452     return DictionaryHelper::get(dictionary, key, value);
 453 }
 454
 455 template <>
 456 struct DictionaryHelperTraits<DOMUint8Array> {
 457     typedef V8Uint8Array type;
 458 };
 459
 460 template <>
 461 struct DictionaryHelperTraits<DOMArrayBufferView> {
 462     typedef V8ArrayBufferView type;
 463 };
 464
 465 template <>
 466 struct DictionaryHelperTraits<MediaKeyError> {
 467     typedef V8MediaKeyError type;
 468 };
 469
 470 template <>
 471 struct DictionaryHelperTraits<DOMError> {
 472     typedef V8DOMError type;
 473 };
 474
 475 template <>
 476 struct DictionaryHelperTraits<Storage> {
 477     typedef V8Storage type;
 478 };
 479
 480 template <>
 481 struct DictionaryHelperTraits<Element> {
 482     typedef V8Element type;
 483 };
 484
 485 template <>
 486 struct DictionaryHelperTraits<Path2D> {
 487     typedef V8Path2D type;
 488 };
 489
 490 template bool DictionaryHelper::get(const Dictionary&, const String& key, RefPtr<DOMUint8Array>& value);
 491 template bool DictionaryHelper::get(const Dictionary&, const String& key, RefPtr<DOMArrayBufferView>& value);
 492 template bool DictionaryHelper::get(const Dictionary&, const String& key, RefPtrWillBeMember<MediaKeyError>& value);
 493 template bool DictionaryHelper::get(const Dictionary&, const String& key, Member<DOMError>& value);
 494 template bool DictionaryHelper::get(const Dictionary&, const String& key, RefPtrWillBeMember<Storage>& value);
 495 template bool DictionaryHelper::get(const Dictionary&, const String& key, RefPtrWillBeMember<Element>& value);
 496 template bool DictionaryHelper::get(const Dictionary&, const String& key, RawPtr<Element>& value);
 497 template bool DictionaryHelper::get(const Dictionary&, const String& key, RefPtrWillBeMember<Path2D>& value);
 498 template bool DictionaryHelper::get(const Dictionary&, const String& key, RawPtr<Path2D>& value);
 499
 500 template <typename T>
 501 struct IntegralTypeTraits {
 502 };
 503
 504 template <>
 505 struct IntegralTypeTraits<uint8_t> {
 506     static inline uint8_t toIntegral(v8::Handle<v8::Value> value, IntegerConversionConfiguration configuration, ExceptionState& exceptionState)
 507     {
 508         return toUInt8(value, configuration, exceptionState);
 509     }
 510     static const String typeName() { return "UInt8"; }
 511 };
 512
 513 template <>
 514 struct IntegralTypeTraits<int8_t> {
 515     static inline int8_t toIntegral(v8::Handle<v8::Value> value, IntegerConversionConfiguration configuration, ExceptionState& exceptionState)
 516     {
 517         return toInt8(value, configuration, exceptionState);
 518     }
 519     static const String typeName() { return "Int8"; }
 520 };
 521
 522 template <>
 523 struct IntegralTypeTraits<unsigned short> {
 524     static inline uint16_t toIntegral(v8::Handle<v8::Value> value, IntegerConversionConfiguration configuration, ExceptionState& exceptionState)
 525     {
 526         return toUInt16(value, configuration, exceptionState);
 527     }
 528     static const String typeName() { return "UInt16"; }
 529 };
 530
 531 template <>
 532 struct IntegralTypeTraits<short> {
 533     static inline int16_t toIntegral(v8::Handle<v8::Value> value, IntegerConversionConfiguration configuration, ExceptionState& exceptionState)
 534     {
 535         return toInt16(value, configuration, exceptionState);
 536     }
 537     static const String typeName() { return "Int16"; }
 538 };
 539
 540 template <>
 541 struct IntegralTypeTraits<unsigned> {
 542     static inline uint32_t toIntegral(v8::Handle<v8::Value> value, IntegerConversionConfiguration configuration, ExceptionState& exceptionState)
 543     {
 544         return toUInt32(value, configuration, exceptionState);
 545     }
 546     static const String typeName() { return "UInt32"; }
 547 };
 548
 549 template <>
 550 struct IntegralTypeTraits<unsigned long> {
 551     static inline uint32_t toIntegral(v8::Handle<v8::Value> value, IntegerConversionConfiguration configuration, ExceptionState& exceptionState)
 552     {
 553         return toUInt32(value, configuration, exceptionState);
 554     }
 555     static const String typeName() { return "UInt32"; }
 556 };
 557
 558 template <>
 559 struct IntegralTypeTraits<int> {
 560     static inline int32_t toIntegral(v8::Handle<v8::Value> value, IntegerConversionConfiguration configuration, ExceptionState& exceptionState)
 561     {
 562         return toInt32(value, configuration, exceptionState);
 563     }
 564     static const String typeName() { return "Int32"; }
 565 };
 566
 567 template <>
 568 struct IntegralTypeTraits<long> {
 569     static inline int32_t toIntegral(v8::Handle<v8::Value> value, IntegerConversionConfiguration configuration, ExceptionState& exceptionState)
 570     {
 571         return toInt32(value, configuration, exceptionState);
 572     }
 573     static const String typeName() { return "Int32"; }
 574 };
 575
 576 template <>
 577 struct IntegralTypeTraits<unsigned long long> {
 578     static inline unsigned long long toIntegral(v8::Handle<v8::Value> value, IntegerConversionConfiguration configuration, ExceptionState& exceptionState)
 579     {
 580         return toUInt64(value, configuration, exceptionState);
 581     }
 582     static const String typeName() { return "UInt64"; }
 583 };
 584
 585 template <>
 586 struct IntegralTypeTraits<long long> {
 587     static inline long long toIntegral(v8::Handle<v8::Value> value, IntegerConversionConfiguration configuration, ExceptionState& exceptionState)
 588     {
 589         return toInt64(value, configuration, exceptionState);
 590     }
 591     static const String typeName() { return "Int64"; }
 592 };
 593
 594 template<typename T>
 595 bool DictionaryHelper::convert(const Dictionary& dictionary, Dictionary::ConversionContext& context, const String& key, T& value)
 596 {
 597     Dictionary::ConversionContextScope scope(context);
 598
 599     v8::Local<v8::Value> v8Value;
 600     if (!dictionary.get(key, v8Value))
 601         return true;
 602
 603     value = IntegralTypeTraits<T>::toIntegral(v8Value, NormalConversion, context.exceptionState());
 604     if (context.exceptionState().throwIfNeeded())
 605         return false;
 606
 607     return true;
 608 }
 609
 610 template bool DictionaryHelper::convert(const Dictionary&, Dictionary::ConversionContext&, const String& key, uint8_t& value);
 611 template bool DictionaryHelper::convert(const Dictionary&, Dictionary::ConversionContext&, const String& key, int8_t& value);
 612 template bool DictionaryHelper::convert(const Dictionary&, Dictionary::ConversionContext&, const String& key, unsigned short& value);
 613 template bool DictionaryHelper::convert(const Dictionary&, Dictionary::ConversionContext&, const String& key, short& value);
 614 template bool DictionaryHelper::convert(const Dictionary&, Dictionary::ConversionContext&, const String& key, unsigned& value);
 615 template bool DictionaryHelper::convert(const Dictionary&, Dictionary::ConversionContext&, const String& key, unsigned long& value);
 616 template bool DictionaryHelper::convert(const Dictionary&, Dictionary::ConversionContext&, const String& key, int& value);
 617 template bool DictionaryHelper::convert(const Dictionary&, Dictionary::ConversionContext&, const String& key, long& value);
 618 template bool DictionaryHelper::convert(const Dictionary&, Dictionary::ConversionContext&, const String& key, long long& value);
 619 template bool DictionaryHelper::convert(const Dictionary&, Dictionary::ConversionContext&, const String& key, unsigned long long& value);
 620
 621 template<typename T>
 622 bool DictionaryHelper::convert(const Dictionary& dictionary, Dictionary::ConversionContext& context, const String& key, Nullable<T>& value)
 623 {
 624     Dictionary::ConversionContextScope scope(context);
 625
 626     v8::Local<v8::Value> v8Value;
 627     if (!dictionary.get(key, v8Value))
 628         return true;
 629
 630     if (context.isNullable() && blink::isUndefinedOrNull(v8Value)) {
 631         value = Nullable<T>();
 632         return true;
 633     }
 634
 635     T converted = IntegralTypeTraits<T>::toIntegral(v8Value, NormalConversion, context.exceptionState());
 636
 637     if (context.exceptionState().throwIfNeeded())
 638         return false;
 639
 640     value = Nullable<T>(converted);
 641     return true;
 642 }
 643
 644 template bool DictionaryHelper::convert(const Dictionary&, Dictionary::ConversionContext&, const String& key, Nullable<uint8_t>& value);
 645 template bool DictionaryHelper::convert(const Dictionary&, Dictionary::ConversionContext&, const String& key, Nullable<int8_t>& value);
 646 template bool DictionaryHelper::convert(const Dictionary&, Dictionary::ConversionContext&, const String& key, Nullable<unsigned short>& value);
 647 template bool DictionaryHelper::convert(const Dictionary&, Dictionary::ConversionContext&, const String& key, Nullable<short>& value);
 648 template bool DictionaryHelper::convert(const Dictionary&, Dictionary::ConversionContext&, const String& key, Nullable<unsigned>& value);
 649 template bool DictionaryHelper::convert(const Dictionary&, Dictionary::ConversionContext&, const String& key, Nullable<unsigned long>& value);
 650 template bool DictionaryHelper::convert(const Dictionary&, Dictionary::ConversionContext&, const String& key, Nullable<int>& value);
 651 template bool DictionaryHelper::convert(const Dictionary&, Dictionary::ConversionContext&, const String& key, Nullable<long>& value);
 652 template bool DictionaryHelper::convert(const Dictionary&, Dictionary::ConversionContext&, const String& key, Nullable<long long>& value);
 653 template bool DictionaryHelper::convert(const Dictionary&, Dictionary::ConversionContext&, const String& key, Nullable<unsigned long long>& value);
 654
 655 template bool DictionaryHelper::convert(const Dictionary&, Dictionary::ConversionContext&, const String& key, RefPtrWillBeMember<LocalDOMWindow>& value);
 656 template bool DictionaryHelper::convert(const Dictionary&, Dictionary::ConversionContext&, const String& key, RefPtrWillBeMember<Storage>& value);
 657 template bool DictionaryHelper::convert(const Dictionary&, Dictionary::ConversionContext&, const String& key, RefPtr<DOMUint8Array>& value);
 658 template bool DictionaryHelper::convert(const Dictionary&, Dictionary::ConversionContext&, const String& key, RefPtr<DOMArrayBufferView>& value);
 659 template bool DictionaryHelper::convert(const Dictionary&, Dictionary::ConversionContext&, const String& key, RefPtrWillBeMember<MediaKeyError>& value);
 660 template bool DictionaryHelper::convert(const Dictionary&, Dictionary::ConversionContext&, const String& key, RefPtrWillBeMember<TrackBase>& value);
 661 template bool DictionaryHelper::convert(const Dictionary&, Dictionary::ConversionContext&, const String& key, RefPtrWillBeMember<EventTarget>& value);
 662
 663 template <>
 664 bool DictionaryHelper::convert(const Dictionary& dictionary, Dictionary::ConversionContext& context, const String& key, MessagePortArray& value)
 665 {
 666     Dictionary::ConversionContextScope scope(context);
 667
 668     v8::Local<v8::Value> v8Value;
 669     if (!dictionary.get(key, v8Value))
 670         return true;
 671
 672     ASSERT(dictionary.isolate());
 673     ASSERT(dictionary.isolate() == v8::Isolate::GetCurrent());
 674
 675     if (isUndefinedOrNull(v8Value))
 676         return true;
 677
 678     value = toRefPtrWillBeMemberNativeArray<MessagePort, V8MessagePort>(v8Value, key, dictionary.isolate(), context.exceptionState());
 679
 680     if (context.exceptionState().throwIfNeeded())
 681         return false;
 682
 683     return true;
 684 }
 685
 686 } // namespace blink