[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);
+  // WPT test:
+  // external/wpt/service-workers/service-worker/
+  // extendable-event-async-waituntil.https.html
+  // 'Test calling waitUntil on a script constructed ExtendableEvent throws
+  // exception'

[falken, 2017/05/25 07:23:23]

Ah sorry I meant to just link in the codereview.

I don't think the spec specifically disallows waitUntil on a script-contructed
event. It just falls into the "If the pending promises count is zero and the
dispatch flag is unset, then" part.

We can just remove this comment.

[leonhsl(Using Gerrit), 2017/05/25 10:11:36]

Oops, got it, removed this comment and updated CL description. Thanks!

+  if (!observer_) {
+    exception_state.ThrowDOMException(
+        kInvalidStateError,
+        "Can not call waitUntil on a script constructed ExtendableEvent.");
+    return;
+  }
+
+  observer_->WaitUntil(script_state, script_promise, exception_state);
 }
 
 ExtendableEvent::ExtendableEvent(const AtomicString& type,
                                  const ExtendableEventInit& initializer)
     : Event(type, initializer) {}
 
 ExtendableEvent::ExtendableEvent(const AtomicString& type,
                                  const ExtendableEventInit& initializer,
                                  WaitUntilObserver* observer)
     : Event(type, initializer), observer_(observer) {}
 
 const AtomicString& ExtendableEvent::InterfaceName() const {
   return EventNames::ExtendableEvent;
 }
 
 DEFINE_TRACE(ExtendableEvent) {
   visitor->Trace(observer_);
   Event::Trace(visitor);
 }
 
 }  // namespace blink