Convert vpn callbacks to OnceCallbacks in content/public/

The success and failure callbacks are only run once, so they can be
OnceCallbacks.

Introduces SuccessOnceCallback and FailureOnceCallback in
VpnService to avoid blowing the change up to the whole
VpnService API.

TBR=dcheng

Bug: 1007763
Change-Id: I668083ab94ecbb9a3c06e3ba8f60d72d493570f6
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1960891
Commit-Queue: danakj <danakj@chromium.org>
Reviewed-by: Avi Drissman <avi@chromium.org>
Reviewed-by: Maksim Ivanov <emaxx@chromium.org>
Cr-Commit-Position: refs/heads/master@{#723585}

PRESUBMIT.py

@@ -370,7 +370,6 @@ _NOT_CONVERTED_TO_MODERN_BIND_AND_CALLBACK = '|'.join((
   '^components/webdata_services/',
   '^components/wifi/',
   '^content/browser/',
-  '^content/public/',
   '^device/bluetooth/',
   '^extensions/',
   '^google_apis/dive/',

content/public/browser/vpn_service_proxy.h

@@ -18,9 +18,9 @@ class PepperVpnProviderResourceHostProxy;
 // All the methods below can only be called on the UI thread.
 class CONTENT_EXPORT VpnServiceProxy {
  public:
-  using SuccessCallback = base::Closure;
+  using SuccessCallback = base::OnceClosure;
   using FailureCallback =
-      base::Callback<void(const std::string& error_name,
+      base::OnceCallback<void(const std::string& error_name,
                               const std::string& error_message)>;
 
   virtual ~VpnServiceProxy() {}
@@ -30,16 +30,16 @@ class CONTENT_EXPORT VpnServiceProxy {
   virtual void Bind(const std::string& host_id,
                     const std::string& configuration_id,
                     const std::string& configuration_name,
-                    const SuccessCallback& success,
-                    const FailureCallback& failure,
+                    SuccessCallback success,
+                    FailureCallback failure,
                     std::unique_ptr<PepperVpnProviderResourceHostProxy>
                         pepper_vpn_provider_proxy) = 0;
 
   // Sends an IP packet to the VpnService.
   virtual void SendPacket(const std::string& host_id,
                           const std::vector<char>& data,
-                          const SuccessCallback& success,
-                          const FailureCallback& failure) = 0;
+                          SuccessCallback success,
+                          FailureCallback failure) = 0;
 };
 
 }  // namespace content

extensions/browser/api/vpn_provider/vpn_service.cc

@@ -163,14 +163,14 @@ class VpnService::VpnServiceProxyImpl : public content::VpnServiceProxy {
   void Bind(const std::string& extension_id,
             const std::string& configuration_id,
             const std::string& configuration_name,
-            const SuccessCallback& success,
-            const FailureCallback& failure,
+            SuccessOnceCallback success,
+            FailureOnceCallback failure,
             std::unique_ptr<content::PepperVpnProviderResourceHostProxy>
                 pepper_vpn_provider_proxy) override;
   void SendPacket(const std::string& extension_id,
                   const std::vector<char>& data,
-                  const SuccessCallback& success,
-                  const FailureCallback& failure) override;
+                  SuccessOnceCallback success,
+                  FailureOnceCallback failure) override;
 
  private:
   base::WeakPtr<VpnService> vpn_service_;
@@ -186,8 +186,8 @@ void VpnService::VpnServiceProxyImpl::Bind(
     const std::string& extension_id,
     const std::string& configuration_id,
     const std::string& configuration_name,
-    const SuccessCallback& success,
-    const FailureCallback& failure,
+    SuccessOnceCallback success,
+    FailureOnceCallback failure,
     std::unique_ptr<content::PepperVpnProviderResourceHostProxy>
         pepper_vpn_provider_proxy) {
   if (!vpn_service_) {
@@ -196,20 +196,22 @@ void VpnService::VpnServiceProxyImpl::Bind(
   }
 
   vpn_service_->Bind(extension_id, configuration_id, configuration_name,
-                     success, failure, std::move(pepper_vpn_provider_proxy));
+                     std::move(success), std::move(failure),
+                     std::move(pepper_vpn_provider_proxy));
 }
 
 void VpnService::VpnServiceProxyImpl::SendPacket(
     const std::string& extension_id,
     const std::vector<char>& data,
-    const SuccessCallback& success,
-    const FailureCallback& failure) {
+    SuccessOnceCallback success,
+    FailureOnceCallback failure) {
   if (!vpn_service_) {
     NOTREACHED();
     return;
   }
 
-  vpn_service_->SendPacket(extension_id, data, success, failure);
+  vpn_service_->SendPacket(extension_id, data, std::move(success),
+                           std::move(failure));
 }
 
 VpnService::VpnService(
@@ -452,20 +454,21 @@ void VpnService::SetParameters(const std::string& extension_id,
 
 void VpnService::SendPacket(const std::string& extension_id,
                             const std::vector<char>& data,
-                            const SuccessCallback& success,
-                            const FailureCallback& failure) {
+                            SuccessOnceCallback success,
+                            FailureOnceCallback failure) {
   if (!DoesActiveConfigurationExistAndIsAccessAuthorized(extension_id)) {
-    failure.Run(std::string(), std::string("Unauthorized access."));
+    std::move(failure).Run(std::string(), std::string("Unauthorized access."));
     return;
   }
 
   if (data.empty()) {
-    failure.Run(std::string(), std::string("Can't send an empty packet."));
+    std::move(failure).Run(std::string(),
+                           std::string("Can't send an empty packet."));
     return;
   }
 
-  shill_client_->SendPacket(active_configuration_->object_path(), data, success,
-                            failure);
+  shill_client_->SendPacket(active_configuration_->object_path(), data,
+                            std::move(success), std::move(failure));
 }
 
 void VpnService::NotifyConnectionStateChanged(const std::string& extension_id,
@@ -628,14 +631,14 @@ void VpnService::Bind(
     const std::string& extension_id,
     const std::string& configuration_id,
     const std::string& configuration_name,
-    const SuccessCallback& success,
-    const FailureCallback& failure,
+    SuccessOnceCallback success,
+    FailureOnceCallback failure,
     std::unique_ptr<content::PepperVpnProviderResourceHostProxy>
         pepper_vpn_provider_proxy) {
   // The ID is the configuration name for now. This may change in the future.
   const std::string key = GetKey(extension_id, configuration_id);
   if (!base::Contains(key_to_configuration_map_, key)) {
-    failure.Run(std::string(),
+    std::move(failure).Run(std::string(),
                            std::string("Unauthorized access. "
                                        "The configuration does not exist."));
     return;
@@ -643,14 +646,16 @@ void VpnService::Bind(
 
   VpnConfiguration* configuration = key_to_configuration_map_[key].get();
   if (active_configuration_ != configuration) {
-    failure.Run(std::string(), std::string("Unauthorized access. "
+    std::move(failure).Run(std::string(),
+                           std::string("Unauthorized access. "
                                        "The configuration is not active."));
     return;
   }
 
   if (configuration->extension_id() != extension_id ||
       configuration->configuration_name() != configuration_name) {
-    failure.Run(std::string(),
+    std::move(failure).Run(
+        std::string(),
         std::string("Unauthorized access. "
                     "Configuration name or extension ID mismatch."));
     return;
@@ -658,14 +663,14 @@ void VpnService::Bind(
 
   const std::string service_path = configuration->service_path();
   if (service_path.empty()) {
-    failure.Run(std::string(), std::string("Pending create."));
+    std::move(failure).Run(std::string(), std::string("Pending create."));
     return;
   }
 
   // Connection authorized. All packets will be routed through the Pepper API.
   configuration->set_pepper_proxy(std::move(pepper_vpn_provider_proxy));
 
-  success.Run();
+  std::move(success).Run();
 }
 
 std::unique_ptr<content::VpnServiceProxy> VpnService::GetVpnServiceProxy() {

extensions/browser/api/vpn_provider/vpn_service.h

@@ -55,12 +55,17 @@ class VpnService : public KeyedService,
                    public NetworkStateHandlerObserver,
                    public extensions::ExtensionRegistryObserver {
  public:
-  using SuccessCallback = base::Closure;
+  using SuccessOnceCallback = base::OnceClosure;
   using StringCallback = base::Callback<void(const std::string& result)>;
-  using FailureCallback =
-      base::Callback<void(const std::string& error_name,
+  using FailureOnceCallback =
+      base::OnceCallback<void(const std::string& error_name,
                               const std::string& error_message)>;
 
+  // TODO(crbug.com/1007786): Delete these and rename the OnceCallback versions
+  // to replace these once they are no longer used.
+  using SuccessCallback = base::Callback<SuccessOnceCallback::RunType>;
+  using FailureCallback = base::Callback<FailureOnceCallback::RunType>;
+
   VpnService(content::BrowserContext* browser_context,
              const std::string& userid_hash,
              extensions::ExtensionRegistry* extension_registry,
@@ -125,8 +130,8 @@ class VpnService : public KeyedService,
   // Calls |success| or |failure| based on the outcome.
   void SendPacket(const std::string& extension_id,
                   const std::vector<char>& data,
-                  const SuccessCallback& success,
-                  const FailureCallback& failure);
+                  SuccessOnceCallback success,
+                  FailureOnceCallback failure);
 
   // Notifies connection state |state| to the active VPN configuration after
   // verifying that it belongs to the extension with id |extension_id|.
@@ -229,8 +234,8 @@ class VpnService : public KeyedService,
   void Bind(const std::string& extension_id,
             const std::string& configuration_id,
             const std::string& configuration_name,
-            const SuccessCallback& success,
-            const FailureCallback& failure,
+            SuccessOnceCallback success,
+            FailureOnceCallback failure,
             std::unique_ptr<content::PepperVpnProviderResourceHostProxy>
                 pepper_vpn_provider_proxy);