[ServiceWorker] Allow waitUntil to be called multiple times asynchronously

third_party/WebKit/Source/modules/serviceworkers/ExtendableEvent.cpp

 /*
  * Copyright (C) 2014 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 34 matching lines @@
                                          const ExtendableEventInit& event_init,
                                          WaitUntilObserver* observer) {
   return new ExtendableEvent(type, event_init, observer);
 }
 
 ExtendableEvent::~ExtendableEvent() {}
 
 void ExtendableEvent::waitUntil(ScriptState* script_state,
                                 ScriptPromise script_promise,
                                 ExceptionState& exception_state) {
-  if (observer_)
-    observer_->WaitUntil(script_state, script_promise, exception_state);
+  if (created_by_script_) {
+    exception_state.ThrowDOMException(
+        kInvalidStateError,
+        "Can not call waitUntil on a script constructed ExtendableEvent.");
+    return;
+  }
+
+  DCHECK(observer_);
+  observer_->WaitUntil(script_state, script_promise, exception_state);
 }
 
 ExtendableEvent::ExtendableEvent(const AtomicString& type,
                                  const ExtendableEventInit& initializer)
-    : Event(type, initializer) {}
+    : Event(type, initializer), created_by_script_(true) {}
 
 ExtendableEvent::ExtendableEvent(const AtomicString& type,
                                  const ExtendableEventInit& initializer,
                                  WaitUntilObserver* observer)
-    : Event(type, initializer), observer_(observer) {}
+    : Event(type, initializer),
+      created_by_script_(false),
+      observer_(observer) {}
 
 const AtomicString& ExtendableEvent::InterfaceName() const {
   return EventNames::ExtendableEvent;
 }
 
 DEFINE_TRACE(ExtendableEvent) {
   visitor->Trace(observer_);
   Event::Trace(visitor);
 }
 
 }  // namespace blink