[Code health] Convert DispatchCallback to OnceCallback

Bug: 1152274
Change-Id: I68caf298c2009923b450619cd6ebb0ad4b94870d
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2615203Reviewed-by: Andrey Kosyakov <caseq@chromium.org>
Reviewed-by: Robert Sesek <rsesek@chromium.org>
Commit-Queue: Leonard Grey <lgrey@chromium.org>
Cr-Commit-Position: refs/heads/master@{#841583}

chrome/browser/devtools/devtools_embedder_message_dispatcher.cc

@@ -65,7 +65,7 @@ struct ParamTuple {
 
   template <typename H, typename... As>
   void Apply(const H& handler, As... args) {
-    handler.Run(args...);
+    handler.Run(std::forward<As>(args)...);
   }
 };
 
@@ -78,16 +78,16 @@ struct ParamTuple<T, Ts...> {
 
   template <typename H, typename... As>
   void Apply(const H& handler, As... args) {
-    tail.template Apply<H, As..., T>(handler, args..., head);
+    tail.template Apply<H, As..., T>(handler, std::forward<As>(args)..., head);
   }
 
   typename StorageTraits<T>::StorageType head;
   ParamTuple<Ts...> tail;
 };
 
-template<typename... As>
-bool ParseAndHandle(const base::Callback<void(As...)>& handler,
-                    const DispatchCallback& callback,
+template <typename... As>
+bool ParseAndHandle(const base::RepeatingCallback<void(As...)>& handler,
+                    DispatchCallback callback,
                     const base::ListValue& list) {
   ParamTuple<As...> tuple;
   if (!tuple.Parse(list, list.begin()))
@@ -96,15 +96,15 @@ bool ParseAndHandle(const base::Callback<void(As...)>& handler,
   return true;
 }
 
-template<typename... As>
+template <typename... As>
 bool ParseAndHandleWithCallback(
-    const base::Callback<void(const DispatchCallback&, As...)>& handler,
-    const DispatchCallback& callback,
+    const base::RepeatingCallback<void(DispatchCallback, As...)>& handler,
+    DispatchCallback callback,
     const base::ListValue& list) {
   ParamTuple<As...> tuple;
   if (!tuple.Parse(list, list.begin()))
     return false;
-  tuple.Apply(handler, callback);
+  tuple.Apply(handler, std::move(callback));
   return true;
 }
 
@@ -120,38 +120,38 @@ bool ParseAndHandleWithCallback(
  */
 class DispatcherImpl : public DevToolsEmbedderMessageDispatcher {
  public:
-  ~DispatcherImpl() override {}
+  ~DispatcherImpl() override = default;
 
-  bool Dispatch(const DispatchCallback& callback,
+  bool Dispatch(DispatchCallback callback,
                 const std::string& method,
                 const base::ListValue* params) override {
     auto it = handlers_.find(method);
-    return it != handlers_.end() && it->second.Run(callback, *params);
+    return it != handlers_.end() &&
+           it->second.Run(std::move(callback), *params);
   }
 
   template<typename... As>
   void RegisterHandler(const std::string& method,
                        void (Delegate::*handler)(As...),
                        Delegate* delegate) {
-    handlers_[method] = base::Bind(&ParseAndHandle<As...>,
-                                   base::Bind(handler,
-                                              base::Unretained(delegate)));
+    handlers_[method] = base::BindRepeating(
+        &ParseAndHandle<As...>,
+        base::BindRepeating(handler, base::Unretained(delegate)));
   }
 
-  template<typename... As>
-  void RegisterHandlerWithCallback(
-      const std::string& method,
-      void (Delegate::*handler)(const DispatchCallback&, As...),
-      Delegate* delegate) {
-    handlers_[method] = base::Bind(&ParseAndHandleWithCallback<As...>,
-                                   base::Bind(handler,
-                                              base::Unretained(delegate)));
+  template <typename... As>
+  void RegisterHandlerWithCallback(const std::string& method,
+                                   void (Delegate::*handler)(DispatchCallback,
+                                                             As...),
+                                   Delegate* delegate) {
+    handlers_[method] = base::BindRepeating(
+        &ParseAndHandleWithCallback<As...>,
+        base::BindRepeating(handler, base::Unretained(delegate)));
   }
 
-
  private:
-  using Handler = base::Callback<bool(const DispatchCallback&,
-                                      const base::ListValue&)>;
+  using Handler =
+      base::RepeatingCallback<bool(DispatchCallback, const base::ListValue&)>;
   using HandlerMap = std::map<std::string, Handler>;
   HandlerMap handlers_;
 };

chrome/browser/devtools/devtools_embedder_message_dispatcher.h

@@ -29,9 +29,9 @@ class DevToolsEmbedderMessageDispatcher {
  public:
   class Delegate {
    public:
-    using DispatchCallback = base::Callback<void(const base::Value*)>;
+    using DispatchCallback = base::OnceCallback<void(const base::Value*)>;
 
-    virtual ~Delegate() {}
+    virtual ~Delegate() = default;
 
     virtual void ActivateWindow() = 0;
     virtual void CloseWindow() = 0;
@@ -39,8 +39,7 @@ class DevToolsEmbedderMessageDispatcher {
     virtual void SetInspectedPageBounds(const gfx::Rect& rect) = 0;
     virtual void InspectElementCompleted() = 0;
     virtual void InspectedURLChanged(const std::string& url) = 0;
-    virtual void SetIsDocked(const DispatchCallback& callback,
-                             bool is_docked) = 0;
+    virtual void SetIsDocked(DispatchCallback callback, bool is_docked) = 0;
     virtual void OpenInNewTab(const std::string& url) = 0;
     virtual void ShowItemInFolder(const std::string& file_system_path) = 0;
     virtual void SaveToFile(const std::string& url,
@@ -57,7 +56,7 @@ class DevToolsEmbedderMessageDispatcher {
                            const std::string& file_system_path,
                            const std::string& excluded_folders) = 0;
     virtual void StopIndexing(int index_request_id) = 0;
-    virtual void LoadNetworkResource(const DispatchCallback& callback,
+    virtual void LoadNetworkResource(DispatchCallback callback,
                                      const std::string& url,
                                      const std::string& headers,
                                      int stream_id) = 0;
@@ -82,7 +81,7 @@ class DevToolsEmbedderMessageDispatcher {
     virtual void OpenRemotePage(const std::string& browser_id,
                                 const std::string& url) = 0;
     virtual void OpenNodeFrontend() = 0;
-    virtual void GetPreferences(const DispatchCallback& callback) = 0;
+    virtual void GetPreferences(DispatchCallback callback) = 0;
     virtual void SetPreference(const std::string& name,
                                const std::string& value) = 0;
     virtual void RemovePreference(const std::string& name) = 0;
@@ -95,25 +94,25 @@ class DevToolsEmbedderMessageDispatcher {
     virtual void RecordPerformanceHistogram(const std::string& name,
                                             double duration) = 0;
     virtual void RecordUserMetricsAction(const std::string& name) = 0;
-    virtual void SendJsonRequest(const DispatchCallback& callback,
+    virtual void SendJsonRequest(DispatchCallback callback,
                                  const std::string& browser_id,
                                  const std::string& url) = 0;
-    virtual void Reattach(const DispatchCallback& callback) = 0;
+    virtual void Reattach(DispatchCallback callback) = 0;
     virtual void ReadyForTest() = 0;
     virtual void ConnectionReady() = 0;
     virtual void SetOpenNewWindowForPopups(bool value) = 0;
     virtual void RegisterExtensionsAPI(const std::string& origin,
                                        const std::string& script) = 0;
-    virtual void ShowSurvey(const DispatchCallback& callback,
+    virtual void ShowSurvey(DispatchCallback callback,
                             const std::string& trigger) = 0;
-    virtual void CanShowSurvey(const DispatchCallback& callback,
+    virtual void CanShowSurvey(DispatchCallback callback,
                                const std::string& trigger) = 0;
   };
 
   using DispatchCallback = Delegate::DispatchCallback;
 
-  virtual ~DevToolsEmbedderMessageDispatcher() {}
-  virtual bool Dispatch(const DispatchCallback& callback,
+  virtual ~DevToolsEmbedderMessageDispatcher() = default;
+  virtual bool Dispatch(DispatchCallback callback,
                         const std::string& method,
                         const base::ListValue* params) = 0;
 

chrome/browser/devtools/devtools_ui_bindings.cc

@@ -456,12 +456,12 @@ class DevToolsUIBindings::NetworkResourceLoader
                      const network::ResourceRequest& resource_request,
                      const net::NetworkTrafficAnnotationTag& traffic_annotation,
                      URLLoaderFactoryHolder url_loader_factory,
-                     const DevToolsUIBindings::DispatchCallback& callback,
+                     DevToolsUIBindings::DispatchCallback callback,
                      base::TimeDelta retry_delay = base::TimeDelta()) {
     auto resource_loader =
         std::make_unique<DevToolsUIBindings::NetworkResourceLoader>(
             stream_id, bindings, resource_request, traffic_annotation,
-            std::move(url_loader_factory), callback, retry_delay);
+            std::move(url_loader_factory), std::move(callback), retry_delay);
     bindings->loaders_.insert(std::move(resource_loader));
   }
 
@@ -471,7 +471,7 @@ class DevToolsUIBindings::NetworkResourceLoader
       const network::ResourceRequest& resource_request,
       const net::NetworkTrafficAnnotationTag& traffic_annotation,
       URLLoaderFactoryHolder url_loader_factory,
-      const DispatchCallback& callback,
+      DispatchCallback callback,
       base::TimeDelta delay)
       : stream_id_(stream_id),
         bindings_(bindings),
@@ -481,7 +481,7 @@ class DevToolsUIBindings::NetworkResourceLoader
             std::make_unique<network::ResourceRequest>(resource_request),
             traffic_annotation)),
         url_loader_factory_(std::move(url_loader_factory)),
-        callback_(callback),
+        callback_(std::move(callback)),
         retry_delay_(delay) {
     loader_->SetOnResponseStartedCallback(base::BindOnce(
         &NetworkResourceLoader::OnResponseStarted, base::Unretained(this)));
@@ -538,11 +538,11 @@ class DevToolsUIBindings::NetworkResourceLoader
                    << delay << "." << std::endl;
       NetworkResourceLoader::Create(
           stream_id_, bindings_, resource_request_, traffic_annotation_,
-          std::move(url_loader_factory_), callback_, delay);
+          std::move(url_loader_factory_), std::move(callback_), delay);
     } else {
       auto response = BuildObjectForResponse(response_headers_.get(), success,
                                              loader_->NetError());
-      callback_.Run(response.get());
+      std::move(callback_).Run(response.get());
     }
     bindings_->loaders_.erase(bindings_->loaders_.find(this));
   }
@@ -823,10 +823,10 @@ void DevToolsUIBindings::SetInspectedPageBounds(const gfx::Rect& rect) {
   delegate_->SetInspectedPageBounds(rect);
 }
 
-void DevToolsUIBindings::SetIsDocked(const DispatchCallback& callback,
+void DevToolsUIBindings::SetIsDocked(DispatchCallback callback,
                                      bool dock_requested) {
   delegate_->SetIsDocked(dock_requested);
-  callback.Run(nullptr);
+  std::move(callback).Run(nullptr);
 }
 
 void DevToolsUIBindings::InspectElementCompleted() {
@@ -851,7 +851,7 @@ void DevToolsUIBindings::InspectedURLChanged(const std::string& url) {
                  base::StringPrintf(kTitleFormat, simplified_url.c_str())));
 }
 
-void DevToolsUIBindings::LoadNetworkResource(const DispatchCallback& callback,
+void DevToolsUIBindings::LoadNetworkResource(DispatchCallback callback,
                                              const std::string& url,
                                              const std::string& headers,
                                              int stream_id) {
@@ -860,7 +860,7 @@ void DevToolsUIBindings::LoadNetworkResource(const DispatchCallback& callback,
     base::DictionaryValue response;
     response.SetInteger("statusCode", 404);
     response.SetBoolean("urlValid", false);
-    callback.Run(&response);
+    std::move(callback).Run(&response);
     return;
   }
   // Create traffic annotation tag.
@@ -941,7 +941,7 @@ void DevToolsUIBindings::LoadNetworkResource(const DispatchCallback& callback,
       base::DictionaryValue response;
       response.SetBoolean("schemeSupported", false);
       response.SetInteger("statusCode", 403);
-      callback.Run(&response);
+      std::move(callback).Run(&response);
       return;
     }
   } else {
@@ -950,9 +950,9 @@ void DevToolsUIBindings::LoadNetworkResource(const DispatchCallback& callback,
     url_loader_factory = partition->GetURLLoaderFactoryForBrowserProcess();
   }
 
-  NetworkResourceLoader::Create(stream_id, this, resource_request,
-                                traffic_annotation,
-                                std::move(url_loader_factory), callback);
+  NetworkResourceLoader::Create(
+      stream_id, this, resource_request, traffic_annotation,
+      std::move(url_loader_factory), std::move(callback));
 }
 
 void DevToolsUIBindings::OpenInNewTab(const std::string& url) {
@@ -1230,10 +1230,10 @@ void DevToolsUIBindings::OpenNodeFrontend() {
   delegate_->OpenNodeFrontend();
 }
 
-void DevToolsUIBindings::GetPreferences(const DispatchCallback& callback) {
+void DevToolsUIBindings::GetPreferences(DispatchCallback callback) {
   const DictionaryValue* prefs =
       profile_->GetPrefs()->GetDictionary(prefs::kDevToolsPreferences);
-  callback.Run(prefs);
+  std::move(callback).Run(prefs);
 }
 
 void DevToolsUIBindings::SetPreference(const std::string& name,
@@ -1255,12 +1255,12 @@ void DevToolsUIBindings::ClearPreferences() {
   update.Get()->Clear();
 }
 
-void DevToolsUIBindings::Reattach(const DispatchCallback& callback) {
+void DevToolsUIBindings::Reattach(DispatchCallback callback) {
   if (agent_host_.get()) {
     agent_host_->DetachClient(this);
     InnerAttach();
   }
-  callback.Run(nullptr);
+  std::move(callback).Run(nullptr);
 }
 
 void DevToolsUIBindings::ReadyForTest() {
@@ -1342,28 +1342,28 @@ void DevToolsUIBindings::RecordUserMetricsAction(const std::string& name) {
   base::RecordComputedAction(name);
 }
 
-void DevToolsUIBindings::SendJsonRequest(const DispatchCallback& callback,
+void DevToolsUIBindings::SendJsonRequest(DispatchCallback callback,
                                          const std::string& browser_id,
                                          const std::string& url) {
   if (!android_bridge_) {
-    callback.Run(nullptr);
+    std::move(callback).Run(nullptr);
     return;
   }
-  android_bridge_->SendJsonRequest(browser_id, url,
-      base::Bind(&DevToolsUIBindings::JsonReceived,
-                 weak_factory_.GetWeakPtr(),
-                 callback));
+  android_bridge_->SendJsonRequest(
+      browser_id, url,
+      base::BindOnce(&DevToolsUIBindings::JsonReceived,
+                     weak_factory_.GetWeakPtr(), std::move(callback)));
 }
 
-void DevToolsUIBindings::JsonReceived(const DispatchCallback& callback,
+void DevToolsUIBindings::JsonReceived(DispatchCallback callback,
                                       int result,
                                       const std::string& message) {
   if (result != net::OK) {
-    callback.Run(nullptr);
+    std::move(callback).Run(nullptr);
     return;
   }
   base::Value message_value(message);
-  callback.Run(&message_value);
+  std::move(callback).Run(&message_value);
 }
 
 void DevToolsUIBindings::DeviceCountChanged(int count) {
@@ -1533,32 +1533,34 @@ void DevToolsUIBindings::RegisterExtensionsAPI(const std::string& origin,
 
 namespace {
 
-void ShowSurveyCallback(const DevToolsUIBindings::DispatchCallback& callback,
+void ShowSurveyCallback(DevToolsUIBindings::DispatchCallback callback,
                         bool survey_shown) {
   base::DictionaryValue response;
   response.SetBoolean("surveyShown", survey_shown);
-  callback.Run(&response);
+  std::move(callback).Run(&response);
 }
 
 }  // namespace
 
-void DevToolsUIBindings::ShowSurvey(const DispatchCallback& callback,
+void DevToolsUIBindings::ShowSurvey(DispatchCallback callback,
                                     const std::string& trigger) {
   HatsService* hats_service =
       HatsServiceFactory::GetForProfile(profile_->GetOriginalProfile(), true);
+  base::RepeatingCallback<void(const base::Value*)> on_survey =
+      base::AdaptCallbackForRepeating(std::move(callback));
   hats_service->LaunchSurvey(
-      trigger, base::BindOnce(ShowSurveyCallback, callback, true),
-      base::BindOnce(ShowSurveyCallback, callback, false));
+      trigger, base::BindOnce(ShowSurveyCallback, on_survey, true),
+      base::BindOnce(ShowSurveyCallback, on_survey, false));
 }
 
-void DevToolsUIBindings::CanShowSurvey(const DispatchCallback& callback,
+void DevToolsUIBindings::CanShowSurvey(DispatchCallback callback,
                                        const std::string& trigger) {
   HatsService* hats_service =
       HatsServiceFactory::GetForProfile(profile_->GetOriginalProfile(), true);
   bool can_show = hats_service->CanShowSurvey(trigger);
   base::DictionaryValue response;
   response.SetBoolean("canShowSurvey", can_show);
-  callback.Run(&response);
+  std::move(callback).Run(&response);
 }
 
 void DevToolsUIBindings::SetDelegate(Delegate* delegate) {

chrome/browser/devtools/devtools_ui_bindings.h

@@ -107,11 +107,11 @@ class DevToolsUIBindings : public DevToolsEmbedderMessageDispatcher::Delegate,
   void SetInspectedPageBounds(const gfx::Rect& rect) override;
   void InspectElementCompleted() override;
   void InspectedURLChanged(const std::string& url) override;
-  void LoadNetworkResource(const DispatchCallback& callback,
+  void LoadNetworkResource(DispatchCallback callback,
                            const std::string& url,
                            const std::string& headers,
                            int stream_id) override;
-  void SetIsDocked(const DispatchCallback& callback, bool is_docked) override;
+  void SetIsDocked(DispatchCallback callback, bool is_docked) override;
   void OpenInNewTab(const std::string& url) override;
   void ShowItemInFolder(const std::string& file_system_path) override;
   void SaveToFile(const std::string& url,
@@ -157,23 +157,23 @@ class DevToolsUIBindings : public DevToolsEmbedderMessageDispatcher::Delegate,
   void RecordPerformanceHistogram(const std::string& name,
                                   double duration) override;
   void RecordUserMetricsAction(const std::string& name) override;
-  void SendJsonRequest(const DispatchCallback& callback,
+  void SendJsonRequest(DispatchCallback callback,
                        const std::string& browser_id,
                        const std::string& url) override;
-  void GetPreferences(const DispatchCallback& callback) override;
+  void GetPreferences(DispatchCallback callback) override;
   void SetPreference(const std::string& name,
                      const std::string& value) override;
   void RemovePreference(const std::string& name) override;
   void ClearPreferences() override;
-  void Reattach(const DispatchCallback& callback) override;
+  void Reattach(DispatchCallback callback) override;
   void ReadyForTest() override;
   void ConnectionReady() override;
   void SetOpenNewWindowForPopups(bool value) override;
   void RegisterExtensionsAPI(const std::string& origin,
                              const std::string& script) override;
-  void ShowSurvey(const DispatchCallback& callback,
+  void ShowSurvey(DispatchCallback callback,
                   const std::string& trigger) override;
-  void CanShowSurvey(const DispatchCallback& callback,
+  void CanShowSurvey(DispatchCallback callback,
                      const std::string& trigger) override;
 
   void EnableRemoteDeviceCounter(bool enable);
@@ -194,7 +194,7 @@ class DevToolsUIBindings : public DevToolsEmbedderMessageDispatcher::Delegate,
   void DidNavigateMainFrame();
   void FrontendLoaded();
 
-  void JsonReceived(const DispatchCallback& callback,
+  void JsonReceived(DispatchCallback callback,
                     int result,
                     const std::string& message);
   void DevicesDiscoveryConfigUpdated();