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

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

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "modules/serviceworkers/WaitUntilObserver.h"
 
 #include "bindings/core/v8/ScriptFunction.h"
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptValue.h"
 #include "bindings/core/v8/V8BindingForCore.h"
@@ skipping 47 matching lines @@
                WaitUntilObserver* observer,
                ResolveType type)
       : ScriptFunction(script_state),
         observer_(observer),
         resolve_type_(type) {}
 
   ScriptValue Call(ScriptValue value) override {
     ASSERT(observer_);
     ASSERT(resolve_type_ == kFulfilled || resolve_type_ == kRejected);
     if (resolve_type_ == kRejected) {
-      observer_->ReportError(value);
+      observer_->ReportPromiseRejected(value);
       value =
           ScriptPromise::Reject(value.GetScriptState(), value).GetScriptValue();
     }
     observer_->DecrementPendingActivity();

[falken, 2017/05/09 08:29:02]

Looking at this more, it looks like things can be cleaner if we just pass an
argument (probably an enum) to DecrementPendingActivity that indicates whether a
promise rejected, resolved, or the event dispatch failed. Then I think we don't
need ReportPromiseRejected() or set |has_error_| separately, it can all be done
by DecrementPendingActivity(). WDYT?

[falken, 2017/05/09 09:02:54]

Or maybe better functions like:
OnPromiseResolved()
OnPromiseRejected()
OnEventDispatchFailed()

The point is instead of calling a function that sets state that affects antoher
function, we'd just need to call a single function and have it do the work.

[leonhsl(Using Gerrit), 2017/05/10 05:03:34]

Done.

     observer_ = nullptr;
     return value;
   }
 
   Member<WaitUntilObserver> observer_;
   ResolveType resolve_type_;
 };
 
 WaitUntilObserver* WaitUntilObserver::Create(ExecutionContext* context,
                                              EventType type,
@@ skipping 53 matching lines @@
                                      EventType type,
                                      int event_id)
     : execution_context_(context),
       type_(type),
       event_id_(event_id),
       consume_window_interaction_timer_(
           Platform::Current()->CurrentThread()->GetWebTaskRunner(),
           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::ReportPromiseRejected(const ScriptValue& value) {
+  has_rejected_promise_ = true;
 }
 
 void WaitUntilObserver::IncrementPendingActivity() {
   ++pending_activity_;
 }
 
 void WaitUntilObserver::DecrementPendingActivity() {
   ASSERT(pending_activity_ > 0);
   if (!execution_context_ || (!has_error_ && --pending_activity_))
     return;
 
   ServiceWorkerGlobalScopeClient* client =
       ServiceWorkerGlobalScopeClient::From(execution_context_);
   WebServiceWorkerEventResult result =
-      has_error_ ? kWebServiceWorkerEventResultRejected
-                 : kWebServiceWorkerEventResultCompleted;
+      (has_error_ || has_rejected_promise_)
+          ? kWebServiceWorkerEventResultRejected
+          : kWebServiceWorkerEventResultCompleted;
   switch (type_) {
     case kActivate:
       client->DidHandleActivateEvent(event_id_, result, event_dispatch_time_);
       break;
     case kFetch:
       client->DidHandleFetchEvent(event_id_, result, event_dispatch_time_);
       break;
     case kInstall:
       client->DidHandleInstallEvent(event_id_, result, event_dispatch_time_);
       break;
@@ skipping 45 matching lines @@
   if (!execution_context_)
     return;
   execution_context_->ConsumeWindowInteraction();
 }
 
 DEFINE_TRACE(WaitUntilObserver) {
   visitor->Trace(execution_context_);
 }
 
 }  // namespace blink