Support PerformanceResourceTiming for Service Worker Navigation Preload

third_party/WebKit/Source/web/ServiceWorkerGlobalScopeProxy.cpp

 /*
  * Copyright (C) 2013 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 54 matching lines @@
 #include "modules/serviceworkers/ExtendableMessageEvent.h"
 #include "modules/serviceworkers/FetchEvent.h"
 #include "modules/serviceworkers/ForeignFetchEvent.h"
 #include "modules/serviceworkers/InstallEvent.h"
 #include "modules/serviceworkers/ServiceWorkerClient.h"
 #include "modules/serviceworkers/ServiceWorkerGlobalScope.h"
 #include "modules/serviceworkers/ServiceWorkerWindowClient.h"
 #include "modules/serviceworkers/WaitUntilObserver.h"
 #include "platform/CrossThreadFunctional.h"
 #include "platform/RuntimeEnabledFeatures.h"
+#include "platform/loader/fetch/ResourceResponse.h"
 #include "platform/wtf/Assertions.h"
 #include "platform/wtf/Functional.h"
 #include "platform/wtf/PtrUtil.h"
 #include "public/platform/modules/notifications/WebNotificationData.h"
 #include "public/platform/modules/serviceworker/WebServiceWorkerEventResult.h"
 #include "public/platform/modules/serviceworker/WebServiceWorkerRequest.h"
 #include "public/web/WebSerializedScriptValue.h"
 #include "public/web/modules/serviceworker/WebServiceWorkerContextClient.h"
 #include "web/WebEmbeddedWorkerImpl.h"
 
@@ skipping 186 matching lines @@
   event_init.setRequest(request);
   event_init.setClientId(
       web_request.IsMainResourceLoad() ? WebString() : web_request.ClientId());
   event_init.setIsReload(web_request.IsReload());
   ScriptState* script_state =
       WorkerGlobalScope()->ScriptController()->GetScriptState();
   FetchEvent* fetch_event = FetchEvent::Create(
       script_state, EventTypeNames::fetch, event_init, respond_with_observer,
       wait_until_observer, navigation_preload_sent);
   if (navigation_preload_sent) {
-    // Keep |fetchEvent| until onNavigationPreloadResponse() or
+    // Keep |fetchEvent| until OnNavigationPreloadComplete() or
     // onNavigationPreloadError() will be called.
     pending_preload_fetch_events_.insert(fetch_event_id, fetch_event);
   }
   wait_until_observer->WillDispatchEvent();
   respond_with_observer->WillDispatchEvent();
   DispatchEventResult dispatch_result =
       WorkerGlobalScope()->DispatchEvent(fetch_event);
   respond_with_observer->DidDispatchEvent(dispatch_result);
   // false is okay because waitUntil for fetch event doesn't care about the
   // promise rejection or an uncaught runtime script error.
   wait_until_observer->DidDispatchEvent(false /* errorOccurred */);
 }
 
 void ServiceWorkerGlobalScopeProxy::OnNavigationPreloadResponse(
     int fetch_event_id,
     std::unique_ptr<WebURLResponse> response,
     std::unique_ptr<WebDataConsumerHandle> data_consume_handle) {
-  FetchEvent* fetch_event = pending_preload_fetch_events_.Take(fetch_event_id);
+  auto it = pending_preload_fetch_events_.find(fetch_event_id);
+  DCHECK(it != pending_preload_fetch_events_.end());
+  FetchEvent* fetch_event = it->value.Get();
   DCHECK(fetch_event);
   fetch_event->OnNavigationPreloadResponse(
       WorkerGlobalScope()->ScriptController()->GetScriptState(),
       std::move(response), std::move(data_consume_handle));
 }
 
 void ServiceWorkerGlobalScopeProxy::OnNavigationPreloadError(
     int fetch_event_id,
     std::unique_ptr<WebServiceWorkerError> error) {
   FetchEvent* fetch_event = pending_preload_fetch_events_.Take(fetch_event_id);
-  // This method may be called after onNavigationPreloadResponse() was called.
-  if (!fetch_event)
-    return;
+  DCHECK(fetch_event);
   // Display an unsanitized console message.
   if (!error->unsanitized_message.IsEmpty()) {
     WorkerGlobalScope()->AddConsoleMessage(ConsoleMessage::Create(
         kWorkerMessageSource, blink::MessageLevel::kErrorMessageLevel,
         error->unsanitized_message));
   }
   // Reject the preloadResponse promise.
   fetch_event->OnNavigationPreloadError(
       WorkerGlobalScope()->ScriptController()->GetScriptState(),
       std::move(error));
 }
 
+void ServiceWorkerGlobalScopeProxy::OnNavigationPreloadComplete(
+    int fetch_event_id,
+    double completion_time,
+    int64_t encoded_data_length,
+    int64_t encoded_body_length,
+    int64_t decoded_body_length) {
+  FetchEvent* fetch_event = pending_preload_fetch_events_.Take(fetch_event_id);
+  DCHECK(fetch_event);
+  fetch_event->OnNavigationPreloadComplete(
+      WorkerGlobalScope(), completion_time, encoded_data_length,
+      encoded_body_length, decoded_body_length);
+}
+
 void ServiceWorkerGlobalScopeProxy::DispatchForeignFetchEvent(
     int fetch_event_id,
     const WebServiceWorkerRequest& web_request) {
   if (!OriginTrials::foreignFetchEnabled(WorkerGlobalScope())) {
     // If origin trial tokens have expired, or are otherwise no longer valid
     // no events should be dispatched.
     // TODO(mek): Ideally the browser wouldn't even start the service worker
     // if its tokens have expired.
     ServiceWorkerGlobalScopeClient::From(WorkerGlobalScope())
         ->RespondToFetchEventWithNoResponse(fetch_event_id, WTF::CurrentTime());
@@ skipping 263 matching lines @@
   return *document_;
 }
 
 ServiceWorkerGlobalScope* ServiceWorkerGlobalScopeProxy::WorkerGlobalScope()
     const {
   DCHECK(worker_global_scope_);
   return worker_global_scope_;
 }
 
 }  // namespace blink