OLD | NEW |
---|---|
(Empty) | |
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 | |
3 // found in the LICENSE file. | |
4 | |
5 #include <algorithm> | |
6 | |
7 #include "base/bind.h" | |
8 #include "base/location.h" | |
9 #include "base/memory/ptr_util.h" | |
10 #include "base/synchronization/lock.h" | |
11 #include "base/threading/thread_task_runner_handle.h" | |
12 #include "content/renderer/media/audio_device_factory.h" | |
13 #include "content/renderer/media/audio_renderer_sink_cache_impl.h" | |
14 #include "media/audio/audio_device_description.h" | |
15 #include "media/base/audio_renderer_sink.h" | |
16 #include "url/origin.h" | |
17 | |
18 namespace content { | |
19 | |
20 constexpr int kDeleteTimeoutMs = 5000; | |
21 | |
22 // Cached sink data. | |
23 struct AudioRendererSinkCacheImpl::CacheEntry { | |
24 int source_render_frame_id; | |
25 std::string device_id; | |
26 url::Origin security_origin; | |
27 scoped_refptr<media::AudioRendererSink> sink; // Sink instance | |
28 bool used; // True if in use by a client. | |
29 }; | |
30 | |
31 // static | |
32 std::unique_ptr<AudioRendererSinkCache> AudioRendererSinkCache::Create() { | |
33 return base::WrapUnique(new AudioRendererSinkCacheImpl( | |
34 base::ThreadTaskRunnerHandle::Get(), | |
35 base::Bind(AudioDeviceFactory::NewAudioRendererMixerSink), | |
36 base::TimeDelta::FromMilliseconds(kDeleteTimeoutMs))); | |
37 } | |
38 | |
39 AudioRendererSinkCacheImpl::AudioRendererSinkCacheImpl( | |
40 scoped_refptr<base::SingleThreadTaskRunner> task_runner, | |
41 const CreateSinkCallback& create_sink_cb, | |
42 base::TimeDelta delete_timeout) | |
43 : task_runner_(std::move(task_runner)), | |
44 create_sink_cb_(create_sink_cb), | |
45 delete_timeout_(delete_timeout), | |
46 weak_ptr_factory_(this) { | |
47 weak_this_ = weak_ptr_factory_.GetWeakPtr(); | |
48 } | |
49 | |
50 AudioRendererSinkCacheImpl::~AudioRendererSinkCacheImpl() { | |
51 // We just release all the cached sinks here. | |
52 } | |
53 | |
54 media::OutputDeviceInfo AudioRendererSinkCacheImpl::GetSinkInfo( | |
55 int source_render_frame_id, | |
56 int session_id, | |
57 const std::string& device_id, | |
58 const url::Origin& security_origin) { | |
59 CacheEntry cache_entry = {source_render_frame_id, | |
60 std::string() /* device_id */, security_origin, | |
61 nullptr /* sink */, false /* not used */}; | |
62 | |
63 if (media::AudioDeviceDescription::UseSessionIdToSelectDevice(session_id, | |
64 device_id)) { | |
65 // We are provided with session id instead of device id. Session id is | |
66 // unique, so we can't find any matching sink. Creating a new one. | |
67 cache_entry.sink = create_sink_cb_.Run(source_render_frame_id, session_id, | |
68 device_id, security_origin); | |
69 cache_entry.device_id = cache_entry.sink->GetOutputDeviceInfo().device_id(); | |
70 | |
71 DVLOG(1) << "GetSinkInfo: address: " << cache_entry.sink.get() | |
Guido Urdaneta
2016/05/25 13:33:14
Consider removing these DVLOG statements.
o1ka
2016/05/25 14:52:11
You mean - ALL??? :) If reviewers insist I'll do i
Guido Urdaneta
2016/05/25 15:44:09
No big deal, really. It's up to you :)
o1ka
2016/05/26 09:00:27
Acknowledged.
| |
72 << " - used session to create new sink."; | |
73 | |
74 // Cache a newly-created sink. | |
75 base::AutoLock auto_lock(cache_lock_); | |
76 cache_.push_back(cache_entry); | |
77 | |
78 } else { | |
79 // Ignore session id. | |
80 base::AutoLock auto_lock(cache_lock_); | |
81 | |
82 auto cache_iter = | |
83 FindCacheEntry_Locked(source_render_frame_id, device_id, | |
84 security_origin, false /* unused_only */); | |
85 | |
86 if (cache_iter != cache_.end()) { | |
87 // A matching cached sink is found. | |
88 DVLOG(1) << "GetSinkInfo: address: " << cache_iter->sink.get() | |
89 << " - reused a cached sink."; | |
90 | |
91 return cache_iter->sink->GetOutputDeviceInfo(); | |
92 } | |
93 | |
94 // No matching sink found, create a new one. | |
95 cache_entry.device_id = device_id; | |
96 cache_entry.sink = create_sink_cb_.Run( | |
97 source_render_frame_id, 0 /* session_id */, device_id, security_origin); | |
98 | |
99 DVLOG(1) << "GetSinkInfo: address: " << cache_entry.sink.get() | |
100 << " - no matching cached sink found, created a new one."; | |
101 | |
102 // Cache a newly-created sink. | |
103 cache_.push_back(cache_entry); | |
104 } | |
105 | |
106 // Schedule it for deletion. | |
107 DeleteLaterIfUnused(cache_entry.sink.get()); | |
108 | |
109 DVLOG(1) << "GetSinkInfo: address: " << cache_entry.sink.get() | |
110 << " created. source_render_frame_id: " << source_render_frame_id | |
111 << " session_id: " << session_id << " device_id: " << device_id | |
112 << " security_origin: " << security_origin; | |
113 | |
114 return cache_entry.sink->GetOutputDeviceInfo(); | |
115 } | |
116 | |
117 scoped_refptr<media::AudioRendererSink> AudioRendererSinkCacheImpl::GetSink( | |
118 int source_render_frame_id, | |
119 const std::string& device_id, | |
120 const url::Origin& security_origin) { | |
121 base::AutoLock auto_lock(cache_lock_); | |
122 | |
123 auto cache_iter = | |
124 FindCacheEntry_Locked(source_render_frame_id, device_id, security_origin, | |
125 true /* unused_only */); | |
126 | |
127 if (cache_iter != cache_.end()) { | |
128 // Found unused sink; mark it as used and return. | |
129 DVLOG(1) << "GetSink: address: " << cache_iter->sink.get() | |
130 << " - found unused cached sink, reusing it."; | |
131 | |
132 cache_iter->used = true; | |
133 return cache_iter->sink; | |
134 } | |
135 | |
136 // No unused sink is found, create one, mark it used, cache it and return. | |
137 CacheEntry cache_entry = { | |
138 source_render_frame_id, device_id, security_origin, | |
139 create_sink_cb_.Run(source_render_frame_id, 0 /* session_id */, device_id, | |
140 security_origin), | |
141 true /* used */}; | |
142 | |
143 cache_.push_back(cache_entry); | |
144 | |
145 DVLOG(1) << "GetSink: address: " << cache_entry.sink.get() | |
146 << " - no unused cached sink found, created a new one." | |
147 << " source_render_frame_id: " << source_render_frame_id | |
148 << " device_id: " << device_id | |
149 << " security_origin: " << security_origin; | |
150 return cache_entry.sink; | |
151 } | |
152 | |
153 void AudioRendererSinkCacheImpl::ReleaseSink( | |
154 const media::AudioRendererSink* sink_ptr) { | |
155 // We don't know the sink state, so won't reuse it. Delete it immediately. | |
156 DeleteSink(sink_ptr, true); | |
157 } | |
158 | |
159 void AudioRendererSinkCacheImpl::DeleteLaterIfUnused( | |
160 const media::AudioRendererSink* sink_ptr) { | |
161 DVLOG(1) << "DeleteLaterIfUnused: address: " << sink_ptr; | |
162 | |
163 task_runner_->PostDelayedTask( | |
164 FROM_HERE, base::Bind(&AudioRendererSinkCacheImpl::DeleteSink, weak_this_, | |
165 sink_ptr, false /*do not delete if used*/), | |
166 delete_timeout_); | |
167 } | |
168 | |
169 void AudioRendererSinkCacheImpl::DeleteSink( | |
170 const media::AudioRendererSink* sink_ptr, | |
171 bool force_delete_used) { | |
172 DCHECK(sink_ptr); | |
173 | |
174 scoped_refptr<media::AudioRendererSink> sink_to_stop; | |
175 | |
176 { | |
177 base::AutoLock auto_lock(cache_lock_); | |
178 | |
179 // Looking up the sink by its pointer. | |
180 auto cache_iter = std::find_if(cache_.begin(), cache_.end(), | |
181 [sink_ptr](const CacheEntry& val) { | |
182 return val.sink.get() == sink_ptr; | |
183 }); | |
184 | |
185 if (cache_iter == cache_.end()) { | |
186 // If we got here and |force_delete_used| is not set it means the sink | |
Guido Urdaneta
2016/05/25 13:33:14
remove "we got here and"
o1ka
2016/05/25 14:52:11
Done.
| |
187 // scheduled for deletion get aquired and released before scheduled | |
Guido Urdaneta
2016/05/25 13:33:13
typo: s/get/got
o1ka
2016/05/25 14:52:11
Done.
| |
188 // deletion - this is ok. | |
189 DCHECK(!force_delete_used) | |
190 << "DeleteSink: address: " << sink_ptr | |
191 << " could not find a sink which is supposed to be in use"; | |
192 | |
193 DVLOG(1) << "DeleteSink: address: " << sink_ptr | |
194 << " force_delete_used = true - already deleted."; | |
195 return; | |
196 } | |
197 | |
198 // When |force_delete_used| is set, it's expected that we are deleting a | |
199 // used sink. | |
200 DCHECK((!force_delete_used) || (force_delete_used && cache_iter->used)) | |
201 << "Attempt to delete a non-aquired sink."; | |
202 | |
203 if (!force_delete_used && cache_iter->used) { | |
204 DVLOG(1) << "DeleteSink: address: " << sink_ptr | |
205 << " sink in use, skipping deletion."; | |
206 return; | |
207 } | |
208 | |
209 // To stop the sink before deletion if it's not used, we need to hold | |
210 // a ref to it. | |
211 if (!cache_iter->used) | |
212 sink_to_stop = cache_iter->sink; | |
213 | |
214 cache_.erase(cache_iter); | |
215 DVLOG(1) << "DeleteSink: address: " << sink_ptr; | |
216 } // Lock scope; | |
217 | |
218 // Stop the sink out of the lock scope. | |
219 if (sink_to_stop.get()) { | |
220 DCHECK_EQ(sink_ptr, sink_to_stop.get()); | |
221 sink_to_stop->Stop(); | |
222 DVLOG(1) << "DeleteSink: address: " << sink_ptr << " stopped."; | |
223 } | |
224 } | |
225 | |
226 AudioRendererSinkCacheImpl::CacheContainer::iterator | |
227 AudioRendererSinkCacheImpl::FindCacheEntry_Locked( | |
228 int source_render_frame_id, | |
229 const std::string& device_id, | |
230 const url::Origin& security_origin, | |
231 bool unused_only) { | |
232 return std::find_if( | |
233 cache_.begin(), cache_.end(), | |
234 [source_render_frame_id, &device_id, &security_origin, | |
235 unused_only](const CacheEntry& val) { | |
236 if (val.used && unused_only) | |
237 return false; | |
238 if (val.source_render_frame_id != source_render_frame_id) | |
239 return false; | |
240 if (media::AudioDeviceDescription::IsDefaultDevice(device_id) && | |
241 media::AudioDeviceDescription::IsDefaultDevice(val.device_id)) { | |
242 // Both device IDs represent the same default device => do not compare | |
243 // them; the default device is always authorized => ignore security | |
244 // origin. | |
245 return true; | |
246 } | |
247 return val.device_id == device_id && | |
248 val.security_origin == security_origin; | |
249 }); | |
250 }; | |
251 | |
252 int AudioRendererSinkCacheImpl::GetCacheSizeForTesting() { | |
253 return cache_.size(); | |
254 } | |
255 | |
256 } // namespace content | |
OLD | NEW |