OLD | NEW |
1 // Copyright 2016 The Chromium Authors. All rights reserved. | 1 // Copyright 2016 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "services/video_capture/service_impl.h" | 5 #include "services/video_capture/video_capture_service_impl.h" |
6 | 6 |
7 #include "base/memory/ptr_util.h" | 7 #include "base/memory/ptr_util.h" |
8 #include "base/message_loop/message_loop.h" | |
9 #include "media/capture/video/fake_video_capture_device_factory.h" | 8 #include "media/capture/video/fake_video_capture_device_factory.h" |
10 #include "media/capture/video/video_capture_buffer_pool.h" | 9 #include "media/capture/video/video_capture_buffer_pool.h" |
11 #include "media/capture/video/video_capture_buffer_tracker.h" | 10 #include "media/capture/video/video_capture_buffer_tracker.h" |
12 #include "media/capture/video/video_capture_jpeg_decoder.h" | 11 #include "media/capture/video/video_capture_jpeg_decoder.h" |
13 #include "media/capture/video/video_capture_system_impl.h" | 12 #include "media/capture/video/video_capture_system_impl.h" |
14 #include "services/service_manager/public/cpp/service_info.h" | 13 #include "services/service_manager/public/cpp/service_info.h" |
15 #include "services/video_capture/device_factory_media_to_mojo_adapter.h" | 14 #include "services/video_capture/device_factory_media_to_mojo_adapter.h" |
16 | 15 |
17 namespace { | 16 namespace { |
18 | 17 |
19 // TODO(chfremer): Replace with an actual decoder factory. | 18 // TODO(chfremer): Replace with an actual decoder factory. |
20 // https://crbug.com/584797 | 19 // https://crbug.com/584797 |
21 std::unique_ptr<media::VideoCaptureJpegDecoder> CreateJpegDecoder() { | 20 std::unique_ptr<media::VideoCaptureJpegDecoder> CreateJpegDecoder() { |
22 return nullptr; | 21 return nullptr; |
23 } | 22 } |
24 | 23 |
25 } // anonymous namespace | 24 } // anonymous namespace |
26 | 25 |
27 namespace video_capture { | 26 namespace video_capture { |
28 | 27 |
29 ServiceImpl::ServiceImpl() { | 28 VideoCaptureServiceImpl::VideoCaptureServiceImpl( |
30 registry_.AddInterface<mojom::Service>(this); | 29 std::unique_ptr<service_manager::ServiceContextRef> service_ref, |
31 } | 30 base::Callback<void(float)> set_shutdown_delay_cb) |
| 31 : service_ref_(std::move(service_ref)), |
| 32 set_shutdown_delay_cb_(std::move(set_shutdown_delay_cb)) {} |
32 | 33 |
33 ServiceImpl::~ServiceImpl() = default; | 34 VideoCaptureServiceImpl::~VideoCaptureServiceImpl() {} |
34 | 35 |
35 void ServiceImpl::OnBindInterface( | 36 void VideoCaptureServiceImpl::ConnectToDeviceFactory( |
36 const service_manager::ServiceInfo& source_info, | 37 mojom::DeviceFactoryRequest request) { |
37 const std::string& interface_name, | |
38 mojo::ScopedMessagePipeHandle interface_pipe) { | |
39 registry_.BindInterface(source_info.identity, interface_name, | |
40 std::move(interface_pipe)); | |
41 } | |
42 | |
43 void ServiceImpl::Create(const service_manager::Identity& remote_identity, | |
44 mojom::ServiceRequest request) { | |
45 service_bindings_.AddBinding(this, std::move(request)); | |
46 } | |
47 | |
48 void ServiceImpl::ConnectToDeviceFactory(mojom::DeviceFactoryRequest request) { | |
49 LazyInitializeDeviceFactory(); | 38 LazyInitializeDeviceFactory(); |
50 factory_bindings_.AddBinding(device_factory_.get(), std::move(request)); | 39 factory_bindings_.AddBinding(device_factory_.get(), std::move(request)); |
51 } | 40 } |
52 | 41 |
53 void ServiceImpl::ConnectToFakeDeviceFactory( | 42 void VideoCaptureServiceImpl::ConnectToFakeDeviceFactory( |
54 mojom::DeviceFactoryRequest request) { | 43 mojom::DeviceFactoryRequest request) { |
55 LazyInitializeFakeDeviceFactory(); | 44 LazyInitializeFakeDeviceFactory(); |
56 fake_factory_bindings_.AddBinding(fake_device_factory_.get(), | 45 fake_factory_bindings_.AddBinding(fake_device_factory_.get(), |
57 std::move(request)); | 46 std::move(request)); |
58 } | 47 } |
59 | 48 |
60 void ServiceImpl::LazyInitializeDeviceFactory() { | 49 void VideoCaptureServiceImpl::SetShutdownDelayInSeconds(float seconds) { |
| 50 set_shutdown_delay_cb_.Run(seconds); |
| 51 } |
| 52 |
| 53 void VideoCaptureServiceImpl::LazyInitializeDeviceFactory() { |
61 if (device_factory_) | 54 if (device_factory_) |
62 return; | 55 return; |
63 | 56 |
64 // Create the platform-specific device factory. | 57 // Create the platform-specific device factory. |
65 // Task runner does not seem to actually be used. | 58 // The task runner passed to CreateFactory is used for things that need to |
| 59 // happen on a "UI thread equivalent", e.g. obtaining screen rotation on |
| 60 // Chrome OS. |
66 std::unique_ptr<media::VideoCaptureDeviceFactory> media_device_factory = | 61 std::unique_ptr<media::VideoCaptureDeviceFactory> media_device_factory = |
67 media::VideoCaptureDeviceFactory::CreateFactory( | 62 media::VideoCaptureDeviceFactory::CreateFactory( |
68 base::MessageLoop::current()->task_runner()); | 63 base::ThreadTaskRunnerHandle::Get()); |
69 auto video_capture_system = base::MakeUnique<media::VideoCaptureSystemImpl>( | 64 auto video_capture_system = base::MakeUnique<media::VideoCaptureSystemImpl>( |
70 std::move(media_device_factory)); | 65 std::move(media_device_factory)); |
71 | 66 |
72 device_factory_ = base::MakeUnique<DeviceFactoryMediaToMojoAdapter>( | 67 device_factory_ = base::MakeUnique<DeviceFactoryMediaToMojoAdapter>( |
73 std::move(video_capture_system), base::Bind(CreateJpegDecoder)); | 68 service_ref_->Clone(), std::move(video_capture_system), |
| 69 base::Bind(CreateJpegDecoder)); |
74 } | 70 } |
75 | 71 |
76 void ServiceImpl::LazyInitializeFakeDeviceFactory() { | 72 void VideoCaptureServiceImpl::LazyInitializeFakeDeviceFactory() { |
77 if (fake_device_factory_) | 73 if (fake_device_factory_) |
78 return; | 74 return; |
79 | 75 |
80 auto factory = base::MakeUnique<media::FakeVideoCaptureDeviceFactory>(); | 76 auto factory = base::MakeUnique<media::FakeVideoCaptureDeviceFactory>(); |
81 auto video_capture_system = | 77 auto video_capture_system = |
82 base::MakeUnique<media::VideoCaptureSystemImpl>(std::move(factory)); | 78 base::MakeUnique<media::VideoCaptureSystemImpl>(std::move(factory)); |
83 | 79 |
84 fake_device_factory_ = base::MakeUnique<DeviceFactoryMediaToMojoAdapter>( | 80 fake_device_factory_ = base::MakeUnique<DeviceFactoryMediaToMojoAdapter>( |
85 std::move(video_capture_system), base::Bind(&CreateJpegDecoder)); | 81 service_ref_->Clone(), std::move(video_capture_system), |
| 82 base::Bind(&CreateJpegDecoder)); |
86 } | 83 } |
87 | 84 |
88 } // namespace video_capture | 85 } // namespace video_capture |
OLD | NEW |