1 // Copyright 2017 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef THIRD_PARTY_BLINK_RENDERER_MODULES_MEDIA_AUDIO_MOJO_AUDIO_OUTPUT_IPC_H_ 6 #define THIRD_PARTY_BLINK_RENDERER_MODULES_MEDIA_AUDIO_MOJO_AUDIO_OUTPUT_IPC_H_ 7 8 #include <string> 9 10 #include "base/callback_helpers.h" 11 #include "base/macros.h" 12 #include "base/memory/weak_ptr.h" 13 #include "base/optional.h" 14 #include "base/single_thread_task_runner.h" 15 #include "base/time/time.h" 16 #include "media/audio/audio_output_ipc.h" 17 #include "media/mojo/mojom/audio_data_pipe.mojom-blink.h" 18 #include "media/mojo/mojom/audio_output_stream.mojom-blink.h" 19 #include "mojo/public/cpp/bindings/pending_receiver.h" 20 #include "mojo/public/cpp/bindings/pending_remote.h" 21 #include "mojo/public/cpp/bindings/receiver.h" 22 #include "mojo/public/cpp/bindings/remote.h" 23 #include "third_party/blink/public/mojom/media/renderer_audio_output_stream_factory.mojom-blink.h" 24 #include "third_party/blink/renderer/modules/modules_export.h" 25 26 namespace blink { 27 28 // MojoAudioOutputIPC is a renderer-side class for handling creation, 29 // initialization and control of an output stream. May only be used on a single 30 // thread. 31 class MODULES_EXPORT MojoAudioOutputIPC 32 : public media::AudioOutputIPC, 33 public media::mojom::blink::AudioOutputStreamProviderClient { 34 public: 35 using FactoryAccessorCB = base::RepeatingCallback< 36 blink::mojom::blink::RendererAudioOutputStreamFactory*()>; 37 38 // |factory_accessor| is required to provide a 39 // RendererAudioOutputStreamFactory* if IPC is possible. 40 MojoAudioOutputIPC( 41 FactoryAccessorCB factory_accessor, 42 scoped_refptr<base::SingleThreadTaskRunner> io_task_runner); 43 44 ~MojoAudioOutputIPC() override; 45 46 // AudioOutputIPC implementation. 47 void RequestDeviceAuthorization(media::AudioOutputIPCDelegate* delegate, 48 const base::UnguessableToken& session_id, 49 const std::string& device_id) override; 50 void CreateStream( 51 media::AudioOutputIPCDelegate* delegate, 52 const media::AudioParameters& params, 53 const base::Optional<base::UnguessableToken>& processing_id) override; 54 void PlayStream() override; 55 void PauseStream() override; 56 void FlushStream() override; 57 void CloseStream() override; 58 void SetVolume(double volume) override; 59 60 // media::mojom::AudioOutputStreamProviderClient implementation. 61 void Created( 62 mojo::PendingRemote<media::mojom::blink::AudioOutputStream> stream, 63 media::mojom::blink::ReadWriteAudioDataPipePtr data_pipe) override; 64 65 private: 66 static constexpr double kDefaultVolume = 1.0; 67 68 using AuthorizationCB = blink::mojom::blink:: 69 RendererAudioOutputStreamFactory::RequestDeviceAuthorizationCallback; 70 71 bool AuthorizationRequested() const; 72 bool StreamCreationRequested() const; 73 74 void ProviderClientBindingDisconnected(uint32_t disconnect_reason, 75 const std::string& description); 76 77 mojo::PendingReceiver<media::mojom::blink::AudioOutputStreamProvider> 78 MakeProviderReceiver(); 79 80 // Tries to acquire a RendererAudioOutputStreamFactory and requests device 81 // authorization. On failure to aquire a factory, |callback| is destructed 82 // asynchronously. 83 void DoRequestDeviceAuthorization(const base::UnguessableToken& session_id, 84 const std::string& device_id, 85 AuthorizationCB callback); 86 87 void ReceivedDeviceAuthorization( 88 base::TimeTicks auth_start_time, 89 media::mojom::blink::OutputDeviceStatus status, 90 const media::AudioParameters& params, 91 const String& device_id) const; 92 93 const FactoryAccessorCB factory_accessor_; 94 95 // This is the state that |delegate_| expects the stream to be in. It is 96 // maintained for when the stream is created. 97 enum { kPaused, kPlaying } expected_state_ = kPaused; 98 base::Optional<double> volume_; 99 100 mojo::Receiver<media::mojom::blink::AudioOutputStreamProviderClient> 101 receiver_{this}; 102 mojo::Remote<media::mojom::blink::AudioOutputStreamProvider> stream_provider_; 103 mojo::Remote<media::mojom::blink::AudioOutputStream> stream_; 104 media::AudioOutputIPCDelegate* delegate_ = nullptr; 105 scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_; 106 107 // To make sure we don't send an "authorization completed" callback for a 108 // stream after it's closed, we use this weak factory. 109 base::WeakPtrFactory<MojoAudioOutputIPC> weak_factory_{this}; 110 111 DISALLOW_COPY_AND_ASSIGN(MojoAudioOutputIPC); 112 }; 113 114 } // namespace blink 115 116 #endif // THIRD_PARTY_BLINK_RENDERER_MODULES_MEDIA_AUDIO_MOJO_AUDIO_OUTPUT_IPC_H_ 117