[WebCrypto] Use ScriptPromiseResolverWithContext.

Source/bindings/v8/ScriptPromiseResolverWithContext.h

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef ScriptPromiseResolverWithContext_h
 #define ScriptPromiseResolverWithContext_h
 
 #include "bindings/v8/NewScriptState.h"
 #include "bindings/v8/ScopedPersistent.h"
 #include "bindings/v8/ScriptPromise.h"
@@ skipping 12 matching lines @@
 // functionalities in addition to ScriptPromiseResolver's.
 //  - A ScriptPromiseResolverWithContext retains a ScriptState. A caller
 //    can call resolve or reject from outside of a V8 context.
 //  - This class is an ActiveDOMObject and keeps track of the associated
 //    ExecutionContext state. When the ExecutionContext is suspended,
 //    resolve or reject will be delayed. When it is stopped, resolve or reject
 //    will be ignored.
 class ScriptPromiseResolverWithContext FINAL : public ActiveDOMObject, public RefCounted<ScriptPromiseResolverWithContext> {
     WTF_MAKE_NONCOPYABLE(ScriptPromiseResolverWithContext);
 
+    class NullType {
+    };
+    class UndefinedType {
+    };
 public:
     static PassRefPtr<ScriptPromiseResolverWithContext> create(NewScriptState* scriptState)
     {
         RefPtr<ScriptPromiseResolverWithContext> resolver = adoptRef(new ScriptPromiseResolverWithContext(scriptState));
         resolver->suspendIfNeeded();
         return resolver.release();
     }
 
+    // Anything that can be passed to one of toV8 functions defined in this

[eroman, 2014/04/17 02:25:46]

"one of toV8" --> "one of the toV8"

+    // class can be passed to this function.
     template <typename T>
     void resolve(T value)
     {
         if (m_state != Pending || !executionContext() || executionContext()->activeDOMObjectsAreStopped())
             return;
         m_state = Resolving;
         NewScriptState::Scope scope(m_scriptState.get());
         m_value.set(m_scriptState->isolate(), toV8(value));
         if (!executionContext()->activeDOMObjectsAreSuspended())
             resolveOrRejectImmediately(&m_timer);
     }
 
+    // Anything that can be passed to one of toV8 functions defined in this

[eroman, 2014/04/17 02:25:46]

"one of toV8" --> "one of the toV8"

+    // class can be passed to this function.
     template <typename T>
     void reject(T value)
     {
         if (m_state != Pending || !executionContext() || executionContext()->activeDOMObjectsAreStopped())
             return;
         m_state = Rejecting;
         NewScriptState::Scope scope(m_scriptState.get());
         m_value.set(m_scriptState->isolate(), toV8(value));
         if (!executionContext()->activeDOMObjectsAreSuspended())
             resolveOrRejectImmediately(&m_timer);
     }
 
+    // null and undefined can be passed to resolve and reject functions.
+    static NullType null() { return NullType(); }
+    static UndefinedType undefined() { return UndefinedType(); }
+    struct Boolean {
+        explicit Boolean(bool value) : value(value) { }
+        const bool value;
+    };
+
     // Note that an empty ScriptPromise will be returned after resolve or
     // reject is called.
     ScriptPromise promise()
     {
         return m_resolver ? m_resolver->promise() : ScriptPromise();
     }
 
     // ActiveDOMObject implementation.
     virtual void suspend() OVERRIDE;
     virtual void resume() OVERRIDE;
@@ skipping 21 matching lines @@
     template <typename T, size_t inlineCapacity>
     v8::Handle<v8::Value> toV8(const Vector<T, inlineCapacity>& value)
     {
         ASSERT(m_scriptState);
         return v8ArrayNoInline(value, m_scriptState->isolate());
     }
     v8::Handle<v8::Value> toV8(ScriptValue value)
     {
         return value.v8Value();
     }
+    v8::Handle<v8::Value> toV8(v8::Handle<v8::Value> value) { return value; }
+    v8::Handle<v8::Value> toV8(NullType) { return v8::Null(m_scriptState->isolate()); }
+    v8::Handle<v8::Value> toV8(UndefinedType) { return v8::Undefined(m_scriptState->isolate()); }
+    // We don't define toV8(bool) to avoid implicit conversion.
+    v8::Handle<v8::Value> toV8(Boolean value) { return v8::Boolean::New(m_scriptState->isolate(), value.value); }
+    v8::Handle<v8::Value> toV8(int8_t value) { return v8::Integer::New(m_scriptState->isolate(), value); }
+    v8::Handle<v8::Value> toV8(uint8_t value) { return v8::Integer::New(m_scriptState->isolate(), value); }
+    v8::Handle<v8::Value> toV8(int16_t value) { return v8::Integer::New(m_scriptState->isolate(), value); }
+    v8::Handle<v8::Value> toV8(uint16_t value) { return v8::Integer::New(m_scriptState->isolate(), value); }
+    v8::Handle<v8::Value> toV8(int32_t value) { return v8::Integer::New(m_scriptState->isolate(), value); }
+    v8::Handle<v8::Value> toV8(uint32_t value) { return v8::Number::New(m_scriptState->isolate(), value); }
+    v8::Handle<v8::Value> toV8(int64_t value) { return v8::Number::New(m_scriptState->isolate(), value); }
+    v8::Handle<v8::Value> toV8(uint64_t value) { return v8::Number::New(m_scriptState->isolate(), value); }
+    v8::Handle<v8::Value> toV8(double value) { return v8::Number::New(m_scriptState->isolate(), value); }
+    v8::Handle<v8::Value> toV8(const char* value)
+    {
+        return v8::String::NewFromUtf8(m_scriptState->isolate(), value, v8::String::kInternalizedString, strlen(value));
+    }
+    v8::Handle<v8::Value> toV8(const String& value)
+    {
+        return v8String(m_scriptState->isolate(), value);
+    }
 
     void resolveOrRejectImmediately(Timer<ScriptPromiseResolverWithContext>*);
     void clear();
 
     ResolutionState m_state;
     RefPtr<NewScriptState> m_scriptState;
     Timer<ScriptPromiseResolverWithContext> m_timer;
     RefPtr<ScriptPromiseResolver> m_resolver;
     ScopedPersistent<v8::Value> m_value;
 };
 
 } // namespace WebCore
 
 #endif // #ifndef ScriptPromiseResolverWithContext_h