Avoid using the method pointer to Callback::Run in ServiceWorkerVersion

content/browser/service_worker/service_worker_version.h

 // 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.
 
 #ifndef CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_VERSION_H_
 #define CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_VERSION_H_
 
 #include <stdint.h>
 
 #include <functional>
@@ skipping 553 matching lines @@
                           std::greater<RequestInfo>>;
   using WebStatusCallback =
       base::Callback<void(int, blink::WebServiceWorkerEventResult)>;
 
   // EmbeddedWorkerInstance Listener implementation which calls a callback
   // on receiving a particular IPC message. ResponseMessage is the type of
   // the IPC message to listen for, while CallbackType should be a callback
   // with same arguments as the IPC message.
   // Additionally only calls the callback for messages with a specific request
   // id, which must be the first argument of the IPC message.
-  template <typename ResponseMessage, typename CallbackType>
-  class EventResponseHandler : public EmbeddedWorkerInstance::Listener {
+  template <typename ResponseMessage,
+            typename CallbackType,
+            typename Signature = typename CallbackType::RunType>
+  class EventResponseHandler;
+
+  template <typename ResponseMessage, typename CallbackType, typename... Args>
+  class EventResponseHandler<ResponseMessage, CallbackType, void(Args...)>
+      : public EmbeddedWorkerInstance::Listener {
    public:
     EventResponseHandler(const base::WeakPtr<EmbeddedWorkerInstance>& worker,
                          int request_id,
                          const CallbackType& callback)
         : worker_(worker), request_id_(request_id), callback_(callback) {
       worker_->AddListener(this);
     }
     ~EventResponseHandler() override {
       if (worker_)
         worker_->RemoveListener(this);
     }
     bool OnMessageReceived(const IPC::Message& message) override;
 
    private:
+    void RunCallback(Args... args) {
+      callback_.Run(std::forward<Args>(args)...);
+    }
+
     base::WeakPtr<EmbeddedWorkerInstance> const worker_;
     const int request_id_;
     const CallbackType callback_;
   };
 
   // The timeout timer interval.
   static const int kTimeoutTimerDelaySeconds;
   // Timeout for an installed worker to start.
   static const int kStartInstalledWorkerTimeoutSeconds;
   // Timeout for a new worker to start.
@@ skipping 288 matching lines @@
           embedded_worker()->AsWeakPtr(), request_id, callback));
 }
 
 template <typename ResponseMessage>
 void ServiceWorkerVersion::RegisterSimpleRequest(int request_id) {
   RegisterRequestCallback<ResponseMessage>(
       request_id,
       base::Bind(&ServiceWorkerVersion::OnSimpleEventResponse, this));
 }
 
-template <typename ResponseMessage, typename CallbackType>
-bool ServiceWorkerVersion::EventResponseHandler<ResponseMessage, CallbackType>::
-    OnMessageReceived(const IPC::Message& message) {
+template <typename ResponseMessage, typename CallbackType, typename... Args>
+bool ServiceWorkerVersion::EventResponseHandler<
+    ResponseMessage,
+    CallbackType,
+    void(Args...)>::OnMessageReceived(const IPC::Message& message) {
   if (message.type() != ResponseMessage::ID)
     return false;
   int received_request_id;
   bool result = base::PickleIterator(message).ReadInt(&received_request_id);
   if (!result || received_request_id != request_id_)
     return false;
 
   CallbackType protect(callback_);
   // Essentially same code as what IPC_MESSAGE_FORWARD expands to.
   void* param = nullptr;
-  if (!ResponseMessage::Dispatch(&message, &callback_, this, param,
-                                 &CallbackType::Run))
+  if (!ResponseMessage::Dispatch(&message, this, this, param,
+                                 &EventResponseHandler::RunCallback))
     message.set_dispatch_error();
 
   // At this point |this| can have been deleted, so don't do anything other
   // than returning.
 
   return true;
 }
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_VERSION_H_