OLD | NEW |
(Empty) | |
| 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 #include "content/browser/renderer_host/media/mojo_service_video_capture_device_
launcher.h" |
| 6 |
| 7 #include "content/browser/renderer_host/media/mojo_service_launched_video_captur
e_device.h" |
| 8 #include "content/public/browser/browser_thread.h" |
| 9 #include "media/capture/video/video_frame_receiver_on_task_runner.h" |
| 10 #include "mojo/public/cpp/bindings/strong_binding.h" |
| 11 #include "services/video_capture/public/cpp/receiver_media_to_mojo_adapter.h" |
| 12 |
| 13 namespace content { |
| 14 |
| 15 MojoServiceVideoCaptureDeviceLauncher::MojoServiceVideoCaptureDeviceLauncher( |
| 16 video_capture::mojom::DeviceFactoryPtr* device_factory) |
| 17 : device_factory_(device_factory), state_(State::READY_TO_LAUNCH) {} |
| 18 |
| 19 MojoServiceVideoCaptureDeviceLauncher:: |
| 20 ~MojoServiceVideoCaptureDeviceLauncher() { |
| 21 DCHECK(thread_checker_.CalledOnValidThread()); |
| 22 DCHECK(state_ == State::READY_TO_LAUNCH); |
| 23 } |
| 24 |
| 25 void MojoServiceVideoCaptureDeviceLauncher::LaunchDeviceAsync( |
| 26 const std::string& device_id, |
| 27 MediaStreamType stream_type, |
| 28 const media::VideoCaptureParams& params, |
| 29 base::WeakPtr<media::VideoFrameReceiver> receiver, |
| 30 Callbacks* callbacks, |
| 31 base::OnceClosure done_cb) { |
| 32 DCHECK(thread_checker_.CalledOnValidThread()); |
| 33 DCHECK(state_ == State::READY_TO_LAUNCH); |
| 34 |
| 35 if (stream_type != content::MEDIA_DEVICE_VIDEO_CAPTURE) { |
| 36 // This launcher only supports MEDIA_DEVICE_VIDEO_CAPTURE. |
| 37 NOTREACHED(); |
| 38 return; |
| 39 } |
| 40 |
| 41 if (!device_factory_->is_bound()) { |
| 42 // This can happen when the MojoServiceVideoCaptureProvider owning |
| 43 // |device_factory_| loses connection to the service process and resets |
| 44 // |device_factory_|. |
| 45 OnDeviceCreationFailed(callbacks, std::move(done_cb)); |
| 46 return; |
| 47 } |
| 48 video_capture::mojom::DevicePtr device; |
| 49 (*device_factory_) |
| 50 ->CreateDevice( |
| 51 device_id, mojo::MakeRequest(&device), |
| 52 base::Bind( |
| 53 &MojoServiceVideoCaptureDeviceLauncher::OnCreateDeviceCallback, |
| 54 base::Unretained(this), params, base::Passed(&device), |
| 55 std::move(receiver), callbacks, base::Passed(&done_cb))); |
| 56 state_ = State::DEVICE_START_IN_PROGRESS; |
| 57 } |
| 58 |
| 59 void MojoServiceVideoCaptureDeviceLauncher::AbortLaunch() { |
| 60 DCHECK(thread_checker_.CalledOnValidThread()); |
| 61 if (state_ == State::DEVICE_START_IN_PROGRESS) |
| 62 state_ = State::DEVICE_START_ABORTING; |
| 63 } |
| 64 |
| 65 void MojoServiceVideoCaptureDeviceLauncher::OnCreateDeviceCallback( |
| 66 const media::VideoCaptureParams& params, |
| 67 video_capture::mojom::DevicePtr device, |
| 68 base::WeakPtr<media::VideoFrameReceiver> receiver, |
| 69 Callbacks* callbacks, |
| 70 base::OnceClosure done_cb, |
| 71 video_capture::mojom::DeviceAccessResultCode result_code) { |
| 72 DCHECK(thread_checker_.CalledOnValidThread()); |
| 73 switch (result_code) { |
| 74 case video_capture::mojom::DeviceAccessResultCode::SUCCESS: |
| 75 OnDeviceCreatedSuccessfully(params, std::move(device), |
| 76 std::move(receiver), callbacks, |
| 77 std::move(done_cb)); |
| 78 return; |
| 79 case video_capture::mojom::DeviceAccessResultCode::ERROR_DEVICE_NOT_FOUND: |
| 80 case video_capture::mojom::DeviceAccessResultCode::NOT_INITIALIZED: |
| 81 OnDeviceCreationFailed(callbacks, std::move(done_cb)); |
| 82 return; |
| 83 } |
| 84 } |
| 85 |
| 86 void MojoServiceVideoCaptureDeviceLauncher::OnDeviceCreatedSuccessfully( |
| 87 const media::VideoCaptureParams& params, |
| 88 video_capture::mojom::DevicePtr device, |
| 89 base::WeakPtr<media::VideoFrameReceiver> receiver, |
| 90 Callbacks* callbacks, |
| 91 base::OnceClosure done_cb) { |
| 92 DCHECK(thread_checker_.CalledOnValidThread()); |
| 93 |
| 94 if (state_ == State::DEVICE_START_ABORTING) { |
| 95 device.reset(); |
| 96 callbacks->OnDeviceLaunchAborted(); |
| 97 base::ResetAndReturn(&done_cb).Run(); |
| 98 return; |
| 99 } |
| 100 |
| 101 auto receiver_adapter = |
| 102 base::MakeUnique<video_capture::ReceiverMediaToMojoAdapter>( |
| 103 base::MakeUnique<media::VideoFrameReceiverOnTaskRunner>( |
| 104 std::move(receiver), |
| 105 BrowserThread::GetTaskRunnerForThread(BrowserThread::IO))); |
| 106 video_capture::mojom::ReceiverPtr receiver_proxy; |
| 107 mojo::MakeStrongBinding<video_capture::mojom::Receiver>( |
| 108 std::move(receiver_adapter), mojo::MakeRequest(&receiver_proxy)); |
| 109 device->Start(params, std::move(receiver_proxy)); |
| 110 callbacks->OnDeviceLaunched( |
| 111 base::MakeUnique<MojoServiceLaunchedVideoCaptureDevice>( |
| 112 std::move(device))); |
| 113 base::ResetAndReturn(&done_cb).Run(); |
| 114 } |
| 115 |
| 116 void MojoServiceVideoCaptureDeviceLauncher::OnDeviceCreationFailed( |
| 117 Callbacks* callbacks, |
| 118 base::OnceClosure done_cb) { |
| 119 DCHECK(thread_checker_.CalledOnValidThread()); |
| 120 if (state_ == State::DEVICE_START_ABORTING) |
| 121 callbacks->OnDeviceLaunchAborted(); |
| 122 else |
| 123 callbacks->OnDeviceLaunchFailed(); |
| 124 base::ResetAndReturn(&done_cb).Run(); |
| 125 } |
| 126 |
| 127 } // namespace content |
OLD | NEW |