Convert services/media_session services to new Mojo types (6/n)

The primary goal of this CL is to convert usage of |functions| of
interface AudioFocusManager and port dependent files to adopt new
implementation.

Bug: 955171
Change-Id: I2c8f269b2b36034b9ebc5beb1aef56ee3db691b1
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1715367
Commit-Queue: Abhijeet Kandalkar <abhijeet@igalia.com>
Reviewed-by: Kinuko Yasuda <kinuko@chromium.org>
Reviewed-by: Ken Rockot <rockot@google.com>
Reviewed-by: Mitsuru Oshima <oshima@chromium.org>
Cr-Commit-Position: refs/heads/master@{#682154}

chromeos/services/assistant/media_session/assistant_media_session.cc

@@ -29,7 +29,6 @@ AssistantMediaSession::AssistantMediaSession(
     AssistantManagerServiceImpl* assistant_manager)
     : assistant_manager_service_(assistant_manager),
       connector_(connector),
-      binding_(this),
       weak_factory_(this) {}
 
 AssistantMediaSession::~AssistantMediaSession() {
@@ -97,9 +96,9 @@ void AssistantMediaSession::RequestAudioFocus(AudioFocusType audio_focus_type) {
     return;
   }
 
-  if (request_client_ptr_.is_bound()) {
+  if (request_client_remote_.is_bound()) {
     // We have an existing request so we should request an updated focus type.
-    request_client_ptr_->RequestAudioFocus(
+    request_client_remote_->RequestAudioFocus(
         GetMediaSessionInfoInternal(), audio_focus_type,
         base::BindOnce(&AssistantMediaSession::FinishAudioFocusRequest,
                        base::Unretained(this), audio_focus_type));
@@ -109,12 +108,11 @@ void AssistantMediaSession::RequestAudioFocus(AudioFocusType audio_focus_type) {
   EnsureServiceConnection();
 
   // Create a mojo interface pointer to our media session.
-  media_session::mojom::MediaSessionPtr media_session;
-  binding_.Close();
-  binding_.Bind(mojo::MakeRequest(&media_session));
-  audio_focus_ptr_->RequestAudioFocus(
-      mojo::MakeRequest(&request_client_ptr_), std::move(media_session),
-      GetMediaSessionInfoInternal(), audio_focus_type,
+  receiver_.reset();
+  audio_focus_remote_->RequestAudioFocus(
+      request_client_remote_.BindNewPipeAndPassReceiver(),
+      receiver_.BindNewPipeAndPassRemote(), GetMediaSessionInfoInternal(),
+      audio_focus_type,
       base::BindOnce(&AssistantMediaSession::FinishInitialAudioFocusRequest,
                      base::Unretained(this), audio_focus_type));
 }
@@ -130,30 +128,31 @@ void AssistantMediaSession::AbandonAudioFocusIfNeeded() {
 
   SetAudioFocusInfo(State::INACTIVE, audio_focus_type_);
 
-  if (!request_client_ptr_.is_bound())
+  if (!request_client_remote_.is_bound())
     return;
 
-  request_client_ptr_->AbandonAudioFocus();
-  request_client_ptr_.reset();
-  audio_focus_ptr_.reset();
+  request_client_remote_->AbandonAudioFocus();
+  request_client_remote_.reset();
+  audio_focus_remote_.reset();
 }
 
 void AssistantMediaSession::EnsureServiceConnection() {
   DCHECK(base::FeatureList::IsEnabled(
       media_session::features::kMediaSessionService));
 
-  if (audio_focus_ptr_.is_bound() && !audio_focus_ptr_.encountered_error())
+  if (audio_focus_remote_.is_bound() &&
+      !audio_focus_remote_.encountered_error())
     return;
 
-  audio_focus_ptr_.reset();
-  connector_->BindInterface(media_session::mojom::kServiceName,
-                            mojo::MakeRequest(&audio_focus_ptr_));
-  audio_focus_ptr_->SetSourceName(kAudioFocusSourceName);
+  audio_focus_remote_.reset();
+  connector_->Connect(media_session::mojom::kServiceName,
+                      audio_focus_remote_->BindNewPipeAndPassReceiver());
+  audio_focus_remote_->SetSourceName(kAudioFocusSourceName);
 }
 
 void AssistantMediaSession::FinishAudioFocusRequest(
     AudioFocusType audio_focus_type) {
-  DCHECK(request_client_ptr_.is_bound());
+  DCHECK(request_client_remote_.is_bound());
 
   SetAudioFocusInfo(State::ACTIVE, audio_focus_type);
 }
@@ -225,8 +224,8 @@ void AssistantMediaSession::NotifyMediaSessionInfoChanged() {
   if (current_info == session_info_)
     return;
 
-  if (request_client_ptr_.is_bound())
-    request_client_ptr_->MediaSessionInfoChanged(current_info.Clone());
+  if (request_client_remote_.is_bound())
+    request_client_remote_->MediaSessionInfoChanged(current_info.Clone());
 
   for (auto& observer : observers_)
     observer->MediaSessionInfoChanged(current_info.Clone());

chromeos/services/assistant/media_session/assistant_media_session.h

@@ -9,8 +9,8 @@
 #include "base/timer/timer.h"
 #include "base/unguessable_token.h"
 #include "libassistant/shared/public/media_manager.h"
-#include "mojo/public/cpp/bindings/binding.h"
 #include "mojo/public/cpp/bindings/interface_ptr_set.h"
+#include "mojo/public/cpp/bindings/receiver.h"
 #include "mojo/public/cpp/bindings/remote_set.h"
 #include "services/media_session/public/mojom/audio_focus.mojom.h"
 #include "services/media_session/public/mojom/media_session.mojom.h"
@@ -103,14 +103,14 @@ class AssistantMediaSession : public media_session::mojom::MediaSession {
   service_manager::Connector* connector_;
 
   // Binding for Mojo pointer to |this| held by AudioFocusManager.
-  mojo::Binding<media_session::mojom::MediaSession> binding_;
+  mojo::Receiver<media_session::mojom::MediaSession> receiver_{this};
 
   assistant_client::TrackType current_track_;
 
   mojo::RemoteSet<media_session::mojom::MediaSessionObserver> observers_;
 
   // Holds a pointer to the MediaSessionService.
-  media_session::mojom::AudioFocusManagerPtr audio_focus_ptr_;
+  mojo::Remote<media_session::mojom::AudioFocusManager> audio_focus_remote_;
 
   // The ducking state of this media session. The initial value is |false|, and
   // is set to |true| after StartDucking(), and will be set to |false| after
@@ -119,7 +119,8 @@ class AssistantMediaSession : public media_session::mojom::MediaSession {
 
   // If the media session has acquired audio focus then this will contain a
   // pointer to that requests AudioFocusRequestClient.
-  media_session::mojom::AudioFocusRequestClientPtr request_client_ptr_;
+  mojo::Remote<media_session::mojom::AudioFocusRequestClient>
+      request_client_remote_;
 
   // The last updated |MediaSessionInfo| that was sent to |observers_|.
   media_session::mojom::MediaSessionInfoPtr session_info_;

content/browser/media/session/audio_focus_delegate_default.cc

@@ -70,7 +70,8 @@ class AudioFocusDelegateDefault : public AudioFocusDelegate {
 
   // If the media session has acquired audio focus then this will contain a
   // pointer to that requests AudioFocusRequestClient.
-  media_session::mojom::AudioFocusRequestClientPtr request_client_ptr_;
+  mojo::Remote<media_session::mojom::AudioFocusRequestClient>
+      request_client_remote_;
 
   // Weak pointer because |this| is owned by |media_session_|.
   MediaSessionImpl* media_session_;
@@ -99,9 +100,9 @@ AudioFocusDelegateDefault::RequestAudioFocus(AudioFocusType audio_focus_type) {
     return AudioFocusDelegate::AudioFocusResult::kSuccess;
   }
 
-  if (request_client_ptr_.is_bound()) {
+  if (request_client_remote_.is_bound()) {
     // We have an existing request so we should request an updated focus type.
-    request_client_ptr_->RequestAudioFocus(
+    request_client_remote_->RequestAudioFocus(
         session_info_.Clone(), audio_focus_type,
         base::BindOnce(&AudioFocusDelegateDefault::FinishAudioFocusRequest,
                        base::Unretained(this), audio_focus_type));
@@ -109,12 +110,12 @@ AudioFocusDelegateDefault::RequestAudioFocus(AudioFocusType audio_focus_type) {
     EnsureServiceConnection();
 
     // Create a mojo interface pointer to our media session.
-    media_session::mojom::MediaSessionPtr media_session;
-    media_session_->BindToMojoRequest(mojo::MakeRequest(&media_session));
+    mojo::PendingRemote<media_session::mojom::MediaSession> media_session =
+        media_session_->AddRemote();
 
     audio_focus_ptr_->RequestGroupedAudioFocus(
-        mojo::MakeRequest(&request_client_ptr_), std::move(media_session),
-        session_info_.Clone(), audio_focus_type,
+        request_client_remote_.BindNewPipeAndPassReceiver(),
+        std::move(media_session), session_info_.Clone(), audio_focus_type,
         GetAudioFocusGroupId(media_session_),
         base::BindOnce(
             &AudioFocusDelegateDefault::FinishInitialAudioFocusRequest,
@@ -130,11 +131,11 @@ void AudioFocusDelegateDefault::AbandonAudioFocus() {
 
   audio_focus_type_.reset();
 
-  if (!request_client_ptr_.is_bound())
+  if (!request_client_remote_.is_bound())
     return;
 
-  request_client_ptr_->AbandonAudioFocus();
-  request_client_ptr_.reset();
+  request_client_remote_->AbandonAudioFocus();
+  request_client_remote_.reset();
   audio_focus_ptr_.reset();
 }
 
@@ -148,15 +149,15 @@ void AudioFocusDelegateDefault::MediaSessionInfoChanged(
     media_session::mojom::MediaSessionInfoPtr session_info) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
-  if (request_client_ptr_.is_bound())
-    request_client_ptr_->MediaSessionInfoChanged(session_info.Clone());
+  if (request_client_remote_.is_bound())
+    request_client_remote_->MediaSessionInfoChanged(session_info.Clone());
 
   session_info_ = std::move(session_info);
 }
 
 void AudioFocusDelegateDefault::FinishAudioFocusRequest(AudioFocusType type) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  DCHECK(request_client_ptr_.is_bound());
+  DCHECK(request_client_remote_.is_bound());
 
   audio_focus_type_ = type;
   media_session_->FinishSystemAudioFocusRequest(type, true /* result */);

content/browser/media/session/media_session_impl.cc

@@ -778,9 +778,11 @@ AudioFocusDelegate::AudioFocusResult MediaSessionImpl::RequestSystemAudioFocus(
   return result;
 }
 
-void MediaSessionImpl::BindToMojoRequest(
-    mojo::InterfaceRequest<media_session::mojom::MediaSession> request) {
-  bindings_.AddBinding(this, std::move(request));
+mojo::PendingRemote<media_session::mojom::MediaSession>
+MediaSessionImpl::AddRemote() {
+  mojo::PendingRemote<media_session::mojom::MediaSession> remote;
+  receivers_.Add(this, remote.InitWithNewPipeAndPassReceiver());
+  return remote;
 }
 
 void MediaSessionImpl::GetDebugInfo(GetDebugInfoCallback callback) {

content/browser/media/session/media_session_impl.h

@@ -24,9 +24,8 @@
 #include "content/public/browser/media_session.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/browser/web_contents_user_data.h"
-#include "mojo/public/cpp/bindings/binding.h"
-#include "mojo/public/cpp/bindings/binding_set.h"
 #include "mojo/public/cpp/bindings/interface_ptr_set.h"
+#include "mojo/public/cpp/bindings/receiver_set.h"
 #include "mojo/public/cpp/bindings/remote_set.h"
 #include "services/media_session/public/mojom/audio_focus.mojom.h"
 
@@ -164,8 +163,7 @@ class MediaSessionImpl : public MediaSession,
       media_session::mojom::AudioFocusType audio_focus_type);
 
   // Creates a binding between |this| and |request|.
-  void BindToMojoRequest(
-      mojo::InterfaceRequest<media_session::mojom::MediaSession> request);
+  mojo::PendingRemote<media_session::mojom::MediaSession> AddRemote();
 
   // Returns information about the MediaSession.
   CONTENT_EXPORT media_session::mojom::MediaSessionInfoPtr
@@ -425,7 +423,7 @@ class MediaSessionImpl : public MediaSession,
   MediaSessionServiceImpl* routed_service_;
 
   // Bindings for Mojo pointers to |this| held by media route providers.
-  mojo::BindingSet<media_session::mojom::MediaSession> bindings_;
+  mojo::ReceiverSet<media_session::mojom::MediaSession> receivers_;
 
   mojo::RemoteSet<media_session::mojom::MediaSessionObserver> observers_;
 

services/media_session/audio_focus_manager.cc

@@ -58,19 +58,19 @@ class MediaPowerDelegate : public base::PowerObserver {
 };
 
 void AudioFocusManager::RequestAudioFocus(
-    mojom::AudioFocusRequestClientRequest request,
-    mojom::MediaSessionPtr media_session,
+    mojo::PendingReceiver<mojom::AudioFocusRequestClient> receiver,
+    mojo::PendingRemote<mojom::MediaSession> media_session,
     mojom::MediaSessionInfoPtr session_info,
     mojom::AudioFocusType type,
     RequestAudioFocusCallback callback) {
   RequestGroupedAudioFocus(
-      std::move(request), std::move(media_session), std::move(session_info),
+      std::move(receiver), std::move(media_session), std::move(session_info),
       type, base::UnguessableToken::Create(), std::move(callback));
 }
 
 void AudioFocusManager::RequestGroupedAudioFocus(
-    mojom::AudioFocusRequestClientRequest request,
-    mojom::MediaSessionPtr media_session,
+    mojo::PendingReceiver<mojom::AudioFocusRequestClient> receiver,
+    mojo::PendingRemote<mojom::MediaSession> media_session,
     mojom::MediaSessionInfoPtr session_info,
     mojom::AudioFocusType type,
     const base::UnguessableToken& group_id,
@@ -79,7 +79,7 @@ void AudioFocusManager::RequestGroupedAudioFocus(
 
   RequestAudioFocusInternal(
       std::make_unique<AudioFocusRequest>(
-          weak_ptr_factory_.GetWeakPtr(), std::move(request),
+          weak_ptr_factory_.GetWeakPtr(), std::move(receiver),
           std::move(media_session), std::move(session_info), type, request_id,
           GetBindingSourceName(), group_id),
       type);

services/media_session/audio_focus_manager.h

@@ -49,17 +49,19 @@ class AudioFocusManager : public mojom::AudioFocusManager,
   using RequestId = base::UnguessableToken;
 
   // mojom::AudioFocusManager.
-  void RequestAudioFocus(mojom::AudioFocusRequestClientRequest request,
-                         mojom::MediaSessionPtr media_session,
-                         mojom::MediaSessionInfoPtr session_info,
-                         mojom::AudioFocusType type,
-                         RequestAudioFocusCallback callback) override;
-  void RequestGroupedAudioFocus(mojom::AudioFocusRequestClientRequest request,
-                                mojom::MediaSessionPtr media_session,
-                                mojom::MediaSessionInfoPtr session_info,
-                                mojom::AudioFocusType type,
-                                const base::UnguessableToken& group_id,
-                                RequestAudioFocusCallback callback) override;
+  void RequestAudioFocus(
+      mojo::PendingReceiver<mojom::AudioFocusRequestClient> receiver,
+      mojo::PendingRemote<mojom::MediaSession> media_session,
+      mojom::MediaSessionInfoPtr session_info,
+      mojom::AudioFocusType type,
+      RequestAudioFocusCallback callback) override;
+  void RequestGroupedAudioFocus(
+      mojo::PendingReceiver<mojom::AudioFocusRequestClient> receiver,
+      mojo::PendingRemote<mojom::MediaSession> media_session,
+      mojom::MediaSessionInfoPtr session_info,
+      mojom::AudioFocusType type,
+      const base::UnguessableToken& group_id,
+      RequestAudioFocusCallback callback) override;
   void GetFocusRequests(GetFocusRequestsCallback callback) override;
   void AddObserver(
       mojo::PendingRemote<mojom::AudioFocusObserver> observer) override;

services/media_session/audio_focus_request.cc

@@ -10,8 +10,8 @@ namespace media_session {
 
 AudioFocusRequest::AudioFocusRequest(
     base::WeakPtr<AudioFocusManager> owner,
-    mojom::AudioFocusRequestClientRequest request,
-    mojom::MediaSessionPtr session,
+    mojo::PendingReceiver<mojom::AudioFocusRequestClient> receiver,
+    mojo::PendingRemote<mojom::MediaSession> session,
     mojom::MediaSessionInfoPtr session_info,
     mojom::AudioFocusType audio_focus_type,
     const base::UnguessableToken& id,
@@ -21,13 +21,13 @@ AudioFocusRequest::AudioFocusRequest(
       session_(std::move(session)),
       session_info_(std::move(session_info)),
       audio_focus_type_(audio_focus_type),
-      binding_(this, std::move(request)),
+      receiver_(this, std::move(receiver)),
       id_(id),
       source_name_(source_name),
       group_id_(group_id),
       owner_(std::move(owner)) {
   // Listen for mojo errors.
-  binding_.set_connection_error_handler(base::BindOnce(
+  receiver_.set_disconnect_handler(base::BindOnce(
       &AudioFocusRequest::OnConnectionError, base::Unretained(this)));
   session_.set_connection_error_handler(base::BindOnce(
       &AudioFocusRequest::OnConnectionError, base::Unretained(this)));

services/media_session/audio_focus_request.h

@@ -8,7 +8,7 @@
 #include "base/callback_forward.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
-#include "mojo/public/cpp/bindings/binding.h"
+#include "mojo/public/cpp/bindings/receiver.h"
 #include "services/media_session/audio_focus_manager_metrics_helper.h"
 #include "services/media_session/public/mojom/audio_focus.mojom.h"
 #include "services/media_session/public/mojom/media_controller.mojom.h"
@@ -23,14 +23,15 @@ class MediaController;
 
 class AudioFocusRequest : public mojom::AudioFocusRequestClient {
  public:
-  AudioFocusRequest(base::WeakPtr<AudioFocusManager> owner,
-                    mojom::AudioFocusRequestClientRequest request,
-                    mojom::MediaSessionPtr session,
-                    mojom::MediaSessionInfoPtr session_info,
-                    mojom::AudioFocusType audio_focus_type,
-                    const base::UnguessableToken& id,
-                    const std::string& source_name,
-                    const base::UnguessableToken& group_id);
+  AudioFocusRequest(
+      base::WeakPtr<AudioFocusManager> owner,
+      mojo::PendingReceiver<mojom::AudioFocusRequestClient> receiver,
+      mojo::PendingRemote<mojom::MediaSession> session,
+      mojom::MediaSessionInfoPtr session_info,
+      mojom::AudioFocusType audio_focus_type,
+      const base::UnguessableToken& id,
+      const std::string& source_name,
+      const base::UnguessableToken& group_id);
 
   ~AudioFocusRequest() override;
 
@@ -97,7 +98,7 @@ class AudioFocusRequest : public mojom::AudioFocusRequestClient {
   mojom::MediaSessionInfoPtr session_info_;
   mojom::AudioFocusType audio_focus_type_;
 
-  mojo::Binding<mojom::AudioFocusRequestClient> binding_;
+  mojo::Receiver<mojom::AudioFocusRequestClient> receiver_;
 
   // The action to apply when the transient hold is released.
   base::Optional<mojom::MediaSessionAction> delayed_action_;

services/media_session/public/cpp/test/mock_media_session.cc

@@ -300,11 +300,11 @@ base::UnguessableToken MockMediaSession::RequestAudioFocusFromService(
     DCHECK(request_id_.is_empty());
 
     // Build a new audio focus request.
-    mojom::MediaSessionPtr media_session;
-    bindings_.AddBinding(this, mojo::MakeRequest(&media_session));
+    mojo::PendingRemote<mojom::MediaSession> media_session;
+    receivers_.Add(this, media_session.InitWithNewPipeAndPassReceiver());
 
     service->RequestAudioFocus(
-        mojo::MakeRequest(&afr_client_), std::move(media_session),
+        afr_client_.BindNewPipeAndPassReceiver(), std::move(media_session),
         GetMediaSessionInfoSync(), audio_focus_type,
         base::BindOnce(
             [](base::UnguessableToken* id,
@@ -333,11 +333,11 @@ base::UnguessableToken MockMediaSession::RequestGroupedAudioFocusFromService(
     DCHECK(request_id_.is_empty());
 
     // Build a new audio focus request.
-    mojom::MediaSessionPtr media_session;
-    bindings_.AddBinding(this, mojo::MakeRequest(&media_session));
+    mojo::PendingRemote<mojom::MediaSession> media_session;
+    receivers_.Add(this, media_session.InitWithNewPipeAndPassReceiver());
 
     service->RequestGroupedAudioFocus(
-        mojo::MakeRequest(&afr_client_), std::move(media_session),
+        afr_client_.BindNewPipeAndPassReceiver(), std::move(media_session),
         GetMediaSessionInfoSync(), audio_focus_type, group_id,
         base::BindOnce(
             [](base::UnguessableToken* id,

services/media_session/public/cpp/test/mock_media_session.h

@@ -13,9 +13,8 @@
 #include "base/optional.h"
 #include "base/run_loop.h"
 #include "base/unguessable_token.h"
-#include "mojo/public/cpp/bindings/binding.h"
-#include "mojo/public/cpp/bindings/binding_set.h"
 #include "mojo/public/cpp/bindings/interface_ptr_set.h"
+#include "mojo/public/cpp/bindings/receiver_set.h"
 #include "mojo/public/cpp/bindings/remote_set.h"
 #include "services/media_session/public/cpp/media_metadata.h"
 #include "services/media_session/public/mojom/audio_focus.mojom.h"
@@ -192,7 +191,7 @@ class COMPONENT_EXPORT(MEDIA_SESSION_TEST_SUPPORT_CPP) MockMediaSession
 
   void RequestAudioFocusFromClient(mojom::AudioFocusType audio_focus_type);
 
-  mojom::AudioFocusRequestClientPtr afr_client_;
+  mojo::Remote<mojom::AudioFocusRequestClient> afr_client_;
 
   base::UnguessableToken request_id_;
 
@@ -216,7 +215,7 @@ class COMPONENT_EXPORT(MEDIA_SESSION_TEST_SUPPORT_CPP) MockMediaSession
   base::flat_map<mojom::MediaSessionImageType, std::vector<MediaImage>> images_;
   GURL last_image_src_;
 
-  mojo::BindingSet<mojom::MediaSession> bindings_;
+  mojo::ReceiverSet<mojom::MediaSession> receivers_;
 
   mojo::RemoteSet<mojom::MediaSessionObserver> observers_;
 

services/media_session/public/mojom/audio_focus.mojom

@@ -95,8 +95,8 @@ interface AudioFocusManager {
   // provide an AudioFocusRequestClient that can be used to control this
   // request. The callback will resolve with the id of the request when
   // audio focus has been granted.
-  RequestAudioFocus@0(AudioFocusRequestClient& client,
-                      MediaSession media_session,
+  RequestAudioFocus@0(pending_receiver<AudioFocusRequestClient> client,
+                      pending_remote<MediaSession> media_session,
                       MediaSessionInfo session_info,
                       AudioFocusType type) =>
                           (mojo_base.mojom.UnguessableToken request_id);
@@ -105,8 +105,8 @@ interface AudioFocusManager {
   // grouping sessions together. This is when a group of media sessions
   // will share audio focus.
   [MinVersion=4] RequestGroupedAudioFocus@4(
-      AudioFocusRequestClient& client,
-      MediaSession media_session,
+      pending_receiver<AudioFocusRequestClient> client,
+      pending_remote<MediaSession> media_session,
       MediaSessionInfo session_info,
       AudioFocusType type,
       mojo_base.mojom.UnguessableToken group_id) =>