Add ServiceWorker InstallPhaseEvent.waitUntil() layout test.

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 95 matching lines @@
     return m_outerWorker->url().string();
 }
 
 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));
+    DEFINE_STATIC_LOCAL(AtomicString, activated, ("activated", AtomicString::ConstructFromLiteral));
+    DEFINE_STATIC_LOCAL(AtomicString, redundant, ("redundant", 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;
+    case blink::WebServiceWorkerStateActivated:
+        return activated;
+    case blink::WebServiceWorkerStateRedundant:
+        return redundant;
     default:
         ASSERT_NOT_REACHED();
         return nullAtom;
     }
 }
 
 PassRefPtr<ServiceWorker> ServiceWorker::from(ExecutionContext* executionContext, WebType* worker)
 {
     if (!worker)
         return PassRefPtr<ServiceWorker>();
@@ skipping 59 matching lines @@
     setProxyState(RegisterPromisePending);
     promise.then(ThenFunction::create(this));
 }
 
 bool ServiceWorker::hasPendingActivity() const
 {
     if (AbstractWorker::hasPendingActivity())
         return true;
     if (m_proxyState == ContextStopped)
         return false;
-    return m_outerWorker->state() != blink::WebServiceWorkerStateDeactivated;
+    return m_outerWorker->state() != blink::WebServiceWorkerStateRedundant;
 }
 
 void ServiceWorker::stop()
 {
     setProxyState(ContextStopped);
 }
 
 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)
     , WebServiceWorkerProxy(this)
     , m_outerWorker(worker)
     , m_proxyState(Initial)
 {
     ScriptWrappable::init(this);
     ASSERT(m_outerWorker);
     m_outerWorker->setProxy(this);
 }
 
 } // namespace WebCore