Remove the queued states mechanism from ServiceWorker

Source/modules/serviceworkers/ServiceWorker.cpp

 /*
  * 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 66 matching lines @@
     // Disentangle the port in preparation for sending it to the remote context.
     OwnPtr<MessagePortChannelArray> channels = MessagePort::disentanglePorts(ports, exceptionState);
     if (exceptionState.hadException())
         return;
 
     blink::WebString messageString = message->toWireString();
     OwnPtr<blink::WebMessagePortChannelArray> webChannels = MessagePort::toWebMessagePortChannelArray(channels.release());
     m_outerWorker->postMessage(messageString, webChannels.leakPtr());
 }
 
-void ServiceWorker::onStateChanged(blink::WebServiceWorkerState state)
+bool ServiceWorker::isReady()
 {
-    if (m_isPromisePending)
-        m_queuedStates.append(state);
-    else
-        changeState(state);
+    return !m_isPromisePending;
 }
 
-// FIXME: To be removed, this is just here as part of a three-sided patch.
 void ServiceWorker::dispatchStateChangeEvent()
 {
-    changeState(m_outerWorker->state());
+    // FIXME: Add ASSERT(isReady()) when Chromium side change rolls in.
+    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));
@@ skipping 27 matching lines @@
     NewScriptState::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;
-    for (Vector<blink::WebServiceWorkerState>::iterator iterator = m_queuedStates.begin(); iterator != m_queuedStates.end(); ++iterator)
-        changeState(*iterator);
-    m_queuedStates.clear();
+    m_outerWorker->proxyReadyChanged();
 }
 
 void ServiceWorker::waitOnPromise(ScriptPromise promise)
 {
     ASSERT(!m_isPromisePending);
     m_isPromisePending = true;
+    m_outerWorker->proxyReadyChanged();
     promise.then(ThenFunction::create(this));
 }
 
-void ServiceWorker::changeState(blink::WebServiceWorkerState state)
-{
-    m_outerWorker->setState(state);
-    this->dispatchEvent(Event::create(EventTypeNames::statechange));
-}
-
 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