Use fetch_event_id (fetchEventID in blink) for FetchEvent

content/renderer/service_worker/service_worker_context_client.cc

 // Copyright 2015 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 "content/renderer/service_worker/service_worker_context_client.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/lazy_instance.h"
@@ skipping 217 matching lines @@
  public:
   static void Create(mojom::FetchEventDispatcherRequest request) {
     mojo::MakeStrongBinding(base::MakeUnique<FetchEventDispatcherImpl>(),
                             std::move(request));
   }
 
   FetchEventDispatcherImpl() {}
 
   ~FetchEventDispatcherImpl() override {}
 
-  void DispatchFetchEvent(int response_id,
+  void DispatchFetchEvent(int fetch_event_id,
                           const ServiceWorkerFetchRequest& request,
                           const DispatchFetchEventCallback& callback) override {
     ServiceWorkerContextClient* client =
         ServiceWorkerContextClient::ThreadSpecificInstance();
     if (!client) {
       callback.Run(SERVICE_WORKER_ERROR_ABORT, base::Time::Now());
       return;
     }
-    client->DispatchFetchEvent(response_id, request, callback);
+    client->DispatchFetchEvent(fetch_event_id, request, callback);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FetchEventDispatcherImpl);
 };
 
 ServiceWorkerContextClient*
 ServiceWorkerContextClient::ThreadSpecificInstance() {
   return g_worker_client_tls.Pointer()->Get();
 }
@@ skipping 321 matching lines @@
 void ServiceWorkerContextClient::didHandleInstallEvent(
     int request_id,
     blink::WebServiceWorkerEventResult result,
     double event_dispatch_time) {
   Send(new ServiceWorkerHostMsg_InstallEventFinished(
       GetRoutingID(), request_id, result, proxy_->hasFetchEventHandler(),
       base::Time::FromDoubleT(event_dispatch_time)));
 }
 
 void ServiceWorkerContextClient::respondToFetchEvent(
-    int response_id,
+    int fetch_event_id,
     double event_dispatch_time) {
   Send(new ServiceWorkerHostMsg_FetchEventResponse(
-      GetRoutingID(), response_id, SERVICE_WORKER_FETCH_EVENT_RESULT_FALLBACK,
-      ServiceWorkerResponse(), base::Time::FromDoubleT(event_dispatch_time)));
+      GetRoutingID(), fetch_event_id,
+      SERVICE_WORKER_FETCH_EVENT_RESULT_FALLBACK, ServiceWorkerResponse(),
+      base::Time::FromDoubleT(event_dispatch_time)));
 }
 
 void ServiceWorkerContextClient::respondToFetchEvent(
-    int response_id,
+    int fetch_event_id,
     const blink::WebServiceWorkerResponse& web_response,
     double event_dispatch_time) {
   ServiceWorkerHeaderMap headers;
   GetServiceWorkerHeaderMapFromWebResponse(web_response, &headers);
   ServiceWorkerHeaderList cors_exposed_header_names;
   GetCorsExposedHeaderNamesFromWebResponse(web_response,
                                            &cors_exposed_header_names);
   ServiceWorkerResponse response(
       web_response.url(), web_response.status(),
       web_response.statusText().utf8(), web_response.responseType(), headers,
       web_response.blobUUID().utf8(), web_response.blobSize(),
       web_response.streamURL(), web_response.error(),
       base::Time::FromInternalValue(web_response.responseTime()),
       !web_response.cacheStorageCacheName().isNull(),
       web_response.cacheStorageCacheName().utf8(), cors_exposed_header_names);
   Send(new ServiceWorkerHostMsg_FetchEventResponse(
-      GetRoutingID(), response_id, SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE,
-      response, base::Time::FromDoubleT(event_dispatch_time)));
+      GetRoutingID(), fetch_event_id,
+      SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE, response,
+      base::Time::FromDoubleT(event_dispatch_time)));
 }
 
 void ServiceWorkerContextClient::didHandleFetchEvent(
-    int event_finish_id,
+    int fetch_event_id,
     blink::WebServiceWorkerEventResult result,
     double event_dispatch_time) {
   const FetchCallback* callback =
-      context_->fetch_event_callbacks.Lookup(event_finish_id);
+      context_->fetch_event_callbacks.Lookup(fetch_event_id);
   if (!callback)
     return;
 
   callback->Run(result == blink::WebServiceWorkerEventResultCompleted
                     ? SERVICE_WORKER_OK
                     : SERVICE_WORKER_ERROR_EVENT_WAITUNTIL_REJECTED,
                 base::Time::FromDoubleT(event_dispatch_time));
-  context_->fetch_event_callbacks.Remove(event_finish_id);
+  context_->fetch_event_callbacks.Remove(fetch_event_id);
 }
 
 void ServiceWorkerContextClient::didHandleNotificationClickEvent(
     int request_id,
     blink::WebServiceWorkerEventResult result,
     double event_dispatch_time) {
   Send(new ServiceWorkerHostMsg_NotificationClickEventFinished(
       GetRoutingID(), request_id, result,
       base::Time::FromDoubleT(event_dispatch_time)));
 }
@@ skipping 220 matching lines @@
       WebServiceWorkerImpl::CreateHandle(worker));
 }
 
 void ServiceWorkerContextClient::OnInstallEvent(int request_id) {
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerContextClient::OnInstallEvent");
   proxy_->dispatchInstallEvent(request_id);
 }
 
 void ServiceWorkerContextClient::DispatchFetchEvent(
-    int response_id,
+    int fetch_event_id,
     const ServiceWorkerFetchRequest& request,
     const FetchCallback& callback) {
   blink::WebServiceWorkerRequest webRequest;
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerContextClient::DispatchFetchEvent");
-  int event_finish_id =
-      context_->fetch_event_callbacks.Add(new FetchCallback(callback));
+  context_->fetch_event_callbacks.AddWithID(new FetchCallback(callback),
+                                            fetch_event_id);
 
   webRequest.setURL(blink::WebURL(request.url));
   webRequest.setMethod(blink::WebString::fromUTF8(request.method));
   for (ServiceWorkerHeaderMap::const_iterator it = request.headers.begin();
        it != request.headers.end();
        ++it) {
     webRequest.setHeader(blink::WebString::fromUTF8(it->first),
                          blink::WebString::fromUTF8(it->second));
   }
   if (!request.blob_uuid.empty()) {
     webRequest.setBlob(blink::WebString::fromUTF8(request.blob_uuid),
                        request.blob_size);
   }
   webRequest.setReferrer(
       blink::WebString::fromUTF8(request.referrer.url.spec()),
       request.referrer.policy);
   webRequest.setMode(GetBlinkFetchRequestMode(request.mode));
   webRequest.setIsMainResourceLoad(request.is_main_resource_load);
   webRequest.setCredentialsMode(
       GetBlinkFetchCredentialsMode(request.credentials_mode));
   webRequest.setRedirectMode(GetBlinkFetchRedirectMode(request.redirect_mode));
   webRequest.setRequestContext(
       GetBlinkRequestContext(request.request_context_type));
   webRequest.setFrameType(GetBlinkFrameType(request.frame_type));
   webRequest.setClientId(blink::WebString::fromUTF8(request.client_id));
   webRequest.setIsReload(request.is_reload);
   if (request.fetch_type == ServiceWorkerFetchType::FOREIGN_FETCH) {
-    proxy_->dispatchForeignFetchEvent(response_id, event_finish_id, webRequest);
+    proxy_->dispatchForeignFetchEvent(fetch_event_id, webRequest);
   } else {
-    proxy_->dispatchFetchEvent(response_id, event_finish_id, webRequest);
+    proxy_->dispatchFetchEvent(fetch_event_id, webRequest);
   }
 }
 
 void ServiceWorkerContextClient::OnNotificationClickEvent(
     int request_id,
     const std::string& notification_id,
     const PlatformNotificationData& notification_data,
     int action_index) {
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerContextClient::OnNotificationClickEvent");
@@ skipping 212 matching lines @@
 }
 
 base::WeakPtr<ServiceWorkerContextClient>
 ServiceWorkerContextClient::GetWeakPtr() {
   DCHECK(worker_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(context_);
   return context_->weak_factory.GetWeakPtr();
 }
 
 }  // namespace content