Cleanup headless templates and message_dispatcher.h.

headless/lib/browser/headless_devtools_client_impl.h

 // Copyright 2016 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 HEADLESS_LIB_BROWSER_HEADLESS_DEVTOOLS_CLIENT_IMPL_H_
 #define HEADLESS_LIB_BROWSER_HEADLESS_DEVTOOLS_CLIENT_IMPL_H_
 
 #include <unordered_map>
 
 #include "base/memory/weak_ptr.h"
@@ skipping 88 matching lines @@
                                const std::string& json_message) override;
   void AgentHostClosed(content::DevToolsAgentHost* agent_host,
                        bool replaced_with_another_client) override;
 
   // internal::MessageDispatcher implementation:
   void SendMessage(const char* method,
                    std::unique_ptr<base::Value> params,
                    base::Callback<void(const base::Value&)> callback) override;
   void SendMessage(const char* method,
                    std::unique_ptr<base::Value> params,
-                   base::Callback<void()> callback) override;
-  void SendMessage(const char* method,
-                   base::Callback<void(const base::Value&)> callback) override;
-  void SendMessage(const char* method,
-                   base::Callback<void()> callback) override;
+                   base::Closure callback) override;
   void RegisterEventHandler(
       const char* method,
       base::Callback<void(const base::Value&)> callback) override;
 
   bool AttachToHost(content::DevToolsAgentHost* agent_host);
   void ForceAttachToHost(content::DevToolsAgentHost* agent_host);
   void DetachFromHost(content::DevToolsAgentHost* agent_host);
 
  private:
   // Contains a callback with or without a result parameter depending on the
   // message type.
   struct Callback {
     Callback();
     Callback(Callback&& other);
-    explicit Callback(base::Callback<void()> callback);
+    explicit Callback(base::Closure callback);
     explicit Callback(base::Callback<void(const base::Value&)> callback);
     ~Callback();
 
     Callback& operator=(Callback&& other);
 
-    base::Callback<void()> callback;
+    base::Closure callback;
     base::Callback<void(const base::Value&)> callback_with_result;
   };
 
   template <typename CallbackType>
   void FinalizeAndSendMessage(base::DictionaryValue* message,
                               CallbackType callback);
 
   template <typename CallbackType>
   void SendMessageWithParams(const char* method,
                              std::unique_ptr<base::Value> params,
                              CallbackType callback);
 
-  template <typename CallbackType>
-  void SendMessageWithoutParams(const char* method, CallbackType callback);
-
   bool DispatchMessageReply(const base::DictionaryValue& message_dict);
 
   using EventHandler = base::Callback<void(const base::Value&)>;
   using EventHandlerMap = std::unordered_map<std::string, EventHandler>;
 
   bool DispatchEvent(std::unique_ptr<base::Value> owning_message,
                      const base::DictionaryValue& message_dict);
   void DispatchEventTask(std::unique_ptr<base::Value> owning_message,
                          const EventHandler* event_handler,
                          const base::DictionaryValue* result_dict);
@@ skipping 38 matching lines @@
   tracing::ExperimentalDomain tracing_domain_;
   scoped_refptr<base::SingleThreadTaskRunner> browser_main_thread_;
   base::WeakPtrFactory<HeadlessDevToolsClientImpl> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(HeadlessDevToolsClientImpl);
 };
 
 }  // namespace headless
 
 #endif  // HEADLESS_LIB_BROWSER_HEADLESS_DEVTOOLS_CLIENT_IMPL_H_