Upstream version 7.36.149.0

[platform/framework/web/crosswalk.git] / src / third_party / WebKit / Source / modules / serviceworkers / ServiceWorker.cpp

diff --git a/src/third_party/WebKit/Source/modules/serviceworkers/ServiceWorker.cpp b/src/third_party/WebKit/Source/modules/serviceworkers/ServiceWorker.cpp
index 3aa2048..2bca5b3 100644 (file)
--- a/src/third_party/WebKit/Source/modules/serviceworkers/ServiceWorker.cpp
+++ b/src/third_party/WebKit/Source/modules/serviceworkers/ServiceWorker.cpp
@@ -31,16 +31,45 @@
 #include "config.h"
 #include "ServiceWorker.h"
 
+#include "EventTargetNames.h"
 #include "bindings/v8/ExceptionState.h"
+#include "bindings/v8/ScriptPromiseResolverWithContext.h"
+#include "bindings/v8/ScriptState.h"
 #include "core/dom/MessagePort.h"
+#include "core/events/Event.h"
+#include "platform/NotImplemented.h"
 #include "public/platform/WebMessagePortChannel.h"
+#include "public/platform/WebServiceWorkerState.h"
 #include "public/platform/WebString.h"
 
 namespace WebCore {
 
-ServiceWorker::ServiceWorker(PassOwnPtr<blink::WebServiceWorker> worker)
-    : m_outerWorker(worker)
+class ServiceWorker::ThenFunction FINAL : public ScriptFunction {
+public:
+    static PassOwnPtr<ScriptFunction> create(PassRefPtr<ServiceWorker> observer)
+    {
+        ExecutionContext* executionContext = observer->executionContext();
+        return adoptPtr(new ThenFunction(toIsolate(executionContext), observer));
+    }
+private:
+    ThenFunction(v8::Isolate* isolate, PassRefPtr<ServiceWorker> observer)
+        : ScriptFunction(isolate)
+        , m_observer(observer)
+    {
+    }
+
+    virtual ScriptValue call(ScriptValue value) OVERRIDE
+    {
+        m_observer->onPromiseResolved();
+        return value;
+    }
+
+    RefPtr<ServiceWorker> m_observer;
+};
+
+const AtomicString& ServiceWorker::interfaceName() const
 {
+    return EventTargetNames::ServiceWorker;
 }
 
 void ServiceWorker::postMessage(PassRefPtr<SerializedScriptValue> message, const MessagePortArray* ports, ExceptionState& exceptionState)
@@ -55,4 +84,88 @@ void ServiceWorker::postMessage(PassRefPtr<SerializedScriptValue> message, const
     m_outerWorker->postMessage(messageString, webChannels.leakPtr());
 }
 
+bool ServiceWorker::isReady()
+{
+    return !m_isPromisePending;
+}
+
+void ServiceWorker::dispatchStateChangeEvent()
+{
+    ASSERT(isReady());
+    this->dispatchEvent(Event::create(EventTypeNames::statechange));
+}
+
+const AtomicString& ServiceWorker::state() const
+{
+    DEFINE_STATIC_LOCAL(AtomicString, unknown, ("unknown", AtomicString::ConstructFromLiteral));
+    DEFINE_STATIC_LOCAL(AtomicString, parsed, ("parsed", AtomicString::ConstructFromLiteral));
+    DEFINE_STATIC_LOCAL(AtomicString, installing, ("installing", AtomicString::ConstructFromLiteral));
+    DEFINE_STATIC_LOCAL(AtomicString, installed, ("installed", AtomicString::ConstructFromLiteral));
+    DEFINE_STATIC_LOCAL(AtomicString, activating, ("activating", AtomicString::ConstructFromLiteral));
+    DEFINE_STATIC_LOCAL(AtomicString, active, ("active", AtomicString::ConstructFromLiteral));
+    DEFINE_STATIC_LOCAL(AtomicString, deactivated, ("deactivated", AtomicString::ConstructFromLiteral));
+
+    switch (m_outerWorker->state()) {
+    case blink::WebServiceWorkerStateUnknown:
+        // The web platform should never see this internal state
+        ASSERT_NOT_REACHED();
+        return unknown;
+    case blink::WebServiceWorkerStateParsed:
+        return parsed;
+    case blink::WebServiceWorkerStateInstalling:
+        return installing;
+    case blink::WebServiceWorkerStateInstalled:
+        return installed;
+    case blink::WebServiceWorkerStateActivating:
+        return activating;
+    case blink::WebServiceWorkerStateActive:
+        return active;
+    case blink::WebServiceWorkerStateDeactivated:
+        return deactivated;
+    default:
+        ASSERT_NOT_REACHED();
+        return nullAtom;
+    }
+}
+
+PassRefPtr<ServiceWorker> ServiceWorker::from(ScriptPromiseResolverWithContext* resolver, WebType* worker)
+{
+    ScriptState::Scope scope(resolver->scriptState());
+    RefPtr<ServiceWorker> serviceWorker = create(resolver->scriptState()->executionContext(), adoptPtr(worker));
+    serviceWorker->waitOnPromise(resolver->promise());
+    return serviceWorker;
+}
+
+void ServiceWorker::onPromiseResolved()
+{
+    ASSERT(m_isPromisePending);
+    m_isPromisePending = false;
+    m_outerWorker->proxyReadyChanged();
+}
+
+void ServiceWorker::waitOnPromise(ScriptPromise promise)
+{
+    ASSERT(!m_isPromisePending);
+    m_isPromisePending = true;
+    m_outerWorker->proxyReadyChanged();
+    promise.then(ThenFunction::create(this));
+}
+
+PassRefPtr<ServiceWorker> ServiceWorker::create(ExecutionContext* executionContext, PassOwnPtr<blink::WebServiceWorker> outerWorker)
+{
+    RefPtr<ServiceWorker> worker = adoptRef(new ServiceWorker(executionContext, outerWorker));
+    worker->suspendIfNeeded();
+    return worker.release();
+}
+
+ServiceWorker::ServiceWorker(ExecutionContext* executionContext, PassOwnPtr<blink::WebServiceWorker> worker)
+    : AbstractWorker(executionContext)
+    , m_outerWorker(worker)
+    , m_isPromisePending(false)
+{
+    ScriptWrappable::init(this);
+    ASSERT(m_outerWorker);
+    m_outerWorker->setProxy(this);
+}
+
 } // namespace WebCore