Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(67)

Side by Side Diff: media/remoting/remoting_renderer_controller.cc

Issue 2643253003: Media Remoting Clean-up: Less-redundant naming, style consistency, etc. (Closed)
Patch Set: Addressed 1st-round comments. UserExperienceController->RendererController Created 3 years, 11 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
(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 "media/remoting/remoting_renderer_controller.h"
6
7 #include "base/bind.h"
8 #include "base/logging.h"
9 #include "base/threading/thread_checker.h"
10 #include "base/time/time.h"
11 #include "media/remoting/remoting_cdm_context.h"
12
13 namespace media {
14
15 RemotingRendererController::RemotingRendererController(
16 scoped_refptr<RemotingSourceImpl> remoting_source)
17 : remoting_source_(remoting_source), weak_factory_(this) {
18 remoting_source_->AddClient(this);
19 }
20
21 RemotingRendererController::~RemotingRendererController() {
22 DCHECK(thread_checker_.CalledOnValidThread());
23 metrics_recorder_.WillStopSession(remoting::MEDIA_ELEMENT_DESTROYED);
24 remoting_source_->RemoveClient(this);
25 }
26
27 void RemotingRendererController::OnStarted(bool success) {
28 DCHECK(thread_checker_.CalledOnValidThread());
29
30 if (success) {
31 VLOG(1) << "Remoting started successively.";
32 if (remote_rendering_started_) {
33 metrics_recorder_.DidStartSession();
34 DCHECK(!switch_renderer_cb_.is_null());
35 switch_renderer_cb_.Run();
36 } else {
37 remoting_source_->StopRemoting(this);
38 }
39 } else {
40 VLOG(1) << "Failed to start remoting.";
41 remote_rendering_started_ = false;
42 metrics_recorder_.WillStopSession(remoting::START_RACE);
43 }
44 }
45
46 void RemotingRendererController::OnSessionStateChanged() {
47 DCHECK(thread_checker_.CalledOnValidThread());
48 UpdateFromSessionState(remoting::SINK_AVAILABLE, remoting::ROUTE_TERMINATED);
49 }
50
51 void RemotingRendererController::UpdateFromSessionState(
52 remoting::StartTrigger start_trigger,
53 remoting::StopTrigger stop_trigger) {
54 VLOG(1) << "UpdateFromSessionState: " << remoting_source_->state();
55 if (!sink_available_changed_cb_.is_null())
56 sink_available_changed_cb_.Run(IsRemoteSinkAvailable());
57
58 UpdateInterstitial(base::nullopt);
59 UpdateAndMaybeSwitch(start_trigger, stop_trigger);
60 }
61
62 bool RemotingRendererController::IsRemoteSinkAvailable() {
63 DCHECK(thread_checker_.CalledOnValidThread());
64
65 switch (remoting_source_->state()) {
66 case SESSION_CAN_START:
67 case SESSION_STARTING:
68 case SESSION_STARTED:
69 return true;
70 case SESSION_UNAVAILABLE:
71 case SESSION_STOPPING:
72 case SESSION_PERMANENTLY_STOPPED:
73 return false;
74 }
75
76 return false; // To suppress compile warning.
77 }
78
79 void RemotingRendererController::OnEnteredFullscreen() {
80 DCHECK(thread_checker_.CalledOnValidThread());
81
82 is_fullscreen_ = true;
83 // See notes in OnBecameDominantVisibleContent() for why this is forced:
84 is_dominant_content_ = true;
85 UpdateAndMaybeSwitch(remoting::ENTERED_FULLSCREEN,
86 remoting::UNKNOWN_STOP_TRIGGER);
87 }
88
89 void RemotingRendererController::OnExitedFullscreen() {
90 DCHECK(thread_checker_.CalledOnValidThread());
91
92 is_fullscreen_ = false;
93 // See notes in OnBecameDominantVisibleContent() for why this is forced:
94 is_dominant_content_ = false;
95 UpdateAndMaybeSwitch(remoting::UNKNOWN_START_TRIGGER,
96 remoting::EXITED_FULLSCREEN);
97 }
98
99 void RemotingRendererController::OnBecameDominantVisibleContent(
100 bool is_dominant) {
101 DCHECK(thread_checker_.CalledOnValidThread());
102
103 // Two scenarios where "dominance" status mixes with fullscreen transitions:
104 //
105 // 1. Just before/after entering fullscreen, the element will, of course,
106 // become the dominant on-screen content via automatic page layout.
107 // 2. Just before/after exiting fullscreen, the element may or may not
108 // shrink in size enough to become non-dominant. However, exiting
109 // fullscreen was caused by a user action that explicitly indicates a
110 // desire to exit remoting, so even if the element is still dominant,
111 // remoting should be shut down.
112 //
113 // Thus, to achieve the desired behaviors, |is_dominant_content_| is force-set
114 // in OnEnteredFullscreen() and OnExitedFullscreen(), and changes to it here
115 // are ignored while in fullscreen.
116 if (is_fullscreen_)
117 return;
118
119 is_dominant_content_ = is_dominant;
120 UpdateAndMaybeSwitch(remoting::BECAME_DOMINANT_CONTENT,
121 remoting::BECAME_AUXILIARY_CONTENT);
122 }
123
124 void RemotingRendererController::OnSetCdm(CdmContext* cdm_context) {
125 DCHECK(thread_checker_.CalledOnValidThread());
126
127 auto* remoting_cdm_context = RemotingCdmContext::From(cdm_context);
128 if (!remoting_cdm_context)
129 return;
130
131 remoting_source_->RemoveClient(this);
132 remoting_source_ = remoting_cdm_context->GetRemotingSource();
133 remoting_source_->AddClient(this);
134 UpdateFromSessionState(remoting::CDM_READY, remoting::DECRYPTION_ERROR);
135 }
136
137 void RemotingRendererController::OnRemotePlaybackDisabled(bool disabled) {
138 DCHECK(thread_checker_.CalledOnValidThread());
139
140 is_remote_playback_disabled_ = disabled;
141 metrics_recorder_.OnRemotePlaybackDisabled(disabled);
142 UpdateAndMaybeSwitch(remoting::ENABLED_BY_PAGE, remoting::DISABLED_BY_PAGE);
143 }
144
145 void RemotingRendererController::OnSetPoster(const GURL& poster_url) {
146 DCHECK(thread_checker_.CalledOnValidThread());
147
148 if (poster_url != poster_url_) {
149 poster_url_ = poster_url;
150 if (poster_url_.is_empty())
151 UpdateInterstitial(SkBitmap());
152 else
153 DownloadPosterImage();
154 }
155 }
156
157 void RemotingRendererController::SetSwitchRendererCallback(
158 const base::Closure& cb) {
159 DCHECK(thread_checker_.CalledOnValidThread());
160 DCHECK(!cb.is_null());
161
162 switch_renderer_cb_ = cb;
163 // Note: Not calling UpdateAndMaybeSwitch() here since this method should be
164 // called during the initialization phase of this RemotingRendererController;
165 // and definitely before a whole lot of other things that are needed to
166 // trigger a switch.
167 }
168
169 void RemotingRendererController::SetRemoteSinkAvailableChangedCallback(
170 const base::Callback<void(bool)>& cb) {
171 DCHECK(thread_checker_.CalledOnValidThread());
172
173 sink_available_changed_cb_ = cb;
174 if (!sink_available_changed_cb_.is_null())
175 sink_available_changed_cb_.Run(IsRemoteSinkAvailable());
176 }
177
178 base::WeakPtr<remoting::RpcBroker> RemotingRendererController::GetRpcBroker()
179 const {
180 DCHECK(thread_checker_.CalledOnValidThread());
181
182 return remoting_source_->GetRpcBroker()->GetWeakPtr();
183 }
184
185 void RemotingRendererController::StartDataPipe(
186 std::unique_ptr<mojo::DataPipe> audio_data_pipe,
187 std::unique_ptr<mojo::DataPipe> video_data_pipe,
188 const RemotingSourceImpl::DataPipeStartCallback& done_callback) {
189 DCHECK(thread_checker_.CalledOnValidThread());
190
191 remoting_source_->StartDataPipe(std::move(audio_data_pipe),
192 std::move(video_data_pipe), done_callback);
193 }
194
195 void RemotingRendererController::OnMetadataChanged(
196 const PipelineMetadata& metadata) {
197 DCHECK(thread_checker_.CalledOnValidThread());
198
199 const gfx::Size old_size = pipeline_metadata_.natural_size;
200 const bool was_audio_codec_supported = has_audio() && IsAudioCodecSupported();
201 const bool was_video_codec_supported = has_video() && IsVideoCodecSupported();
202 pipeline_metadata_ = metadata;
203 const bool is_audio_codec_supported = has_audio() && IsAudioCodecSupported();
204 const bool is_video_codec_supported = has_video() && IsVideoCodecSupported();
205 metrics_recorder_.OnPipelineMetadataChanged(metadata);
206
207 is_encrypted_ = false;
208 if (has_video())
209 is_encrypted_ |= metadata.video_decoder_config.is_encrypted();
210 if (has_audio())
211 is_encrypted_ |= metadata.audio_decoder_config.is_encrypted();
212
213 if (pipeline_metadata_.natural_size != old_size)
214 UpdateInterstitial(base::nullopt);
215
216 remoting::StartTrigger start_trigger = remoting::UNKNOWN_START_TRIGGER;
217 if (!was_audio_codec_supported && is_audio_codec_supported)
218 start_trigger = remoting::SUPPORTED_AUDIO_CODEC;
219 if (!was_video_codec_supported && is_video_codec_supported) {
220 start_trigger = start_trigger == remoting::SUPPORTED_AUDIO_CODEC
221 ? remoting::SUPPORTED_AUDIO_AND_VIDEO_CODECS
222 : remoting::SUPPORTED_VIDEO_CODEC;
223 }
224 remoting::StopTrigger stop_trigger = remoting::UNKNOWN_STOP_TRIGGER;
225 if (was_audio_codec_supported && !is_audio_codec_supported)
226 stop_trigger = remoting::UNSUPPORTED_AUDIO_CODEC;
227 if (was_video_codec_supported && !is_video_codec_supported) {
228 stop_trigger = stop_trigger == remoting::UNSUPPORTED_AUDIO_CODEC
229 ? remoting::UNSUPPORTED_AUDIO_AND_VIDEO_CODECS
230 : remoting::UNSUPPORTED_VIDEO_CODEC;
231 }
232 UpdateAndMaybeSwitch(start_trigger, stop_trigger);
233 }
234
235 bool RemotingRendererController::IsVideoCodecSupported() {
236 DCHECK(thread_checker_.CalledOnValidThread());
237 DCHECK(has_video());
238
239 switch (pipeline_metadata_.video_decoder_config.codec()) {
240 case VideoCodec::kCodecH264:
241 case VideoCodec::kCodecVP8:
242 return true;
243 default:
244 VLOG(2) << "Remoting does not support video codec: "
245 << pipeline_metadata_.video_decoder_config.codec();
246 return false;
247 }
248 }
249
250 bool RemotingRendererController::IsAudioCodecSupported() {
251 DCHECK(thread_checker_.CalledOnValidThread());
252 DCHECK(has_audio());
253
254 switch (pipeline_metadata_.audio_decoder_config.codec()) {
255 case AudioCodec::kCodecAAC:
256 case AudioCodec::kCodecMP3:
257 case AudioCodec::kCodecPCM:
258 case AudioCodec::kCodecVorbis:
259 case AudioCodec::kCodecFLAC:
260 case AudioCodec::kCodecAMR_NB:
261 case AudioCodec::kCodecAMR_WB:
262 case AudioCodec::kCodecPCM_MULAW:
263 case AudioCodec::kCodecGSM_MS:
264 case AudioCodec::kCodecPCM_S16BE:
265 case AudioCodec::kCodecPCM_S24BE:
266 case AudioCodec::kCodecOpus:
267 case AudioCodec::kCodecEAC3:
268 case AudioCodec::kCodecPCM_ALAW:
269 case AudioCodec::kCodecALAC:
270 case AudioCodec::kCodecAC3:
271 return true;
272 default:
273 VLOG(2) << "Remoting does not support audio codec: "
274 << pipeline_metadata_.audio_decoder_config.codec();
275 return false;
276 }
277 }
278
279 void RemotingRendererController::OnPlaying() {
280 DCHECK(thread_checker_.CalledOnValidThread());
281
282 is_paused_ = false;
283 UpdateAndMaybeSwitch(remoting::PLAY_COMMAND, remoting::UNKNOWN_STOP_TRIGGER);
284 }
285
286 void RemotingRendererController::OnPaused() {
287 DCHECK(thread_checker_.CalledOnValidThread());
288
289 is_paused_ = true;
290 }
291
292 bool RemotingRendererController::ShouldBeRemoting() {
293 DCHECK(thread_checker_.CalledOnValidThread());
294
295 if (switch_renderer_cb_.is_null()) {
296 DCHECK(!remote_rendering_started_);
297 return false; // No way to switch to a RemotingRenderImpl.
298 }
299
300 const RemotingSessionState state = remoting_source_->state();
301 if (is_encrypted_) {
302 // Due to technical limitations when playing encrypted content, once a
303 // remoting session has been started, always return true here to indicate
304 // that the RemotingRendererImpl should be used. In the stopped states,
305 // RemotingRendererImpl will display an interstitial to notify the user that
306 // local rendering cannot be resumed.
307 //
308 // TODO(miu): Revisit this once more of the encrypted-remoting impl is
309 // in-place. For example, this will prevent metrics from recording session
310 // stop reasons.
311 return state == RemotingSessionState::SESSION_STARTED ||
312 state == RemotingSessionState::SESSION_STOPPING ||
313 state == RemotingSessionState::SESSION_PERMANENTLY_STOPPED;
314 }
315
316 if (encountered_renderer_fatal_error_)
317 return false;
318
319 switch (state) {
320 case SESSION_UNAVAILABLE:
321 return false; // Cannot remote media without a remote sink.
322 case SESSION_CAN_START:
323 case SESSION_STARTING:
324 case SESSION_STARTED:
325 break; // Media remoting is possible, assuming other requirments are met.
326 case SESSION_STOPPING:
327 case SESSION_PERMANENTLY_STOPPED:
328 return false; // Use local rendering after stopping remoting.
329 }
330
331 switch (remoting_source_->sink_capabilities()) {
332 case mojom::RemotingSinkCapabilities::NONE:
333 return false;
334 case mojom::RemotingSinkCapabilities::RENDERING_ONLY:
335 case mojom::RemotingSinkCapabilities::CONTENT_DECRYPTION_AND_RENDERING:
336 break; // The sink is capable of remote rendering.
337 }
338
339 if ((!has_audio() && !has_video()) ||
340 (has_video() && !IsVideoCodecSupported()) ||
341 (has_audio() && !IsAudioCodecSupported())) {
342 return false;
343 }
344
345 if (is_remote_playback_disabled_)
346 return false;
347
348 // Normally, entering fullscreen or being the dominant visible content is the
349 // signal that starts remote rendering. However, current technical limitations
350 // require encrypted content be remoted without waiting for a user signal.
351 return is_fullscreen_ || is_dominant_content_;
352 }
353
354 void RemotingRendererController::UpdateAndMaybeSwitch(
355 remoting::StartTrigger start_trigger,
356 remoting::StopTrigger stop_trigger) {
357 DCHECK(thread_checker_.CalledOnValidThread());
358
359 bool should_be_remoting = ShouldBeRemoting();
360
361 if (remote_rendering_started_ == should_be_remoting)
362 return;
363
364 // Only switch to remoting when media is playing. Since the renderer is
365 // created when video starts loading/playing, receiver will display a black
366 // screen before video starts playing if switching to remoting when paused.
367 // Thus, the user experience is improved by not starting remoting until
368 // playback resumes.
369 if (should_be_remoting && is_paused_)
370 return;
371
372 // Switch between local renderer and remoting renderer.
373 remote_rendering_started_ = should_be_remoting;
374
375 if (remote_rendering_started_) {
376 DCHECK(!switch_renderer_cb_.is_null());
377 if (remoting_source_->state() ==
378 RemotingSessionState::SESSION_PERMANENTLY_STOPPED) {
379 switch_renderer_cb_.Run();
380 return;
381 }
382 DCHECK_NE(start_trigger, remoting::UNKNOWN_START_TRIGGER);
383 metrics_recorder_.WillStartSession(start_trigger);
384 // |switch_renderer_cb_.Run()| will be called after remoting is started
385 // successfully.
386 remoting_source_->StartRemoting(this);
387 } else {
388 // For encrypted content, it's only valid to switch to remoting renderer,
389 // and never back to the local renderer. The RemotingCdmController will
390 // force-stop the session when remoting has ended; so no need to call
391 // StopRemoting() from here.
392 DCHECK(!is_encrypted_);
393 DCHECK_NE(stop_trigger, remoting::UNKNOWN_STOP_TRIGGER);
394 metrics_recorder_.WillStopSession(stop_trigger);
395 switch_renderer_cb_.Run();
396 remoting_source_->StopRemoting(this);
397 }
398 }
399
400 void RemotingRendererController::SetShowInterstitialCallback(
401 const ShowInterstitialCallback& cb) {
402 DCHECK(thread_checker_.CalledOnValidThread());
403 show_interstitial_cb_ = cb;
404 UpdateInterstitial(SkBitmap());
405 if (!poster_url_.is_empty())
406 DownloadPosterImage();
407 }
408
409 void RemotingRendererController::SetDownloadPosterCallback(
410 const DownloadPosterCallback& cb) {
411 DCHECK(thread_checker_.CalledOnValidThread());
412 DCHECK(download_poster_cb_.is_null());
413 download_poster_cb_ = cb;
414 if (!poster_url_.is_empty())
415 DownloadPosterImage();
416 }
417
418 void RemotingRendererController::UpdateInterstitial(
419 const base::Optional<SkBitmap>& image) {
420 DCHECK(thread_checker_.CalledOnValidThread());
421 if (show_interstitial_cb_.is_null() ||
422 pipeline_metadata_.natural_size.IsEmpty())
423 return;
424
425 RemotingInterstitialType type = RemotingInterstitialType::BETWEEN_SESSIONS;
426 switch (remoting_source_->state()) {
427 case SESSION_STARTED:
428 type = RemotingInterstitialType::IN_SESSION;
429 break;
430 case SESSION_PERMANENTLY_STOPPED:
431 type = RemotingInterstitialType::ENCRYPTED_MEDIA_FATAL_ERROR;
432 break;
433 case SESSION_UNAVAILABLE:
434 case SESSION_CAN_START:
435 case SESSION_STARTING:
436 case SESSION_STOPPING:
437 break;
438 }
439
440 show_interstitial_cb_.Run(image, pipeline_metadata_.natural_size, type);
441 }
442
443 void RemotingRendererController::DownloadPosterImage() {
444 if (download_poster_cb_.is_null() || show_interstitial_cb_.is_null())
445 return;
446 DCHECK(!poster_url_.is_empty());
447
448 const base::TimeTicks download_start_time = base::TimeTicks::Now();
449 download_poster_cb_.Run(
450 poster_url_,
451 base::Bind(&RemotingRendererController::OnPosterImageDownloaded,
452 weak_factory_.GetWeakPtr(), poster_url_, download_start_time));
453 }
454
455 void RemotingRendererController::OnPosterImageDownloaded(
456 const GURL& download_url,
457 base::TimeTicks download_start_time,
458 const SkBitmap& image) {
459 DCHECK(thread_checker_.CalledOnValidThread());
460
461 metrics_recorder_.OnPosterImageDownloaded(
462 base::TimeTicks::Now() - download_start_time, !image.drawsNothing());
463 if (download_url != poster_url_)
464 return; // The poster image URL has changed during the download.
465 UpdateInterstitial(image);
466 }
467
468 void RemotingRendererController::OnRendererFatalError(
469 remoting::StopTrigger stop_trigger) {
470 DCHECK(thread_checker_.CalledOnValidThread());
471
472 // Do not act on errors caused by things like Mojo pipes being closed during
473 // shutdown.
474 if (!remote_rendering_started_)
475 return;
476
477 encountered_renderer_fatal_error_ = true;
478 UpdateAndMaybeSwitch(remoting::UNKNOWN_START_TRIGGER, stop_trigger);
479 }
480
481 } // namespace media
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698