receiver_controller.cc 4.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117
  1. // Copyright 2020 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. #include "media/remoting/receiver_controller.h"
  5. #include "base/no_destructor.h"
  6. #include "base/task/single_thread_task_runner.h"
  7. #include "base/threading/thread_task_runner_handle.h"
  8. namespace media {
  9. namespace remoting {
  10. // static
  11. ReceiverController* ReceiverController::GetInstance() {
  12. static base::NoDestructor<ReceiverController> controller;
  13. return controller.get();
  14. }
  15. ReceiverController::ReceiverController()
  16. : rpc_messenger_([this](std::vector<uint8_t> message) {
  17. OnSendRpc(std::move(message));
  18. }),
  19. main_task_runner_(base::ThreadTaskRunnerHandle::Get()) {}
  20. ReceiverController::~ReceiverController() = default;
  21. void ReceiverController::Initialize(
  22. mojo::PendingRemote<mojom::Remotee> remotee) {
  23. DCHECK(main_task_runner_->BelongsToCurrentThread());
  24. DCHECK(!media_remotee_.is_bound());
  25. media_remotee_.Bind(std::move(remotee));
  26. // Calling NotifyRemotingSinkReady() to notify the host that RemotingSink is
  27. // ready.
  28. media_remotee_->OnRemotingSinkReady(receiver_.BindNewPipeAndPassRemote());
  29. }
  30. void ReceiverController::OnRendererFlush(uint32_t audio_count,
  31. uint32_t video_count) {
  32. if (!main_task_runner_->BelongsToCurrentThread()) {
  33. // |this| is a singleton per process, it would be safe to use
  34. // base::Unretained() here.
  35. main_task_runner_->PostTask(
  36. FROM_HERE,
  37. base::BindOnce(&ReceiverController::OnRendererFlush,
  38. base::Unretained(this), audio_count, video_count));
  39. return;
  40. }
  41. if (media_remotee_.is_bound())
  42. media_remotee_->OnFlushUntil(audio_count, video_count);
  43. }
  44. void ReceiverController::OnVideoNaturalSizeChange(const gfx::Size& size) {
  45. if (!main_task_runner_->BelongsToCurrentThread()) {
  46. // |this| is a singleton per process, it would be safe to use
  47. // base::Unretained() here.
  48. main_task_runner_->PostTask(
  49. FROM_HERE, base::BindOnce(&ReceiverController::OnVideoNaturalSizeChange,
  50. base::Unretained(this), size));
  51. return;
  52. }
  53. if (media_remotee_.is_bound())
  54. media_remotee_->OnVideoNaturalSizeChange(size);
  55. }
  56. void ReceiverController::StartDataStreams(
  57. mojo::PendingRemote<::media::mojom::RemotingDataStreamReceiver>
  58. audio_stream,
  59. mojo::PendingRemote<::media::mojom::RemotingDataStreamReceiver>
  60. video_stream) {
  61. if (!main_task_runner_->BelongsToCurrentThread()) {
  62. // |this| is a singleton per process, it would be safe to use
  63. // base::Unretained() here.
  64. main_task_runner_->PostTask(
  65. FROM_HERE,
  66. base::BindOnce(&ReceiverController::StartDataStreams,
  67. base::Unretained(this), std::move(audio_stream),
  68. std::move(video_stream)));
  69. return;
  70. }
  71. if (media_remotee_.is_bound()) {
  72. media_remotee_->StartDataStreams(std::move(audio_stream),
  73. std::move(video_stream));
  74. }
  75. }
  76. void ReceiverController::OnMessageFromSource(
  77. const std::vector<uint8_t>& message) {
  78. DCHECK(main_task_runner_->BelongsToCurrentThread());
  79. auto rpc_message = std::make_unique<openscreen::cast::RpcMessage>(
  80. openscreen::cast::RpcMessage());
  81. if (!rpc_message->ParseFromArray(message.data(), message.size()))
  82. return;
  83. rpc_messenger_.ProcessMessageFromRemote(std::move(rpc_message));
  84. }
  85. void ReceiverController::OnSendRpc(std::vector<uint8_t> message) {
  86. if (!main_task_runner_->BelongsToCurrentThread()) {
  87. // |this| is a singleton per process, it would be safe to use
  88. // base::Unretained() here.
  89. main_task_runner_->PostTask(
  90. FROM_HERE, base::BindOnce(&ReceiverController::OnSendRpc,
  91. base::Unretained(this), std::move(message)));
  92. return;
  93. }
  94. DCHECK(media_remotee_.is_bound());
  95. if (media_remotee_.is_bound())
  96. media_remotee_->SendMessageToSource(message);
  97. }
  98. } // namespace remoting
  99. } // namespace media