[ServiceWorker] Allow waitUntil to be called multiple times asynchronously

third_party/WebKit/Source/modules/serviceworkers/RespondWithObserver.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/RespondWithObserver.h"
 
 #include <v8.h>
 
 #include "bindings/core/v8/ScriptFunction.h"
 #include "bindings/core/v8/ScriptPromise.h"
@@ skipping 63 matching lines @@
   event_dispatch_time_ = WTF::CurrentTime();
 }
 
 void RespondWithObserver::DidDispatchEvent(
     DispatchEventResult dispatch_result) {
   DCHECK(GetExecutionContext());
   if (state_ != kInitial)
     return;
 
   if (dispatch_result != DispatchEventResult::kNotCanceled) {
-    observer_->IncrementPendingActivity();
+    observer_->IncrementPendingPromise();
     ResponseWasRejected(kWebServiceWorkerResponseErrorDefaultPrevented);
     return;
   }
 
   OnNoResponse();
   state_ = kDone;
   observer_.Clear();
 }
 
 void RespondWithObserver::RespondWith(ScriptState* script_state,
                                       ScriptPromise script_promise,
                                       ExceptionState& exception_state) {
   if (state_ != kInitial) {
     exception_state.ThrowDOMException(
         kInvalidStateError, "The event has already been responded to.");
     return;
   }
 
   state_ = kPending;
-  observer_->IncrementPendingActivity();
+  observer_->IncrementPendingPromise();
   script_promise.Then(ThenFunction::CreateFunction(script_state, this,
                                                    ThenFunction::kFulfilled),
                       ThenFunction::CreateFunction(script_state, this,
                                                    ThenFunction::kRejected));
 }
 
 void RespondWithObserver::ResponseWasRejected(
     WebServiceWorkerResponseError error) {
   OnResponseRejected(error);
   state_ = kDone;
-  observer_->DecrementPendingActivity();
+  observer_->DecrementPendingPromise();
   observer_.Clear();
 }
 
 void RespondWithObserver::ResponseWasFulfilled(const ScriptValue& value) {
   OnResponseFulfilled(value);
   state_ = kDone;
-  observer_->DecrementPendingActivity();
+  observer_->DecrementPendingPromise();
   observer_.Clear();
 }
 
 RespondWithObserver::RespondWithObserver(ExecutionContext* context,
                                          int event_id,
                                          WaitUntilObserver* observer)
     : ContextLifecycleObserver(context),
       event_id_(event_id),
       state_(kInitial),
       observer_(observer) {}
 
 DEFINE_TRACE(RespondWithObserver) {
   visitor->Trace(observer_);
   ContextLifecycleObserver::Trace(visitor);
 }
 
 }  // namespace blink