[Code Health] Remove network_handler::StringResultCallback

Follow up to https://crrev.com/c/2289191.

This callback is only used in tether code as an error callback. This
change moves the callback to TetherDelegate and renames to
StringErrorCallback. Even though this is mostly used in
chromeos/components/tether, it can't be defined there since
chromeos/network can't include code from there.

Bug: 1007660
Change-Id: I882d25857afdcc2b86a9cae4f146032603b6d40f
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2303871Reviewed-by: Kyle Horimoto <khorimoto@chromium.org>
Commit-Queue: Clark DuVall <cduvall@chromium.org>
Cr-Commit-Position: refs/heads/master@{#789263}

chromeos/components/tether/fake_tether_connector.cc

@@ -15,7 +15,7 @@ FakeTetherConnector::~FakeTetherConnector() = default;
 void FakeTetherConnector::ConnectToNetwork(
     const std::string& tether_network_guid,
     base::OnceClosure success_callback,
-    network_handler::StringResultCallback error_callback) {
+    StringErrorCallback error_callback) {
   last_connected_tether_network_guid_ = tether_network_guid;
 
   if (connection_error_name_.empty())

chromeos/components/tether/fake_tether_connector.h

@@ -37,10 +37,9 @@ class FakeTetherConnector : public TetherConnector {
   }
 
   // TetherConnector:
-  void ConnectToNetwork(
-      const std::string& tether_network_guid,
-      base::OnceClosure success_callback,
-      network_handler::StringResultCallback error_callback) override;
+  void ConnectToNetwork(const std::string& tether_network_guid,
+                        base::OnceClosure success_callback,
+                        StringErrorCallback error_callback) override;
   bool CancelConnectionAttempt(const std::string& tether_network_guid) override;
 
  private:

chromeos/components/tether/fake_tether_disconnector.cc

@@ -15,7 +15,7 @@ FakeTetherDisconnector::~FakeTetherDisconnector() = default;
 void FakeTetherDisconnector::DisconnectFromNetwork(
     const std::string& tether_network_guid,
     base::OnceClosure success_callback,
-    network_handler::StringResultCallback error_callback,
+    StringErrorCallback error_callback,
     const TetherSessionCompletionLogger::SessionCompletionReason&
         session_completion_reason) {
   last_disconnected_tether_network_guid_ = tether_network_guid;

chromeos/components/tether/fake_tether_disconnector.h

@@ -39,7 +39,7 @@ class FakeTetherDisconnector : public TetherDisconnector {
   void DisconnectFromNetwork(
       const std::string& tether_network_guid,
       base::OnceClosure success_callback,
-      network_handler::StringResultCallback error_callback,
+      StringErrorCallback error_callback,
       const TetherSessionCompletionLogger::SessionCompletionReason&
           session_completion_reason) override;
 

chromeos/components/tether/fake_wifi_hotspot_disconnector.cc

@@ -15,7 +15,7 @@ FakeWifiHotspotDisconnector::~FakeWifiHotspotDisconnector() = default;
 void FakeWifiHotspotDisconnector::DisconnectFromWifiHotspot(
     const std::string& wifi_network_guid,
     base::OnceClosure success_callback,
-    network_handler::StringResultCallback error_callback) {
+    StringErrorCallback error_callback) {
   last_disconnected_wifi_network_guid_ = wifi_network_guid;
 
   if (disconnection_error_name_.empty())

chromeos/components/tether/fake_wifi_hotspot_disconnector.h

@@ -29,10 +29,9 @@ class FakeWifiHotspotDisconnector : public WifiHotspotDisconnector {
   }
 
   // WifiHotspotDisconnector:
-  void DisconnectFromWifiHotspot(
-      const std::string& wifi_network_guid,
-      base::OnceClosure success_callback,
-      network_handler::StringResultCallback error_callback) override;
+  void DisconnectFromWifiHotspot(const std::string& wifi_network_guid,
+                                 base::OnceClosure success_callback,
+                                 StringErrorCallback error_callback) override;
 
  private:
   std::string last_disconnected_wifi_network_guid_;

chromeos/components/tether/network_connection_handler_tether_delegate.cc

@@ -29,7 +29,7 @@ void OnFailedDisconnectionFromPreviousHost(
 
 NetworkConnectionHandlerTetherDelegate::Callbacks::Callbacks(
     base::OnceClosure success_callback,
-    network_handler::StringResultCallback error_callback)
+    StringErrorCallback error_callback)
     : success_callback(std::move(success_callback)),
       error_callback(std::move(error_callback)) {}
 
@@ -65,7 +65,7 @@ NetworkConnectionHandlerTetherDelegate::
 void NetworkConnectionHandlerTetherDelegate::DisconnectFromNetwork(
     const std::string& tether_network_guid,
     base::OnceClosure success_callback,
-    network_handler::StringResultCallback error_callback) {
+    StringErrorCallback error_callback) {
   int request_num = next_request_num_++;
   request_num_to_callbacks_map_.emplace(
       request_num,
@@ -83,7 +83,7 @@ void NetworkConnectionHandlerTetherDelegate::DisconnectFromNetwork(
 void NetworkConnectionHandlerTetherDelegate::ConnectToNetwork(
     const std::string& tether_network_guid,
     base::OnceClosure success_callback,
-    network_handler::StringResultCallback error_callback) {
+    StringErrorCallback error_callback) {
   if (active_host_->GetActiveHostStatus() ==
       ActiveHost::ActiveHostStatus::CONNECTED) {
     if (active_host_->GetTetherNetworkGuid() == tether_network_guid) {

chromeos/components/tether/network_connection_handler_tether_delegate.h

@@ -10,7 +10,6 @@
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "chromeos/network/network_connection_handler.h"
-#include "chromeos/network/network_handler_callbacks.h"
 
 namespace chromeos {
 
@@ -34,25 +33,23 @@ class NetworkConnectionHandlerTetherDelegate
   ~NetworkConnectionHandlerTetherDelegate() override;
 
   // NetworkConnectionHandler::TetherDelegate:
-  void DisconnectFromNetwork(
-      const std::string& tether_network_guid,
-      base::OnceClosure success_callback,
-      network_handler::StringResultCallback error_callback) override;
-  void ConnectToNetwork(
-      const std::string& tether_network_guid,
-      base::OnceClosure success_callback,
-      network_handler::StringResultCallback error_callback) override;
+  void DisconnectFromNetwork(const std::string& tether_network_guid,
+                             base::OnceClosure success_callback,
+                             StringErrorCallback error_callback) override;
+  void ConnectToNetwork(const std::string& tether_network_guid,
+                        base::OnceClosure success_callback,
+                        StringErrorCallback error_callback) override;
 
  private:
   struct Callbacks {
    public:
     Callbacks(base::OnceClosure success_callback,
-              network_handler::StringResultCallback error_callback);
+              StringErrorCallback error_callback);
     Callbacks(Callbacks&&);
     ~Callbacks();
 
     base::OnceClosure success_callback;
-    network_handler::StringResultCallback error_callback;
+    StringErrorCallback error_callback;
   };
 
   void OnRequestSuccess(int request_num);

chromeos/components/tether/network_connection_handler_tether_delegate_unittest.cc

@@ -28,10 +28,9 @@ const char kSuccessResult[] = "success";
 class DummyTetherConnector : public FakeTetherConnector {
  public:
   // TetherConnector:
-  void ConnectToNetwork(
-      const std::string& tether_network_guid,
-      base::OnceClosure success_callback,
-      network_handler::StringResultCallback error_callback) override {}
+  void ConnectToNetwork(const std::string& tether_network_guid,
+                        base::OnceClosure success_callback,
+                        StringErrorCallback error_callback) override {}
 };
 
 // Does nothing when a disconnection is requested.
@@ -41,7 +40,7 @@ class DummyTetherDisconnector : public FakeTetherDisconnector {
   void DisconnectFromNetwork(
       const std::string& tether_network_guid,
       base::OnceClosure success_callback,
-      network_handler::StringResultCallback error_callback,
+      StringErrorCallback error_callback,
       const TetherSessionCompletionLogger::SessionCompletionReason&
           session_completion_reason) override {}
 };

chromeos/components/tether/tether_connector.h

@@ -20,13 +20,15 @@ namespace tether {
 // the associated Wi-Fi network.
 class TetherConnector {
  public:
+  using StringErrorCallback =
+      NetworkConnectionHandler::TetherDelegate::StringErrorCallback;
+
   TetherConnector() {}
   virtual ~TetherConnector() {}
 
-  virtual void ConnectToNetwork(
-      const std::string& tether_network_guid,
-      base::OnceClosure success_callback,
-      network_handler::StringResultCallback error_callback) = 0;
+  virtual void ConnectToNetwork(const std::string& tether_network_guid,
+                                base::OnceClosure success_callback,
+                                StringErrorCallback error_callback) = 0;
 
   // Returns whether the connection attempt was successfully canceled.
   virtual bool CancelConnectionAttempt(

chromeos/components/tether/tether_connector_impl.cc

@@ -73,7 +73,7 @@ TetherConnectorImpl::~TetherConnectorImpl() {
 void TetherConnectorImpl::ConnectToNetwork(
     const std::string& tether_network_guid,
     base::OnceClosure success_callback,
-    network_handler::StringResultCallback error_callback) {
+    StringErrorCallback error_callback) {
   DCHECK(!tether_network_guid.empty());
   DCHECK(!success_callback.is_null());
   DCHECK(!error_callback.is_null());
@@ -276,8 +276,7 @@ void TetherConnectorImpl::SetConnectionFailed(
   notification_presenter_->RemoveSetupRequiredNotification();
 
   // Save a copy of the callback before resetting it below.
-  network_handler::StringResultCallback error_callback =
-      std::move(error_callback_);
+  StringErrorCallback error_callback = std::move(error_callback_);
 
   std::string failed_connection_device_id = device_id_pending_connection_;
   device_id_pending_connection_.clear();

chromeos/components/tether/tether_connector_impl.h

@@ -61,10 +61,9 @@ class TetherConnectorImpl : public TetherConnector,
       WifiHotspotDisconnector* wifi_hotspot_disconnector);
   ~TetherConnectorImpl() override;
 
-  void ConnectToNetwork(
-      const std::string& tether_network_guid,
-      base::OnceClosure success_callback,
-      network_handler::StringResultCallback error_callback) override;
+  void ConnectToNetwork(const std::string& tether_network_guid,
+                        base::OnceClosure success_callback,
+                        StringErrorCallback error_callback) override;
 
   // Returns whether the connection attempt was successfully canceled.
   bool CancelConnectionAttempt(const std::string& tether_network_guid) override;
@@ -117,7 +116,7 @@ class TetherConnectorImpl : public TetherConnector,
   bool did_send_successful_request_ = false;
   std::string device_id_pending_connection_;
   base::OnceClosure success_callback_;
-  network_handler::StringResultCallback error_callback_;
+  StringErrorCallback error_callback_;
   std::unique_ptr<ConnectTetheringOperation> connect_tethering_operation_;
   base::Time connect_to_host_start_time_;
   base::WeakPtrFactory<TetherConnectorImpl> weak_ptr_factory_{this};

chromeos/components/tether/tether_disconnector.h

@@ -12,7 +12,7 @@
 #include "base/memory/weak_ptr.h"
 #include "chromeos/components/tether/disconnect_tethering_operation.h"
 #include "chromeos/components/tether/tether_session_completion_logger.h"
-#include "chromeos/network/network_handler_callbacks.h"
+#include "chromeos/network/network_connection_handler.h"
 
 namespace chromeos {
 
@@ -21,6 +21,9 @@ namespace tether {
 // Disconnects from an active Tether connection.
 class TetherDisconnector {
  public:
+  using StringErrorCallback =
+      NetworkConnectionHandler::TetherDelegate::StringErrorCallback;
+
   TetherDisconnector() {}
   virtual ~TetherDisconnector() {}
 
@@ -31,7 +34,7 @@ class TetherDisconnector {
   virtual void DisconnectFromNetwork(
       const std::string& tether_network_guid,
       base::OnceClosure success_callback,
-      network_handler::StringResultCallback error_callback,
+      StringErrorCallback error_callback,
       const TetherSessionCompletionLogger::SessionCompletionReason&
           session_completion_reason) = 0;
 

chromeos/components/tether/tether_disconnector_impl.cc

@@ -40,7 +40,7 @@ TetherDisconnectorImpl::~TetherDisconnectorImpl() = default;
 void TetherDisconnectorImpl::DisconnectFromNetwork(
     const std::string& tether_network_guid,
     base::OnceClosure success_callback,
-    network_handler::StringResultCallback error_callback,
+    StringErrorCallback error_callback,
     const TetherSessionCompletionLogger::SessionCompletionReason&
         session_completion_reason) {
   DCHECK(!tether_network_guid.empty());
@@ -96,7 +96,7 @@ void TetherDisconnectorImpl::DisconnectActiveWifiConnection(
     const std::string& tether_network_guid,
     const std::string& wifi_network_guid,
     base::OnceClosure success_callback,
-    network_handler::StringResultCallback error_callback) {
+    StringErrorCallback error_callback) {
   // First, disconnect the active host so that the user gets visual indication
   // that the disconnection is in progress as quickly as possible.
   active_host_->SetActiveHostDisconnected();

chromeos/components/tether/tether_disconnector_impl.h

@@ -14,7 +14,6 @@
 #include "base/memory/weak_ptr.h"
 #include "chromeos/components/tether/tether_disconnector.h"
 #include "chromeos/components/tether/tether_session_completion_logger.h"
-#include "chromeos/network/network_handler_callbacks.h"
 
 namespace chromeos {
 
@@ -40,18 +39,17 @@ class TetherDisconnectorImpl : public TetherDisconnector {
   void DisconnectFromNetwork(
       const std::string& tether_network_guid,
       base::OnceClosure success_callback,
-      network_handler::StringResultCallback error_callback,
+      StringErrorCallback error_callback,
       const TetherSessionCompletionLogger::SessionCompletionReason&
           session_completion_reason) override;
 
  private:
   friend class TetherDisconnectorImplTest;
 
-  void DisconnectActiveWifiConnection(
-      const std::string& tether_network_guid,
-      const std::string& wifi_network_guid,
-      base::OnceClosure success_callback,
-      network_handler::StringResultCallback error_callback);
+  void DisconnectActiveWifiConnection(const std::string& tether_network_guid,
+                                      const std::string& wifi_network_guid,
+                                      base::OnceClosure success_callback,
+                                      StringErrorCallback error_callback);
 
   ActiveHost* active_host_;
   WifiHotspotDisconnector* wifi_hotspot_disconnector_;

chromeos/components/tether/wifi_hotspot_disconnector.h

@@ -7,7 +7,7 @@
 
 #include "base/callback.h"
 #include "base/macros.h"
-#include "chromeos/network/network_handler_callbacks.h"
+#include "chromeos/network/network_connection_handler.h"
 
 namespace chromeos {
 
@@ -16,6 +16,9 @@ namespace tether {
 // Disconnects from Wi-Fi hotspots provided by Tether hosts.
 class WifiHotspotDisconnector {
  public:
+  using StringErrorCallback =
+      NetworkConnectionHandler::TetherDelegate::StringErrorCallback;
+
   WifiHotspotDisconnector() {}
   virtual ~WifiHotspotDisconnector() {}
 
@@ -25,7 +28,7 @@ class WifiHotspotDisconnector {
   virtual void DisconnectFromWifiHotspot(
       const std::string& wifi_network_guid,
       base::OnceClosure success_callback,
-      network_handler::StringResultCallback error_callback) = 0;
+      StringErrorCallback error_callback) = 0;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(WifiHotspotDisconnector);

chromeos/components/tether/wifi_hotspot_disconnector_impl.cc

@@ -51,7 +51,7 @@ WifiHotspotDisconnectorImpl::~WifiHotspotDisconnectorImpl() = default;
 void WifiHotspotDisconnectorImpl::DisconnectFromWifiHotspot(
     const std::string& wifi_network_guid,
     base::OnceClosure success_callback,
-    network_handler::StringResultCallback error_callback) {
+    StringErrorCallback error_callback) {
   const NetworkState* wifi_network_state =
       network_state_handler_->GetNetworkStateFromGuid(wifi_network_guid);
   if (!wifi_network_state) {
@@ -98,7 +98,7 @@ void WifiHotspotDisconnectorImpl::OnSuccessfulWifiDisconnect(
     const std::string& wifi_network_guid,
     const std::string& wifi_network_path,
     base::OnceClosure success_callback,
-    network_handler::StringResultCallback error_callback) {
+    StringErrorCallback error_callback) {
   PA_LOG(VERBOSE) << "Successfully disconnected from Wi-Fi network with GUID "
                   << wifi_network_guid << ".";
   CleanUpAfterWifiDisconnection(wifi_network_path, std::move(success_callback),
@@ -108,7 +108,7 @@ void WifiHotspotDisconnectorImpl::OnSuccessfulWifiDisconnect(
 void WifiHotspotDisconnectorImpl::OnFailedWifiDisconnect(
     const std::string& wifi_network_guid,
     const std::string& wifi_network_path,
-    network_handler::StringResultCallback error_callback,
+    StringErrorCallback error_callback,
     const std::string& error_name,
     std::unique_ptr<base::DictionaryValue> error_data) {
   PA_LOG(ERROR) << "Failed to disconnect from Wi-Fi network with GUID "
@@ -120,7 +120,7 @@ void WifiHotspotDisconnectorImpl::OnFailedWifiDisconnect(
 void WifiHotspotDisconnectorImpl::CleanUpAfterWifiDisconnection(
     const std::string& wifi_network_path,
     base::OnceClosure success_callback,
-    network_handler::StringResultCallback error_callback) {
+    StringErrorCallback error_callback) {
   network_configuration_remover_->RemoveNetworkConfigurationByPath(
       wifi_network_path);
   pref_service_->ClearPref(prefs::kDisconnectingWifiNetworkPath);

chromeos/components/tether/wifi_hotspot_disconnector_impl.h

@@ -35,27 +35,24 @@ class WifiHotspotDisconnectorImpl : public WifiHotspotDisconnector {
   ~WifiHotspotDisconnectorImpl() override;
 
   // WifiHotspotDisconnector:
-  void DisconnectFromWifiHotspot(
-      const std::string& wifi_network_guid,
-      base::OnceClosure success_callback,
-      network_handler::StringResultCallback error_callback) override;
+  void DisconnectFromWifiHotspot(const std::string& wifi_network_guid,
+                                 base::OnceClosure success_callback,
+                                 StringErrorCallback error_callback) override;
 
  private:
-  void OnSuccessfulWifiDisconnect(
-      const std::string& wifi_network_guid,
-      const std::string& wifi_network_path,
-      base::OnceClosure success_callback,
-      network_handler::StringResultCallback error_callback);
+  void OnSuccessfulWifiDisconnect(const std::string& wifi_network_guid,
+                                  const std::string& wifi_network_path,
+                                  base::OnceClosure success_callback,
+                                  StringErrorCallback error_callback);
   void OnFailedWifiDisconnect(
       const std::string& wifi_network_guid,
       const std::string& wifi_network_path,
-      network_handler::StringResultCallback error_callback,
+      StringErrorCallback error_callback,
       const std::string& error_name,
       std::unique_ptr<base::DictionaryValue> error_data);
-  void CleanUpAfterWifiDisconnection(
-      const std::string& wifi_network_path,
-      base::OnceClosure success_callback,
-      network_handler::StringResultCallback error_callback);
+  void CleanUpAfterWifiDisconnection(const std::string& wifi_network_path,
+                                     base::OnceClosure success_callback,
+                                     StringErrorCallback error_callback);
 
   NetworkConnectionHandler* network_connection_handler_;
   NetworkStateHandler* network_state_handler_;

chromeos/network/network_connect_unittest.cc

@@ -67,17 +67,15 @@ class FakeTetherDelegate : public NetworkConnectionHandler::TetherDelegate {
   }
 
   // NetworkConnectionHandler::TetherDelegate:
-  void ConnectToNetwork(
-      const std::string& tether_network_guid,
-      base::OnceClosure success_callback,
-      network_handler::StringResultCallback error_callback) override {
+  void ConnectToNetwork(const std::string& tether_network_guid,
+                        base::OnceClosure success_callback,
+                        StringErrorCallback error_callback) override {
     last_connected_tether_network_guid_ = tether_network_guid;
     std::move(success_callback).Run();
   }
-  void DisconnectFromNetwork(
-      const std::string& tether_network_guid,
-      base::OnceClosure success_callback,
-      network_handler::StringResultCallback error_callback) override {}
+  void DisconnectFromNetwork(const std::string& tether_network_guid,
+                             base::OnceClosure success_callback,
+                             StringErrorCallback error_callback) override {}
 
  private:
   std::string last_connected_tether_network_guid_;

chromeos/network/network_connection_handler.h

@@ -110,21 +110,22 @@ class COMPONENT_EXPORT(CHROMEOS_NETWORK) NetworkConnectionHandler {
 
   class COMPONENT_EXPORT(CHROMEOS_NETWORK) TetherDelegate {
    public:
+    using StringErrorCallback =
+        base::OnceCallback<void(const std::string& string_result)>;
+
     // Connects to the Tether network with GUID |tether_network_guid|. On
     // success, invokes |success_callback|, and on failure, invokes
     // |error_callback|, passing the relevant error code declared above.
-    virtual void ConnectToNetwork(
-        const std::string& tether_network_guid,
-        base::OnceClosure success_callback,
-        network_handler::StringResultCallback error_callback) = 0;
+    virtual void ConnectToNetwork(const std::string& tether_network_guid,
+                                  base::OnceClosure success_callback,
+                                  StringErrorCallback error_callback) = 0;
 
     // Disconnects from the Tether network with GUID |tether_network_guid|. On
     // success, invokes |success_callback|, and on failure, invokes
     // |error_callback|, passing the relevant error code declared above.
-    virtual void DisconnectFromNetwork(
-        const std::string& tether_network_guid,
-        base::OnceClosure success_callback,
-        network_handler::StringResultCallback error_callback) = 0;
+    virtual void DisconnectFromNetwork(const std::string& tether_network_guid,
+                                       base::OnceClosure success_callback,
+                                       StringErrorCallback error_callback) = 0;
 
    protected:
     virtual ~TetherDelegate() {}

chromeos/network/network_connection_handler_impl_unittest.cc

@@ -98,20 +98,18 @@ class FakeTetherDelegate : public NetworkConnectionHandler::TetherDelegate {
     return last_delegate_function_type_;
   }
 
-  void ConnectToNetwork(
-      const std::string& service_path,
-      base::OnceClosure success_callback,
-      network_handler::StringResultCallback error_callback) override {
+  void ConnectToNetwork(const std::string& service_path,
+                        base::OnceClosure success_callback,
+                        StringErrorCallback error_callback) override {
     last_delegate_function_type_ = DelegateFunctionType::CONNECT;
     last_service_path_ = service_path;
     last_success_callback_ = std::move(success_callback);
     last_error_callback_ = std::move(error_callback);
   }
 
-  void DisconnectFromNetwork(
-      const std::string& service_path,
-      base::OnceClosure success_callback,
-      network_handler::StringResultCallback error_callback) override {
+  void DisconnectFromNetwork(const std::string& service_path,
+                             base::OnceClosure success_callback,
+                             StringErrorCallback error_callback) override {
     last_delegate_function_type_ = DelegateFunctionType::DISCONNECT;
     last_service_path_ = service_path;
     last_success_callback_ = std::move(success_callback);
@@ -122,14 +120,12 @@ class FakeTetherDelegate : public NetworkConnectionHandler::TetherDelegate {
 
   base::OnceClosure& last_success_callback() { return last_success_callback_; }
 
-  network_handler::StringResultCallback& last_error_callback() {
-    return last_error_callback_;
-  }
+  StringErrorCallback& last_error_callback() { return last_error_callback_; }
 
  private:
   std::string last_service_path_;
   base::OnceClosure last_success_callback_;
-  network_handler::StringResultCallback last_error_callback_;
+  StringErrorCallback last_error_callback_;
   DelegateFunctionType last_delegate_function_type_;
 };
 

chromeos/network/network_device_handler_unittest.cc

@@ -79,11 +79,6 @@ class NetworkDeviceHandlerTest : public testing::Test {
                       base::Unretained(this));
   }
 
-  network_handler::StringResultCallback GetStringSuccessCallback() {
-    return base::Bind(&NetworkDeviceHandlerTest::StringSuccessCallback,
-                      base::Unretained(this));
-  }
-
   network_handler::ErrorCallback GetErrorCallback() {
     return base::BindOnce(&NetworkDeviceHandlerTest::ErrorCallback,
                           base::Unretained(this));

chromeos/network/network_handler_callbacks.h

@@ -42,9 +42,6 @@ using ErrorCallback =
     base::OnceCallback<void(const std::string& error_name,
                             std::unique_ptr<base::DictionaryValue> error_data)>;
 
-using StringResultCallback =
-    base::OnceCallback<void(const std::string& string_result)>;
-
 using ServiceResultCallback =
     base::OnceCallback<void(const std::string& service_path,
                             const std::string& guid)>;