[ServiceWorker] waitUntil() should wait until all promises got resolved/rejected.

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

Index: third_party/WebKit/Source/modules/serviceworkers/WaitUntilObserver.cpp
diff --git a/third_party/WebKit/Source/modules/serviceworkers/WaitUntilObserver.cpp b/third_party/WebKit/Source/modules/serviceworkers/WaitUntilObserver.cpp
index 839f336a2d17707a5f95b998d9b2cb2cfe5e688f..843007fd39e6b46131e334698101e1cd5aec6a73 100644
--- a/third_party/WebKit/Source/modules/serviceworkers/WaitUntilObserver.cpp
+++ b/third_party/WebKit/Source/modules/serviceworkers/WaitUntilObserver.cpp
@@ -65,11 +65,10 @@ class WaitUntilObserver::ThenFunction final : public ScriptFunction {
     ASSERT(observer_);
     ASSERT(resolve_type_ == kFulfilled || resolve_type_ == kRejected);
     if (resolve_type_ == kRejected) {
-      observer_->ReportError(value);
       value =
           ScriptPromise::Reject(value.GetScriptState(), value).GetScriptValue();
     }
-    observer_->DecrementPendingActivity();
+    observer_->OnPromiseCompleted(resolve_type_ == kRejected ? true : false);
     observer_ = nullptr;
     return value;
   }
@@ -97,17 +96,15 @@ void WaitUntilObserver::WillDispatchEvent() {
   IncrementPendingActivity();
 }
 
-void WaitUntilObserver::DidDispatchEvent(bool error_occurred) {
-  if (error_occurred)
-    has_error_ = true;
+void WaitUntilObserver::DidDispatchEvent(bool event_dispatch_failed) {
+  event_dispatch_state_ = event_dispatch_failed ? kFailed : kCompleted;
   DecrementPendingActivity();
-  event_dispatched_ = true;
 }
 
 void WaitUntilObserver::WaitUntil(ScriptState* script_state,
                                   ScriptPromise script_promise,
                                   ExceptionState& exception_state) {
-  if (event_dispatched_) {
+  if (event_dispatch_state_ != kInitial) {
     exception_state.ThrowDOMException(kInvalidStateError,
                                       "The event handler is already finished.");
     return;
@@ -143,11 +140,10 @@ WaitUntilObserver::WaitUntilObserver(ExecutionContext* context,
           this,
           &WaitUntilObserver::ConsumeWindowInteraction) {}
 
-void WaitUntilObserver::ReportError(const ScriptValue& value) {
-  // FIXME: Propagate error message to the client for onerror handling.
-  NOTIMPLEMENTED();
-
-  has_error_ = true;
+void WaitUntilObserver::OnPromiseCompleted(bool rejected) {

[falken, 2017/05/10 05:25:12]

OnPromiseSettled is aligned with promise terminology.

To avoid the bool param, I'd rather have this use the enum ResolveType, or just
split it into OnPromiseFulfilled and OnPromiseRejected.

[leonhsl(Using Gerrit), 2017/05/10 07:07:52]

Done.

+  if (rejected)
+    has_rejected_promise_ = true;
+  DecrementPendingActivity();
 }
 
 void WaitUntilObserver::IncrementPendingActivity() {
@@ -156,14 +152,16 @@ void WaitUntilObserver::IncrementPendingActivity() {
 
 void WaitUntilObserver::DecrementPendingActivity() {
   ASSERT(pending_activity_ > 0);
-  if (!execution_context_ || (!has_error_ && --pending_activity_))
+  if (!execution_context_ ||
+      (event_dispatch_state_ != kFailed && --pending_activity_))
     return;
 
   ServiceWorkerGlobalScopeClient* client =
       ServiceWorkerGlobalScopeClient::From(execution_context_);
   WebServiceWorkerEventResult result =
-      has_error_ ? kWebServiceWorkerEventResultRejected
-                 : kWebServiceWorkerEventResultCompleted;
+      (event_dispatch_state_ == kFailed || has_rejected_promise_)
+          ? kWebServiceWorkerEventResultRejected
+          : kWebServiceWorkerEventResultCompleted;
   switch (type_) {
     case kActivate:
       client->DidHandleActivateEvent(event_id_, result, event_dispatch_time_);