Keep the wrapper of FetchEvent alive while waiting for the preload response.

third_party/WebKit/Source/modules/serviceworkers/FetchEvent.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/FetchEvent.h"
 
 #include "bindings/core/v8/ToV8ForCore.h"
 #include "core/dom/ExecutionContext.h"
 #include "core/timing/WorkerGlobalScopePerformance.h"
 #include "modules/fetch/BytesConsumerForDataConsumerHandle.h"
@@ skipping 51 matching lines @@
 }
 
 ScriptPromise FetchEvent::preloadResponse(ScriptState* script_state) {
   return preload_response_property_->Promise(script_state->World());
 }
 
 const AtomicString& FetchEvent::InterfaceName() const {
   return EventNames::FetchEvent;
 }
 
+bool FetchEvent::HasPendingActivity() const {
+  // Prevent V8 from garbage collecting the wrapper object while waiting for the
+  // preload response. This is in order to keep the resolver of preloadResponse
+  // Promise alive.
+  return waiting_for_preload_response_ && GetExecutionContext();
+}
+
 FetchEvent::FetchEvent(ScriptState* script_state,
                        const AtomicString& type,
                        const FetchEventInit& initializer,
                        FetchRespondWithObserver* respond_with_observer,
                        WaitUntilObserver* wait_until_observer,
                        bool navigation_preload_sent)
     : ExtendableEvent(type, initializer, wait_until_observer),
+      ContextClient(ExecutionContext::From(script_state)),
       observer_(respond_with_observer),
       preload_response_property_(new PreloadResponseProperty(
           ExecutionContext::From(script_state),
           this,
-          PreloadResponseProperty::kPreloadResponse)) {
+          PreloadResponseProperty::kPreloadResponse)),
+      waiting_for_preload_response_(navigation_preload_sent) {
   if (!navigation_preload_sent)
     preload_response_property_->ResolveWithUndefined();
 
   client_id_ = initializer.clientId();
   is_reload_ = initializer.isReload();
   if (initializer.hasRequest()) {
     ScriptState::Scope scope(script_state);
     request_ = initializer.request();
     v8::Local<v8::Value> request = ToV8(request_, script_state);
     v8::Local<v8::Value> event = ToV8(this, script_state);
     if (event.IsEmpty()) {
       // |toV8| can return an empty handle when the worker is terminating.
       // We don't want the renderer to crash in such cases.
       // TODO(yhirano): Replace this branch with an assertion when the
       // graceful shutdown mechanism is introduced.
       return;
     }
     DCHECK(event->IsObject());
     // Sets a hidden value in order to teach V8 the dependency from
     // the event to the request.
     V8PrivateProperty::GetFetchEventRequest(script_state->GetIsolate())
         .Set(event.As<v8::Object>(), request);
     // From the same reason as above, setHiddenValue can return false.
     // TODO(yhirano): Add an assertion that it returns true once the
     // graceful shutdown mechanism is introduced.
   }
 }
 
+FetchEvent::~FetchEvent() {}
+
 void FetchEvent::OnNavigationPreloadResponse(
     ScriptState* script_state,
     std::unique_ptr<WebURLResponse> response,
     std::unique_ptr<WebDataConsumerHandle> data_consume_handle) {
   if (!script_state->ContextIsValid())
     return;
   DCHECK(preload_response_property_);
   DCHECK(!preload_response_);
   ScriptState::Scope scope(script_state);
   preload_response_ = std::move(response);
@@ skipping 20 matching lines @@
       NetworkUtils::IsRedirectResponseCode(preload_response_->HttpStatusCode())
           ? response_data->CreateOpaqueRedirectFilteredResponse()
           : response_data->CreateBasicFilteredResponse();
   preload_response_property_->Resolve(
       Response::Create(ExecutionContext::From(script_state), tainted_response));
 }
 
 void FetchEvent::OnNavigationPreloadError(
     ScriptState* script_state,
     std::unique_ptr<WebServiceWorkerError> error) {
+  waiting_for_preload_response_ = false;
   if (!script_state->ContextIsValid())
     return;
   DCHECK(preload_response_property_);
   preload_response_property_->Reject(
       ServiceWorkerError::Take(nullptr, *error.get()));
 }
 
 void FetchEvent::OnNavigationPreloadComplete(
     WorkerGlobalScope* worker_global_scope,
     double completion_time,
     int64_t encoded_data_length,
     int64_t encoded_body_length,
     int64_t decoded_body_length) {
   DCHECK(preload_response_);
+  waiting_for_preload_response_ = false;
   std::unique_ptr<WebURLResponse> response = std::move(preload_response_);
   ResourceResponse resource_response = response->ToResourceResponse();
   resource_response.SetEncodedDataLength(encoded_data_length);
   resource_response.SetEncodedBodyLength(encoded_body_length);
   resource_response.SetDecodedBodyLength(decoded_body_length);
   // According to the current spec of Resource Timing, the initiator type of
   // navigation preload request must be "other". But it may change when the spec
   // discussion is settled. https://github.com/w3c/resource-timing/issues/110
   RefPtr<ResourceTimingInfo> info = ResourceTimingInfo::Create(
       "other", resource_response.GetResourceLoadTiming()->RequestTime(),
       false /* is_main_resource */);
   info->SetNegativeAllowed(true);
   info->SetLoadFinishTime(completion_time);
   info->SetInitialURL(request_->url());
   info->SetFinalResponse(resource_response);
   info->AddFinalTransferSize(encoded_data_length);
   WorkerGlobalScopePerformance::performance(*worker_global_scope)
       ->AddResourceTiming(*info);
 }
 
 DEFINE_TRACE(FetchEvent) {
   visitor->Trace(observer_);
   visitor->Trace(request_);
   visitor->Trace(preload_response_property_);
   ExtendableEvent::Trace(visitor);
+  ContextClient::Trace(visitor);
 }
 
 }  // namespace blink