Home | History | Annotate | Download | only in serviceworkers 
      1 /*
      2  * Copyright (C) 2013 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 are
      6  * met:
      7  *
      8  *     * Redistributions of source code must retain the above copyright
      9  * notice, this list of conditions and the following disclaimer.
     10  *     * Redistributions in binary form must reproduce the above
     11  * copyright notice, this list of conditions and the following disclaimer
     12  * in the documentation and/or other materials provided with the
     13  * distribution.
     14  *     * Neither the name of Google Inc. nor the names of its
     15  * contributors may be used to endorse or promote products derived from
     16  * this software without specific prior written permission.
     17  *
     18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
     19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
     20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
     21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
     22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
     23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
     24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
     28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     29  */
     30 
     31 #include "config.h"
     32 #include "ServiceWorker.h"
     33 
     34 #include "bindings/core/v8/ExceptionState.h"
     35 #include "bindings/core/v8/ScriptPromiseResolver.h"
     36 #include "bindings/core/v8/ScriptState.h"
     37 #include "core/dom/MessagePort.h"
     38 #include "core/events/Event.h"
     39 #include "modules/EventTargetModules.h"
     40 #include "platform/NotImplemented.h"
     41 #include "public/platform/WebMessagePortChannel.h"
     42 #include "public/platform/WebServiceWorkerState.h"
     43 #include "public/platform/WebString.h"
     44 #include <v8.h>
     45 
     46 namespace blink {
     47 
     48 class ServiceWorker::ThenFunction FINAL : public ScriptFunction {
     49 public:
     50     static v8::Handle<v8::Function> createFunction(ScriptState* scriptState, PassRefPtrWillBeRawPtr<ServiceWorker> observer)
     51     {
     52         ThenFunction* self = new ThenFunction(scriptState, observer);
     53         return self->bindToV8Function();
     54     }
     55 
     56     virtual void trace(Visitor* visitor) OVERRIDE
     57     {
     58         visitor->trace(m_observer);
     59         ScriptFunction::trace(visitor);
     60     }
     61 
     62 private:
     63     ThenFunction(ScriptState* scriptState, PassRefPtrWillBeRawPtr<ServiceWorker> observer)
     64         : ScriptFunction(scriptState)
     65         , m_observer(observer)
     66     {
     67     }
     68 
     69     virtual ScriptValue call(ScriptValue value) OVERRIDE
     70     {
     71         m_observer->onPromiseResolved();
     72         return value;
     73     }
     74 
     75     RefPtrWillBeMember<ServiceWorker> m_observer;
     76 };
     77 
     78 const AtomicString& ServiceWorker::interfaceName() const
     79 {
     80     return EventTargetNames::ServiceWorker;
     81 }
     82 
     83 void ServiceWorker::postMessage(ExecutionContext*, PassRefPtr<SerializedScriptValue> message, const MessagePortArray* ports, ExceptionState& exceptionState)
     84 {
     85     // Disentangle the port in preparation for sending it to the remote context.
     86     OwnPtr<MessagePortChannelArray> channels = MessagePort::disentanglePorts(ports, exceptionState);
     87     if (exceptionState.hadException())
     88         return;
     89     if (m_outerWorker->state() == WebServiceWorkerStateRedundant) {
     90         exceptionState.throwDOMException(InvalidStateError, "ServiceWorker is in redundant state.");
     91         return;
     92     }
     93 
     94     WebString messageString = message->toWireString();
     95     OwnPtr<WebMessagePortChannelArray> webChannels = MessagePort::toWebMessagePortChannelArray(channels.release());
     96     m_outerWorker->postMessage(messageString, webChannels.leakPtr());
     97 }
     98 
     99 void ServiceWorker::terminate(ExceptionState& exceptionState)
    100 {
    101     exceptionState.throwDOMException(InvalidAccessError, "Not supported.");
    102 }
    103 
    104 bool ServiceWorker::isReady()
    105 {
    106     return m_proxyState == Ready;
    107 }
    108 
    109 void ServiceWorker::dispatchStateChangeEvent()
    110 {
    111     ASSERT(isReady());
    112     this->dispatchEvent(Event::create(EventTypeNames::statechange));
    113 }
    114 
    115 String ServiceWorker::scriptURL() const
    116 {
    117     return m_outerWorker->url().string();
    118 }
    119 
    120 const AtomicString& ServiceWorker::state() const
    121 {
    122     DEFINE_STATIC_LOCAL(AtomicString, unknown, ("unknown", AtomicString::ConstructFromLiteral));
    123     DEFINE_STATIC_LOCAL(AtomicString, parsed, ("parsed", AtomicString::ConstructFromLiteral));
    124     DEFINE_STATIC_LOCAL(AtomicString, installing, ("installing", AtomicString::ConstructFromLiteral));
    125     DEFINE_STATIC_LOCAL(AtomicString, installed, ("installed", AtomicString::ConstructFromLiteral));
    126     DEFINE_STATIC_LOCAL(AtomicString, activating, ("activating", AtomicString::ConstructFromLiteral));
    127     DEFINE_STATIC_LOCAL(AtomicString, activated, ("activated", AtomicString::ConstructFromLiteral));
    128     DEFINE_STATIC_LOCAL(AtomicString, redundant, ("redundant", AtomicString::ConstructFromLiteral));
    129 
    130     switch (m_outerWorker->state()) {
    131     case WebServiceWorkerStateUnknown:
    132         // The web platform should never see this internal state
    133         ASSERT_NOT_REACHED();
    134         return unknown;
    135     case WebServiceWorkerStateParsed:
    136         return parsed;
    137     case WebServiceWorkerStateInstalling:
    138         return installing;
    139     case WebServiceWorkerStateInstalled:
    140         return installed;
    141     case WebServiceWorkerStateActivating:
    142         return activating;
    143     case WebServiceWorkerStateActivated:
    144         return activated;
    145     case WebServiceWorkerStateRedundant:
    146         return redundant;
    147     default:
    148         ASSERT_NOT_REACHED();
    149         return nullAtom;
    150     }
    151 }
    152 
    153 PassRefPtrWillBeRawPtr<ServiceWorker> ServiceWorker::from(ExecutionContext* executionContext, WebType* worker)
    154 {
    155     if (!worker)
    156         return nullptr;
    157 
    158     RefPtrWillBeRawPtr<ServiceWorker> serviceWorker = getOrCreate(executionContext, worker);
    159     if (serviceWorker->m_proxyState == Initial)
    160         serviceWorker->setProxyState(Ready);
    161     return serviceWorker.release();
    162 }
    163 
    164 PassRefPtrWillBeRawPtr<ServiceWorker> ServiceWorker::take(ScriptPromiseResolver* resolver, WebType* worker)
    165 {
    166     if (!worker)
    167         return nullptr;
    168 
    169     RefPtrWillBeRawPtr<ServiceWorker> serviceWorker = getOrCreate(resolver->scriptState()->executionContext(), worker);
    170     ScriptState::Scope scope(resolver->scriptState());
    171     if (serviceWorker->m_proxyState == Initial)
    172         serviceWorker->waitOnPromise(resolver);
    173     return serviceWorker;
    174 }
    175 
    176 void ServiceWorker::dispose(WebType* worker)
    177 {
    178     if (worker && !worker->proxy())
    179         delete worker;
    180 }
    181 
    182 void ServiceWorker::setProxyState(ProxyState state)
    183 {
    184     if (m_proxyState == state)
    185         return;
    186     switch (m_proxyState) {
    187     case Initial:
    188         ASSERT(state == RegisterPromisePending || state == Ready || state == ContextStopped);
    189         break;
    190     case RegisterPromisePending:
    191         ASSERT(state == Ready || state == ContextStopped);
    192         break;
    193     case Ready:
    194         ASSERT(state == ContextStopped);
    195         break;
    196     case ContextStopped:
    197         ASSERT_NOT_REACHED();
    198         break;
    199     }
    200 
    201     ProxyState oldState = m_proxyState;
    202     m_proxyState = state;
    203     if (oldState == Ready || state == Ready)
    204         m_outerWorker->proxyReadyChanged();
    205 }
    206 
    207 void ServiceWorker::onPromiseResolved()
    208 {
    209     if (m_proxyState == ContextStopped)
    210         return;
    211     setProxyState(Ready);
    212 }
    213 
    214 void ServiceWorker::waitOnPromise(ScriptPromiseResolver* resolver)
    215 {
    216     if (resolver->promise().isEmpty()) {
    217         // The document was detached during registration. The state doesn't really
    218         // matter since this ServiceWorker will immediately die.
    219         setProxyState(ContextStopped);
    220         return;
    221     }
    222     setProxyState(RegisterPromisePending);
    223     resolver->promise().then(ThenFunction::createFunction(resolver->scriptState(), this));
    224 }
    225 
    226 bool ServiceWorker::hasPendingActivity() const
    227 {
    228     if (AbstractWorker::hasPendingActivity())
    229         return true;
    230     if (m_proxyState == ContextStopped)
    231         return false;
    232     return m_outerWorker->state() != WebServiceWorkerStateRedundant;
    233 }
    234 
    235 void ServiceWorker::stop()
    236 {
    237     setProxyState(ContextStopped);
    238 }
    239 
    240 PassRefPtrWillBeRawPtr<ServiceWorker> ServiceWorker::getOrCreate(ExecutionContext* executionContext, WebType* outerWorker)
    241 {
    242     if (!outerWorker)
    243         return nullptr;
    244 
    245     WebServiceWorkerProxy* proxy = outerWorker->proxy();
    246     ServiceWorker* existingServiceWorker = proxy ? proxy->unwrap() : 0;
    247     if (existingServiceWorker) {
    248         ASSERT(existingServiceWorker->executionContext() == executionContext);
    249         return existingServiceWorker;
    250     }
    251 
    252     RefPtrWillBeRawPtr<ServiceWorker> worker = adoptRefWillBeNoop(new ServiceWorker(executionContext, adoptPtr(outerWorker)));
    253     worker->suspendIfNeeded();
    254     return worker.release();
    255 }
    256 
    257 ServiceWorker::ServiceWorker(ExecutionContext* executionContext, PassOwnPtr<WebServiceWorker> worker)
    258     : AbstractWorker(executionContext)
    259     , WebServiceWorkerProxy(this)
    260     , m_outerWorker(worker)
    261     , m_proxyState(Initial)
    262 {
    263     ASSERT(m_outerWorker);
    264     m_outerWorker->setProxy(this);
    265 }
    266 
    267 } // namespace blink
    268