ServiceWorkerVersion: remove unused parameter in DispatchInstallEvent

content/browser/service_worker/service_worker_version.cc

 // Copyright 2013 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/service_worker_version.h"
 
 #include "base/command_line.h"
 #include "base/memory/ref_counted.h"
 #include "base/stl_util.h"
 #include "base/strings/string16.h"
@@ skipping 445 matching lines @@
       embedded_worker_->message_port_message_filter();
   std::vector<int> new_routing_ids;
   filter->UpdateMessagePortsWithNewRoutes(sent_message_ports, &new_routing_ids);
   ServiceWorkerStatusCode status =
       embedded_worker_->SendMessage(ServiceWorkerMsg_MessageToWorker(
           message, sent_message_ports, new_routing_ids));
   RunSoon(base::Bind(callback, status));
 }
 
 void ServiceWorkerVersion::DispatchInstallEvent(
-    int active_version_id,
     const StatusCallback& callback) {
   DCHECK_EQ(INSTALLING, status()) << status();
 
   if (running_status() != RUNNING) {
     // Schedule calling this method after starting the worker.
     StartWorker(
         base::Bind(&RunTaskAfterStartWorker,
                    weak_factory_.GetWeakPtr(),
                    callback,
                    base::Bind(&self::DispatchInstallEventAfterStartWorker,
                               weak_factory_.GetWeakPtr(),
-                              active_version_id,
                               callback)));
   } else {
-    DispatchInstallEventAfterStartWorker(active_version_id, callback);
+    DispatchInstallEventAfterStartWorker(callback);
   }
 }
 
 void ServiceWorkerVersion::DispatchActivateEvent(
     const StatusCallback& callback) {
   DCHECK_EQ(ACTIVATING, status()) << status();
 
   if (running_status() != RUNNING) {
     // Schedule calling this method after starting the worker.
     StartWorker(
@@ skipping 445 matching lines @@
   return handled;
 }
 
 void ServiceWorkerVersion::OnStartMessageSent(
     ServiceWorkerStatusCode status) {
   if (status != SERVICE_WORKER_OK)
     RunCallbacks(this, &start_callbacks_, status);
 }
 
 void ServiceWorkerVersion::DispatchInstallEventAfterStartWorker(
-    int active_version_id,
     const StatusCallback& callback) {
   DCHECK_EQ(RUNNING, running_status())
       << "Worker stopped too soon after it was started.";
 
   int request_id = install_callbacks_.Add(new StatusCallback(callback));
   ServiceWorkerStatusCode status = embedded_worker_->SendMessage(
-      ServiceWorkerMsg_InstallEvent(request_id, active_version_id));
+      ServiceWorkerMsg_InstallEvent(request_id));
   if (status != SERVICE_WORKER_OK) {
     install_callbacks_.Remove(request_id);
     RunSoon(base::Bind(callback, status));
   }
 }
 
 void ServiceWorkerVersion::DispatchActivateEventAfterStartWorker(
     const StatusCallback& callback) {
   DCHECK_EQ(RUNNING, running_status())
       << "Worker stopped too soon after it was started.";
@@ skipping 536 matching lines @@
     int request_id) {
   callbacks->Remove(request_id);
   if (is_doomed_) {
     // The stop should be already scheduled, but try to stop immediately, in
     // order to release worker resources soon.
     StopWorkerIfIdle();
   }
 }
 
 }  // namespace content