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

This reverts commit f4723a7e.

Reason for revert: cdm_storage_id.cc:112:45: error: expected ')'
https://ci.chromium.org/p/chrome/builders/ci/chromeos-kevin-chrome/8936

Original change's description:
> 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}

TBR=liberato@chromium.org,cassew@google.com

Change-Id: Ie1ee4eb9a5a81ef346e38e21fff6535ef29e2790
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: 1007635
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2324498Reviewed-by: Ben Pastene <bpastene@chromium.org>
Commit-Queue: Ben Pastene <bpastene@chromium.org>
Cr-Commit-Position: refs/heads/master@{#792425}

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::BindOnce(&ComputeAndReturnStorageId, profile_salt, origin,
-                 std::move(scoped_callback));
+      base::Bind(&ComputeAndReturnStorageId, profile_salt, origin,
+                 base::Passed(&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::BindRepeating(
-                       &WasRecentlyAudibleWatcher::TestWasRecentlyAudible,
-                       base::Unretained(this)));
-      run_loop_ = std::make_unique<base::RunLoop>();
+      timer_.Start(
+          FROM_HERE, base::TimeDelta::FromMicroseconds(100),
+          base::Bind(&WasRecentlyAudibleWatcher::TestWasRecentlyAudible,
+                     base::Unretained(this)));
+      run_loop_.reset(new 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::BindRepeating(&MediaEngagementTimeFilterAdapter, this,
-                              delete_begin, delete_end));
+          base::Bind(&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::BindOnce(&OutputProtectionImpl::OnQueryStatusResult,
-                     weak_factory_.GetWeakPtr(), base::Passed(&callback)));
+  GetProxy()->QueryStatus(base::Bind(&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::BindOnce(&OutputProtectionImpl::OnEnableProtectionResult,
-                     weak_factory_.GetWeakPtr(), base::Passed(&callback)));
+      base::Bind(&OutputProtectionImpl::OnEnableProtectionResult,
+                 weak_factory_.GetWeakPtr(), base::Passed(&callback)));
 }
 
 void OutputProtectionImpl::OnQueryStatusResult(QueryStatusCallback callback,

chrome/browser/media/output_protection_proxy.cc

@@ -4,8 +4,6 @@
 
 #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"
@@ -40,36 +38,35 @@ OutputProtectionProxy::~OutputProtectionProxy() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 }
 
-void OutputProtectionProxy::QueryStatus(QueryStatusCallback callback) {
+void OutputProtectionProxy::QueryStatus(const 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(), std::move(callback)));
+                     weak_ptr_factory_.GetWeakPtr(), callback));
 #else  // defined(OS_CHROMEOS)
-  ProcessQueryStatusResult(std::move(callback), true, 0, 0);
+  ProcessQueryStatusResult(callback, true, 0, 0);
 #endif  // defined(OS_CHROMEOS)
 }
 
 void OutputProtectionProxy::EnableProtection(
     uint32_t desired_method_mask,
-    EnableProtectionCallback callback) {
+    const EnableProtectionCallback& callback) {
   DVLOG(1) << __func__;
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
 #if defined(OS_CHROMEOS)
-  output_protection_delegate_.SetProtection(desired_method_mask,
-                                            std::move(callback));
+  output_protection_delegate_.SetProtection(desired_method_mask, callback);
 #else   // defined(OS_CHROMEOS)
   NOTIMPLEMENTED();
-  std::move(callback).Run(false);
+  callback.Run(false);
 #endif  // defined(OS_CHROMEOS)
 }
 
 void OutputProtectionProxy::ProcessQueryStatusResult(
-    QueryStatusCallback callback,
+    const QueryStatusCallback& callback,
     bool success,
     uint32_t link_mask,
     uint32_t protection_mask) {
@@ -79,7 +76,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.";
-    std::move(callback).Run(false, 0, 0);
+    callback.Run(false, 0, 0);
     return;
   }
 
@@ -94,5 +91,5 @@ void OutputProtectionProxy::ProcessQueryStatusResult(
       new_link_mask |= display::DISPLAY_CONNECTION_TYPE_NETWORK;
   }
 
-  std::move(callback).Run(success, new_link_mask, protection_mask);
+  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:
-  using QueryStatusCallback =
-      base::OnceCallback<void(bool /* success */,
+  typedef base::Callback<void(bool /* success */,
                               uint32_t /* link_mask */,
-                              uint32_t /* protection_mask*/)>;
-  using EnableProtectionCallback = base::OnceCallback<void(bool /* success */)>;
+                              uint32_t /* protection_mask*/)>
+      QueryStatusCallback;
+  typedef base::Callback<void(bool /* success */)> EnableProtectionCallback;
 
   OutputProtectionProxy(int render_process_id, int render_frame_id);
   ~OutputProtectionProxy();
 
-  void QueryStatus(QueryStatusCallback callback);
+  void QueryStatus(const QueryStatusCallback& callback);
   void EnableProtection(uint32_t desired_method_mask,
-                        EnableProtectionCallback callback);
+                        const EnableProtectionCallback& callback);
 
  private:
   // Callbacks for QueryStatus(). It also checks the network link and adds it
   // to the |link_mask|.
-  void ProcessQueryStatusResult(QueryStatusCallback callback,
+  void ProcessQueryStatusResult(const 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,16 +606,14 @@ TEST_F(CastMediaSinkServiceImplTest, TestOnSinkAddedOrUpdated) {
   // Channel 1, 2 opened.
   EXPECT_CALL(*mock_cast_socket_service_, OpenSocketInternal(ip_endpoint1, _))
       .WillOnce(WithArgs<1>(
-          [&socket1](const base::RepeatingCallback<void(
-                         cast_channel::CastSocket * socket)>& callback) {
-            callback.Run(&socket1);
-          }));
+          [&socket1](
+              const base::Callback<void(cast_channel::CastSocket * socket)>&
+                  callback) { callback.Run(&socket1); }));
   EXPECT_CALL(*mock_cast_socket_service_, OpenSocketInternal(ip_endpoint2, _))
       .WillOnce(WithArgs<1>(
-          [&socket2](const base::RepeatingCallback<void(
-                         cast_channel::CastSocket * socket)>& callback) {
-            callback.Run(&socket2);
-          }));
+          [&socket2](
+              const base::Callback<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.
@@ -653,11 +651,10 @@ TEST_F(CastMediaSinkServiceImplTest,
 
   EXPECT_CALL(*mock_cast_socket_service_, OpenSocketInternal(ip_endpoint1, _))
       .Times(1)
-      .WillOnce(WithArgs<1>(
-          Invoke([&socket1](const base::RepeatingCallback<void(
-                                cast_channel::CastSocket * socket)>& callback) {
-            std::move(callback).Run(&socket1);
-          })));
+      .WillOnce(WithArgs<1>(Invoke(
+          [&socket1](
+              const base::Callback<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
@@ -667,10 +664,9 @@ TEST_F(CastMediaSinkServiceImplTest,
     EXPECT_CALL(*mock_cast_socket_service_, OpenSocketInternal(ip_endpoint1, _))
         .Times(1)
         .WillOnce(WithArgs<1>(Invoke(
-            [&socket1](const base::RepeatingCallback<void(
-                           cast_channel::CastSocket * socket)>& callback) {
-              std::move(callback).Run(&socket1);
-            })));
+            [&socket1](
+                const base::Callback<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::CancelableOnceClosure> cancelable_dismiss_cb;
+  std::unique_ptr<base::CancelableClosure> cancelable_dismiss_cb;
   base::TimeDelta timeout = GetAutoDismissTimeout(issue_info);
   if (!timeout.is_zero()) {
     cancelable_dismiss_cb =
-        std::make_unique<base::CancelableOnceClosure>(base::BindOnce(
+        std::make_unique<base::CancelableClosure>(base::Bind(
             &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::CancelableOnceClosure> cancelable_dismiss_callback)
+    std::unique_ptr<base::CancelableClosure> cancelable_dismiss_callback)
     : issue(issue),
       cancelable_dismiss_callback(std::move(cancelable_dismiss_callback)) {}
 

chrome/browser/media/router/issue_manager.h

@@ -69,14 +69,13 @@ class IssueManager {
   // will require adding support for delayed tasks to CancelableTaskTracker.
   struct Entry {
     Entry(const Issue& issue,
-          std::unique_ptr<base::CancelableOnceClosure>
-              cancelable_dismiss_callback);
+          std::unique_ptr<base::CancelableClosure> cancelable_dismiss_callback);
     ~Entry();
 
     Issue issue;
 
     // Set to non-null if |issue| can be auto-dismissed.
-    std::unique_ptr<base::CancelableOnceClosure> cancelable_dismiss_callback;
+    std::unique_ptr<base::CancelableClosure> 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::BindRepeating(
+    callbacks->set_removal_callback(base::Bind(
         &MediaRouterBase::OnPresentationConnectionStateCallbackRemoved,
         base::Unretained(this), route_id));
   }