Convert from base::Bind and base::Callback to Once/Repeating in media

This CL converts base::Callback (and corresponding calls to base::Bind)
to either base::OnceCallback or base::RepeatingCallback in
chrome/browser/media. In general a base::OnceCallback is preferred since
that's a stronger API guarantee, so that's been done where safe.

Bug: 1007635
Change-Id: Ie3113c61db1ae43ce2e31c262f023d714f42dfc0
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2321003
Commit-Queue: Will Cassella <cassew@google.com>
Reviewed-by: Frank Liberato <liberato@chromium.org>
Cr-Commit-Position: refs/heads/master@{#792380}

chrome/browser/media/cdm_storage_id.cc

@@ -108,8 +108,8 @@ void ComputeStorageId(const std::vector<uint8_t>& profile_salt,
       mojo::WrapCallbackWithDefaultInvokeIfNotRun(std::move(callback),
                                                   std::vector<uint8_t>());
   chromeos::SystemSaltGetter::Get()->GetSystemSalt(
-      base::Bind(&ComputeAndReturnStorageId, profile_salt, origin,
-                 base::Passed(&scoped_callback)));
+      base::BindOnce(&ComputeAndReturnStorageId, profile_salt, origin,
+                 std::move(scoped_callback));
 
 #else
 #error Storage ID enabled but not implemented for this platform.

chrome/browser/media/media_engagement_browsertest.cc

@@ -69,11 +69,11 @@ class WasRecentlyAudibleWatcher {
   // Waits until WasRecentlyAudible is true.
   void WaitForWasRecentlyAudible() {
     if (!audible_helper_->WasRecentlyAudible()) {
-      timer_.Start(
-          FROM_HERE, base::TimeDelta::FromMicroseconds(100),
-          base::Bind(&WasRecentlyAudibleWatcher::TestWasRecentlyAudible,
-                     base::Unretained(this)));
-      run_loop_.reset(new base::RunLoop());
+      timer_.Start(FROM_HERE, base::TimeDelta::FromMicroseconds(100),
+                   base::BindRepeating(
+                       &WasRecentlyAudibleWatcher::TestWasRecentlyAudible,
+                       base::Unretained(this)));
+      run_loop_ = std::make_unique<base::RunLoop>();
       run_loop_->Run();
     }
   }

chrome/browser/media/media_engagement_service.cc

@@ -142,8 +142,8 @@ void MediaEngagementService::ClearDataBetweenTime(
       ->ClearSettingsForOneTypeWithPredicate(
           ContentSettingsType::MEDIA_ENGAGEMENT, base::Time(),
           base::Time::Max(),
-          base::Bind(&MediaEngagementTimeFilterAdapter, this, delete_begin,
-                     delete_end));
+          base::BindRepeating(&MediaEngagementTimeFilterAdapter, this,
+                              delete_begin, delete_end));
 }
 
 void MediaEngagementService::Shutdown() {

chrome/browser/media/output_protection_impl.cc

@@ -42,9 +42,9 @@ void OutputProtectionImpl::QueryStatus(QueryStatusCallback callback) {
   DVLOG(2) << __func__;
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
-  GetProxy()->QueryStatus(base::Bind(&OutputProtectionImpl::OnQueryStatusResult,
-                                     weak_factory_.GetWeakPtr(),
-                                     base::Passed(&callback)));
+  GetProxy()->QueryStatus(
+      base::BindOnce(&OutputProtectionImpl::OnQueryStatusResult,
+                     weak_factory_.GetWeakPtr(), base::Passed(&callback)));
 }
 
 void OutputProtectionImpl::EnableProtection(uint32_t desired_protection_mask,
@@ -54,8 +54,8 @@ void OutputProtectionImpl::EnableProtection(uint32_t desired_protection_mask,
 
   GetProxy()->EnableProtection(
       desired_protection_mask,
-      base::Bind(&OutputProtectionImpl::OnEnableProtectionResult,
-                 weak_factory_.GetWeakPtr(), base::Passed(&callback)));
+      base::BindOnce(&OutputProtectionImpl::OnEnableProtectionResult,
+                     weak_factory_.GetWeakPtr(), base::Passed(&callback)));
 }
 
 void OutputProtectionImpl::OnQueryStatusResult(QueryStatusCallback callback,

chrome/browser/media/output_protection_proxy.cc

@@ -4,6 +4,8 @@
 
 #include "chrome/browser/media/output_protection_proxy.h"
 
+#include <utility>
+
 #include "base/bind.h"
 #include "build/build_config.h"
 #include "chrome/browser/media/webrtc/media_capture_devices_dispatcher.h"
@@ -38,35 +40,36 @@ OutputProtectionProxy::~OutputProtectionProxy() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 }
 
-void OutputProtectionProxy::QueryStatus(const QueryStatusCallback& callback) {
+void OutputProtectionProxy::QueryStatus(QueryStatusCallback callback) {
   DVLOG(1) << __func__;
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
 #if defined(OS_CHROMEOS)
   output_protection_delegate_.QueryStatus(
       base::BindOnce(&OutputProtectionProxy::ProcessQueryStatusResult,
-                     weak_ptr_factory_.GetWeakPtr(), callback));
+                     weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
 #else  // defined(OS_CHROMEOS)
-  ProcessQueryStatusResult(callback, true, 0, 0);
+  ProcessQueryStatusResult(std::move(callback), true, 0, 0);
 #endif  // defined(OS_CHROMEOS)
 }
 
 void OutputProtectionProxy::EnableProtection(
     uint32_t desired_method_mask,
-    const EnableProtectionCallback& callback) {
+    EnableProtectionCallback callback) {
   DVLOG(1) << __func__;
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
 #if defined(OS_CHROMEOS)
-  output_protection_delegate_.SetProtection(desired_method_mask, callback);
+  output_protection_delegate_.SetProtection(desired_method_mask,
+                                            std::move(callback));
 #else   // defined(OS_CHROMEOS)
   NOTIMPLEMENTED();
-  callback.Run(false);
+  std::move(callback).Run(false);
 #endif  // defined(OS_CHROMEOS)
 }
 
 void OutputProtectionProxy::ProcessQueryStatusResult(
-    const QueryStatusCallback& callback,
+    QueryStatusCallback callback,
     bool success,
     uint32_t link_mask,
     uint32_t protection_mask) {
@@ -76,7 +79,7 @@ void OutputProtectionProxy::ProcessQueryStatusResult(
   // TODO(xjz): Investigate whether this check should be removed.
   if (!GetRenderFrameView(render_process_id_, render_frame_id_)) {
     LOG(WARNING) << "RenderFrameHost is not alive.";
-    callback.Run(false, 0, 0);
+    std::move(callback).Run(false, 0, 0);
     return;
   }
 
@@ -91,5 +94,5 @@ void OutputProtectionProxy::ProcessQueryStatusResult(
       new_link_mask |= display::DISPLAY_CONNECTION_TYPE_NETWORK;
   }
 
-  callback.Run(success, new_link_mask, protection_mask);
+  std::move(callback).Run(success, new_link_mask, protection_mask);
 }

chrome/browser/media/output_protection_proxy.h

@@ -26,23 +26,23 @@
 // All methods except constructor should be invoked in UI thread.
 class OutputProtectionProxy {
  public:
-  typedef base::Callback<void(bool /* success */,
+  using QueryStatusCallback =
+      base::OnceCallback<void(bool /* success */,
                               uint32_t /* link_mask */,
-                              uint32_t /* protection_mask*/)>
-      QueryStatusCallback;
-  typedef base::Callback<void(bool /* success */)> EnableProtectionCallback;
+                              uint32_t /* protection_mask*/)>;
+  using EnableProtectionCallback = base::OnceCallback<void(bool /* success */)>;
 
   OutputProtectionProxy(int render_process_id, int render_frame_id);
   ~OutputProtectionProxy();
 
-  void QueryStatus(const QueryStatusCallback& callback);
+  void QueryStatus(QueryStatusCallback callback);
   void EnableProtection(uint32_t desired_method_mask,
-                        const EnableProtectionCallback& callback);
+                        EnableProtectionCallback callback);
 
  private:
   // Callbacks for QueryStatus(). It also checks the network link and adds it
   // to the |link_mask|.
-  void ProcessQueryStatusResult(const QueryStatusCallback& callback,
+  void ProcessQueryStatusResult(QueryStatusCallback callback,
                                 bool success,
                                 uint32_t link_mask,
                                 uint32_t protection_mask);

chrome/browser/media/router/discovery/mdns/cast_media_sink_service_impl_unittest.cc

@@ -606,14 +606,16 @@ TEST_F(CastMediaSinkServiceImplTest, TestOnSinkAddedOrUpdated) {
   // Channel 1, 2 opened.
   EXPECT_CALL(*mock_cast_socket_service_, OpenSocketInternal(ip_endpoint1, _))
       .WillOnce(WithArgs<1>(
-          [&socket1](
-              const base::Callback<void(cast_channel::CastSocket * socket)>&
-                  callback) { callback.Run(&socket1); }));
+          [&socket1](const base::RepeatingCallback<void(
+                         cast_channel::CastSocket * socket)>& callback) {
+            callback.Run(&socket1);
+          }));
   EXPECT_CALL(*mock_cast_socket_service_, OpenSocketInternal(ip_endpoint2, _))
       .WillOnce(WithArgs<1>(
-          [&socket2](
-              const base::Callback<void(cast_channel::CastSocket * socket)>&
-                  callback) { callback.Run(&socket2); }));
+          [&socket2](const base::RepeatingCallback<void(
+                         cast_channel::CastSocket * socket)>& callback) {
+            callback.Run(&socket2);
+          }));
 
   // Add DIAL sinks to |dial_media_sink_service_|, which in turn notifies
   // |media_sink_service_impl_| via the Observer interface.
@@ -651,10 +653,11 @@ TEST_F(CastMediaSinkServiceImplTest,
 
   EXPECT_CALL(*mock_cast_socket_service_, OpenSocketInternal(ip_endpoint1, _))
       .Times(1)
-      .WillOnce(WithArgs<1>(Invoke(
-          [&socket1](
-              const base::Callback<void(cast_channel::CastSocket * socket)>&
-                  callback) { std::move(callback).Run(&socket1); })));
+      .WillOnce(WithArgs<1>(
+          Invoke([&socket1](const base::RepeatingCallback<void(
+                                cast_channel::CastSocket * socket)>& callback) {
+            std::move(callback).Run(&socket1);
+          })));
   media_sink_service_impl_.OnSinkAddedOrUpdated(dial_sink1);
 
   // We don't trigger retries, thus each iteration will only increment the
@@ -664,9 +667,10 @@ TEST_F(CastMediaSinkServiceImplTest,
     EXPECT_CALL(*mock_cast_socket_service_, OpenSocketInternal(ip_endpoint1, _))
         .Times(1)
         .WillOnce(WithArgs<1>(Invoke(
-            [&socket1](
-                const base::Callback<void(cast_channel::CastSocket * socket)>&
-                    callback) { std::move(callback).Run(&socket1); })));
+            [&socket1](const base::RepeatingCallback<void(
+                           cast_channel::CastSocket * socket)>& callback) {
+              std::move(callback).Run(&socket1);
+            })));
     media_sink_service_impl_.OnSinkAddedOrUpdated(dial_sink1);
   }
 

chrome/browser/media/router/issue_manager.cc

@@ -61,11 +61,11 @@ void IssueManager::AddIssue(const IssueInfo& issue_info) {
   }
 
   Issue issue(issue_info);
-  std::unique_ptr<base::CancelableClosure> cancelable_dismiss_cb;
+  std::unique_ptr<base::CancelableOnceClosure> cancelable_dismiss_cb;
   base::TimeDelta timeout = GetAutoDismissTimeout(issue_info);
   if (!timeout.is_zero()) {
     cancelable_dismiss_cb =
-        std::make_unique<base::CancelableClosure>(base::Bind(
+        std::make_unique<base::CancelableOnceClosure>(base::BindOnce(
             &IssueManager::ClearIssue, base::Unretained(this), issue.id()));
     task_runner_->PostDelayedTask(FROM_HERE, cancelable_dismiss_cb->callback(),
                                   timeout);
@@ -108,7 +108,7 @@ void IssueManager::UnregisterObserver(IssuesObserver* observer) {
 
 IssueManager::Entry::Entry(
     const Issue& issue,
-    std::unique_ptr<base::CancelableClosure> cancelable_dismiss_callback)
+    std::unique_ptr<base::CancelableOnceClosure> cancelable_dismiss_callback)
     : issue(issue),
       cancelable_dismiss_callback(std::move(cancelable_dismiss_callback)) {}
 

chrome/browser/media/router/issue_manager.h

@@ -69,13 +69,14 @@ class IssueManager {
   // will require adding support for delayed tasks to CancelableTaskTracker.
   struct Entry {
     Entry(const Issue& issue,
-          std::unique_ptr<base::CancelableClosure> cancelable_dismiss_callback);
+          std::unique_ptr<base::CancelableOnceClosure>
+              cancelable_dismiss_callback);
     ~Entry();
 
     Issue issue;
 
     // Set to non-null if |issue| can be auto-dismissed.
-    std::unique_ptr<base::CancelableClosure> cancelable_dismiss_callback;
+    std::unique_ptr<base::CancelableOnceClosure> cancelable_dismiss_callback;
 
    private:
     DISALLOW_COPY_AND_ASSIGN(Entry);

chrome/browser/media/router/media_router_base.cc

@@ -62,7 +62,7 @@ MediaRouterBase::AddPresentationConnectionStateChangedCallback(
   auto& callbacks = presentation_connection_state_callbacks_[route_id];
   if (!callbacks) {
     callbacks = std::make_unique<PresentationConnectionStateChangedCallbacks>();
-    callbacks->set_removal_callback(base::Bind(
+    callbacks->set_removal_callback(base::BindRepeating(
         &MediaRouterBase::OnPresentationConnectionStateCallbackRemoved,
         base::Unretained(this), route_id));
   }