Use fetch_event_id (fetchEventID in blink) for FetchEvent

content/browser/service_worker/embedded_worker_test_helper.cc

 // 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 "content/browser/service_worker/embedded_worker_test_helper.h"
 
 #include <map>
 #include <string>
 #include <utility>
 
@@ skipping 146 matching lines @@
         std::move(request));
   }
 
   MockFetchEventDispatcher(
       const base::WeakPtr<EmbeddedWorkerTestHelper>& helper,
       int thread_id)
       : helper_(helper), thread_id_(thread_id) {}
 
   ~MockFetchEventDispatcher() override {}
 
-  void DispatchFetchEvent(int response_id,
+  void DispatchFetchEvent(int fetch_event_id,
                           const ServiceWorkerFetchRequest& request,
                           const DispatchFetchEventCallback& callback) override {
     if (!helper_)
       return;
-    helper_->OnFetchEventStub(thread_id_, response_id, request, callback);
+    helper_->OnFetchEventStub(thread_id_, fetch_event_id, request, callback);
   }
 
  private:
   base::WeakPtr<EmbeddedWorkerTestHelper> helper_;
   const int thread_id_;
 };
 
 EmbeddedWorkerTestHelper::EmbeddedWorkerTestHelper(
     const base::FilePath& user_data_directory)
     : browser_context_(new TestBrowserContext),
@@ skipping 145 matching lines @@
   // The installing worker may have been doomed and terminated.
   if (!registry()->GetWorker(embedded_worker_id))
     return;
   SimulateSend(new ServiceWorkerHostMsg_InstallEventFinished(
       embedded_worker_id, request_id,
       blink::WebServiceWorkerEventResultCompleted, true, base::Time::Now()));
 }
 
 void EmbeddedWorkerTestHelper::OnFetchEvent(
     int embedded_worker_id,
-    int response_id,
+    int fetch_event_id,
     const ServiceWorkerFetchRequest& request,
     const FetchCallback& callback) {
   SimulateSend(new ServiceWorkerHostMsg_FetchEventResponse(
-      embedded_worker_id, response_id,
+      embedded_worker_id, fetch_event_id,
       SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE,
       ServiceWorkerResponse(
           GURL(), 200, "OK", blink::WebServiceWorkerResponseTypeDefault,
           ServiceWorkerHeaderMap(), std::string(), 0, GURL(),
           blink::WebServiceWorkerResponseErrorUnknown, base::Time(),
           false /* is_in_cache_storage */,
           std::string() /* cache_storage_cache_name */,
           ServiceWorkerHeaderList() /* cors_exposed_header_names */),
       base::Time::Now()));
   callback.Run(SERVICE_WORKER_OK, base::Time::Now());
@@ skipping 136 matching lines @@
 
 void EmbeddedWorkerTestHelper::OnInstallEventStub(int request_id) {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&EmbeddedWorkerTestHelper::OnInstallEvent, AsWeakPtr(),
                  current_embedded_worker_id_, request_id));
 }
 
 void EmbeddedWorkerTestHelper::OnFetchEventStub(
     int thread_id,
-    int response_id,
+    int fetch_event_id,
     const ServiceWorkerFetchRequest& request,
     const FetchCallback& callback) {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&EmbeddedWorkerTestHelper::OnFetchEvent, AsWeakPtr(),
-                 thread_id_embedded_worker_id_map_[thread_id], response_id,
+                 thread_id_embedded_worker_id_map_[thread_id], fetch_event_id,
                  request, callback));
 }
 
 void EmbeddedWorkerTestHelper::OnPushEventStub(
     int request_id,
     const PushEventPayload& payload) {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&EmbeddedWorkerTestHelper::OnPushEvent, AsWeakPtr(),
                             current_embedded_worker_id_, request_id, payload));
 }
@@ skipping 41 matching lines @@
   registry->Bind(mojo::GetProxy(&interfaces));
 
   std::unique_ptr<shell::InterfaceProvider> remote_interfaces(
       new shell::InterfaceProvider);
   remote_interfaces->Bind(std::move(interfaces));
   rph->SetRemoteInterfaces(std::move(remote_interfaces));
   return registry;
 }
 
 }  // namespace content