[ServiceWorker] Remove useless ServiceWorkerVersion::DispatchSimpleEvent().

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 261 matching lines @@
                      bool was_handled,
                      base::Time dispatch_event_time);
 
   // Finishes an external request that was started by StartExternalRequest().
   // Returns false if there was an error finishing the request: e.g. the request
   // was not found or the worker already terminated.
   bool FinishExternalRequest(const std::string& request_uuid);
 
   // Creates a callback that is to be used for marking simple events dispatched
   // through the ServiceWorkerEventDispatcher as finished for the |request_id|.
+  // Simple event means those events expecting a response with only a status
+  // code and the dispatch time. See service_worker_event_dispatcher.mojom.
   SimpleEventCallback CreateSimpleEventCallback(int request_id);
 
   // This must be called when the worker is running.
   mojom::ServiceWorkerEventDispatcher* event_dispatcher() {
     DCHECK(event_dispatcher_.is_bound());
     return event_dispatcher_.get();
   }
 
   // Dispatches an event. If dispatching the event fails, all of the error
   // callbacks that were associated with |request_ids| via StartRequest are
   // called.
-  // Use RegisterRequestCallback or RegisterSimpleRequest to register a callback
-  // to receive messages sent back in response to this event before calling this
-  // method.
-  // This must be called when the worker is running.
+  // Use RegisterRequestCallback to register a callback to receive messages sent
+  // back in response to this event before calling this method. This must be
+  // called when the worker is running.
   void DispatchEvent(const std::vector<int>& request_ids,
                      const IPC::Message& message);
 
   // This method registers a callback to receive messages sent back from the
   // service worker in response to |request_id|.
   // ResponseMessage is the type of the IPC message that is used for the
   // response, and its first argument MUST be the request_id.
   // Callback registration should be done once for one request_id.
   template <typename ResponseMessage, typename ResponseCallbackType>
   void RegisterRequestCallback(int request_id,
                                const ResponseCallbackType& callback);
 
-  // You can use this method instead of RegisterRequestCallback when the
-  // response message sent back from the service worker consists of just
-  // a request_id and a blink::WebServiceWorkerEventResult field. The result
-  // field is converted to a ServiceWorkerStatusCode and passed to the error
-  // handler associated with the request_id which is registered by StartRequest.
-  // Additionally if you use this method, FinishRequest will be called before
-  // passing the reply to the callback.
-  // Callback registration should be done once for one request_id.
-  template <typename ResponseMessage>
-  void RegisterSimpleRequest(int request_id);
-
-  // This is a wrapper method equivalent to one RegisterSimpleRequest and one
-  // DispatchEvent. For simple events where the full functionality of
-  // RegisterRequestCallback/DispatchEvent is not needed, this method can be
-  // used instead. The ResponseMessage must consist
-  // of just a request_id and a blink::WebServiceWorkerEventResult field. The
-  // result is converted to a ServiceWorkerStatusCode and passed to the error
-  // handler associated with the request. Additionally this methods calls
-  // FinishRequest before passing the reply to the callback.
-  template <typename ResponseMessage>
-  void DispatchSimpleEvent(int request_id, const IPC::Message& message);
-
   // Adds and removes |provider_host| as a controllee of this ServiceWorker.
   void AddControllee(ServiceWorkerProviderHost* provider_host);
   void RemoveControllee(ServiceWorkerProviderHost* provider_host);
 
   // Returns if it has controllee.
   bool HasControllee() const { return !controllee_map_.empty(); }
   std::map<std::string, ServiceWorkerProviderHost*> controllee_map() {
     return controllee_map_;
   }
 
@@ skipping 304 matching lines @@
 
   // Message handlers.
 
   // This corresponds to the spec's get(id) steps.
   void OnGetClient(int request_id, const std::string& client_uuid);
 
   // This corresponds to the spec's matchAll(options) steps.
   void OnGetClients(int request_id,
                     const ServiceWorkerClientQueryOptions& options);
 
-  // Receiver function of responses of simple events dispatched through chromium
-  // IPCs. This is internally the same with OnSimpleEventFinished and will be
-  // replaced with OnSimpleEventFinished after all of simple events are
-  // dispatched via mojo.
-  void OnSimpleEventResponse(int request_id,
-                             blink::WebServiceWorkerEventResult result,
-                             base::Time dispatch_event_time);
   void OnOpenWindow(int request_id, GURL url);
   void OnOpenWindowFinished(int request_id,
                             ServiceWorkerStatusCode status,
                             const ServiceWorkerClientInfo& client_info);
 
   void OnSetCachedMetadata(const GURL& url, const std::vector<char>& data);
   void OnSetCachedMetadataFinished(int64_t callback_id, int result);
   void OnClearCachedMetadata(const GURL& url);
   void OnClearCachedMetadataFinished(int64_t callback_id, int result);
 
@@ skipping 193 matching lines @@
   // This is the set of features that were used up until installation of this
   // version completed, or used during the lifetime of |this|. The values must
   // be from blink::UseCounter::Feature enum.
   std::set<uint32_t> used_features_;
 
   base::WeakPtrFactory<ServiceWorkerVersion> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerVersion);
 };
 
-template <typename ResponseMessage>
-void ServiceWorkerVersion::DispatchSimpleEvent(int request_id,
-                                               const IPC::Message& message) {
-  RegisterSimpleRequest<ResponseMessage>(request_id);
-  DispatchEvent({request_id}, message);
-}
-
 template <typename ResponseMessage, typename ResponseCallbackType>
 void ServiceWorkerVersion::RegisterRequestCallback(
     int request_id,
     const ResponseCallbackType& callback) {
   PendingRequest* request = pending_requests_.Lookup(request_id);
   DCHECK(request) << "Invalid request id";
   DCHECK(!request->listener) << "Callback was already registered";
   DCHECK(!request->is_dispatched) << "Request already dispatched an IPC event";
   request->listener.reset(
       new EventResponseHandler<ResponseMessage, ResponseCallbackType>(
           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, 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, 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_