[ServiceWorker, PushMessaging] Use ScriptPromiseResolverWithContext.

Source/bindings/v8/CallbackPromiseAdapter.h

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 13 matching lines @@
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef CallbackPromiseAdapter_h
 #define CallbackPromiseAdapter_h
 
-#include "bindings/v8/NewScriptState.h"
-#include "bindings/v8/ScriptPromiseResolver.h"
+#include "bindings/v8/ScriptPromiseResolverWithContext.h"
 #include "public/platform/WebCallbacks.h"
 
 namespace WebCore {
 
 // This class provides an easy way to convert from a Script-exposed
 // class (i.e. a class that has a toV8() overload) that uses Promises
 // to a WebKit API class that uses WebCallbacks. You can define
 // seperate Success and Error classes, but this example just uses one
 // object for both.
 //
@@ skipping 11 matching lines @@
 //
 //    // call signature: callSomeMethod(WebCallbacks<MyClass, MyClass>* callbacks)
 //    webObject->callSomeMethod(new CallbackPromiseAdapter<MyClass, MyClass>(resolver, scriptExecutionContext));
 //
 // Note that this class does not manage its own lifetime. In this
 // example that ownership of the WebCallbacks instance is being passed
 // in and it is up to the callee to free the WebCallbacks instace.
 template<typename S, typename T>
 class CallbackPromiseAdapter FINAL : public blink::WebCallbacks<typename S::WebType, typename T::WebType> {
 public:
-    CallbackPromiseAdapter(PassRefPtr<ScriptPromiseResolver> resolver, ExecutionContext* context)
+    CallbackPromiseAdapter(PassRefPtr<ScriptPromiseResolverWithContext> resolver)
         : m_resolver(resolver)
-        , m_scriptState(NewScriptState::current(toIsolate(context)))
     {
     }
     virtual ~CallbackPromiseAdapter() { }
 
     virtual void onSuccess(typename S::WebType* result) OVERRIDE
     {
-        NewScriptState::Scope scope(m_scriptState.get());
-        m_resolver->resolve(S::from(m_scriptState.get(), result));
+        if (!m_resolver->scriptState())
+            return;

[haraken, 2014/04/14 12:13:17]

This will change existing behavior in a case where onSuccess() is called after
an ExecutionContext is stopped. In the old code, resolve() was called. In the
new code, nothing is called. Is this change OK?

In addition, even if you want to return immediately when the ExecutionContext is
gone, you should check it by the existence of
ScriptPromiseResolverWithContext::m_resolver (instead of the existence of
ScriptPromiseResolverWithContext::m_scriptState). As I commented in
ScriptPromiseResolverWithContext.h, m_scriptState shouldn't be cleared out until
the holder object dies.

[yhirano, 2014/04/14 12:37:23]

Yes, this CL changes the behavior as written in the description, though the
blink Promises can't work with a stopped execution context (see [A]).
In addition to that, current ScriptPromiseResolverWithContext ignores resolve or
reject callls when the execution context is stopped.

What should a resolver do when resolve or reject called on a stopped execution
context?
I think of three options:
1. Do nothing (the current behavior)
2. Work normally
3. The resolver rejects the associated promise with a certain exception when the
executionContext is stopped.

A:
https://code.google.com/p/chromium/codesearch#chromium/src/third_party/WebKit...

[yhirano, 2014/04/15 01:02:17]

I made ScriptPromiseResolver::m_scriptState const so that we can use after the
resolver is cleared.

+        m_resolver->resolve(S::from(m_resolver->scriptState(), result));
     }
     virtual void onError(typename T::WebType* error) OVERRIDE
     {
-        NewScriptState::Scope scope(m_scriptState.get());
-        m_resolver->reject(T::from(m_scriptState.get(), error));
+        if (!m_resolver->scriptState())
+            return;

[haraken, 2014/04/14 12:13:17]

Ditto.

+        m_resolver->reject(T::from(m_resolver->scriptState(), error));
     }
 private:
-    RefPtr<ScriptPromiseResolver> m_resolver;
-    RefPtr<NewScriptState> m_scriptState;
+    RefPtr<ScriptPromiseResolverWithContext> m_resolver;
     WTF_MAKE_NONCOPYABLE(CallbackPromiseAdapter);
 };
 
 } // namespace WebCore
 
 #endif