Media Remoting: Update remoting interstitial when status changes.

media/remoting/remoting_renderer_controller.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/remoting/remoting_renderer_controller.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/threading/thread_checker.h"
+#include "media/base/video_util.h"
 #include "media/remoting/remoting_cdm_context.h"
 
 namespace media {
 
+namespace {
+
+gfx::Size GetRotatedVideoSize(VideoRotation rotation, gfx::Size natural_size) {
+  if (rotation == VIDEO_ROTATION_90 || rotation == VIDEO_ROTATION_270)
+    return gfx::Size(natural_size.height(), natural_size.width());
+  return natural_size;
+}
+
+}  // namespace
+
 RemotingRendererController::RemotingRendererController(
     scoped_refptr<RemotingSourceImpl> remoting_source)
     : remoting_source_(remoting_source), weak_factory_(this) {
   remoting_source_->AddClient(this);
 }
 
 RemotingRendererController::~RemotingRendererController() {
   DCHECK(thread_checker_.CalledOnValidThread());
   remoting_source_->RemoveClient(this);
 }
@@ skipping 12 matching lines @@
   } else {
     VLOG(1) << "Failed to start remoting.";
     remote_rendering_started_ = false;
   }
 }
 
 void RemotingRendererController::OnSessionStateChanged() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   VLOG(1) << "OnSessionStateChanged: " << remoting_source_->state();
+
+  UpdateInterstitial();
   UpdateAndMaybeSwitch();
 }
 
 void RemotingRendererController::OnEnteredFullscreen() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   is_fullscreen_ = true;
   UpdateAndMaybeSwitch();
 }
 
@@ skipping 40 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
 
   remoting_source_->StartDataPipe(std::move(audio_data_pipe),
                                   std::move(video_data_pipe), done_callback);
 }
 
 void RemotingRendererController::OnMetadataChanged(
     const PipelineMetadata& metadata) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
+  const gfx::Size old_size = pipeline_metadata_.natural_size;
   pipeline_metadata_ = metadata;
 
   is_encrypted_ = false;
   if (has_video()) {
-    video_decoder_config_ = metadata.video_decoder_config;
-    is_encrypted_ |= video_decoder_config_.is_encrypted();
+    is_encrypted_ |= metadata.video_decoder_config.is_encrypted();
+    pipeline_metadata_.natural_size = GetRotatedVideoSize(
+        pipeline_metadata_.video_rotation, pipeline_metadata_.natural_size);
   }
   if (has_audio()) {
-    audio_decoder_config_ = metadata.audio_decoder_config;
-    is_encrypted_ |= audio_decoder_config_.is_encrypted();
+    is_encrypted_ |= metadata.audio_decoder_config.is_encrypted();
   }
+
+  if (pipeline_metadata_.natural_size != old_size)
+    UpdateInterstitial();
+
   UpdateAndMaybeSwitch();
 }
 
 bool RemotingRendererController::IsVideoCodecSupported() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(has_video());
 
-  switch (video_decoder_config_.codec()) {
+  switch (pipeline_metadata_.video_decoder_config.codec()) {
     case VideoCodec::kCodecH264:
     case VideoCodec::kCodecVP8:
       return true;
     default:
       VLOG(2) << "Remoting does not support video codec: "
-              << video_decoder_config_.codec();
+              << pipeline_metadata_.video_decoder_config.codec();
       return false;
   }
 }
 
 bool RemotingRendererController::IsAudioCodecSupported() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(has_audio());
 
-  switch (audio_decoder_config_.codec()) {
+  switch (pipeline_metadata_.audio_decoder_config.codec()) {
     case AudioCodec::kCodecAAC:
     case AudioCodec::kCodecMP3:
     case AudioCodec::kCodecPCM:
     case AudioCodec::kCodecVorbis:
     case AudioCodec::kCodecFLAC:
     case AudioCodec::kCodecAMR_NB:
     case AudioCodec::kCodecAMR_WB:
     case AudioCodec::kCodecPCM_MULAW:
     case AudioCodec::kCodecGSM_MS:
     case AudioCodec::kCodecPCM_S16BE:
     case AudioCodec::kCodecPCM_S24BE:
     case AudioCodec::kCodecOpus:
     case AudioCodec::kCodecEAC3:
     case AudioCodec::kCodecPCM_ALAW:
     case AudioCodec::kCodecALAC:
     case AudioCodec::kCodecAC3:
       return true;
     default:
       VLOG(2) << "Remoting does not support audio codec: "
-              << audio_decoder_config_.codec();
+              << pipeline_metadata_.audio_decoder_config.codec();
       return false;
   }
 }
 
 bool RemotingRendererController::ShouldBeRemoting() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (switch_renderer_cb_.is_null())
     return false;  // No way to switch to a RemotingRenderImpl.
 
@@ skipping 66 matching lines @@
     // For encrypted content, it's only valid to switch to remoting renderer,
     // and never back to the local renderer. The RemotingCdmController will
     // force-stop the session when remoting has ended; so no need to call
     // StopRemoting() from here.
     DCHECK(!is_encrypted_);
     switch_renderer_cb_.Run();
     remoting_source_->StopRemoting(this);
   }
 }
 
+void RemotingRendererController::SetShowInterstitialCallback(
+    const ShowInterstitialCallback& cb) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  show_interstitial_cb_ = cb;
+  UpdateInterstitial();
+}
+
+void RemotingRendererController::UpdateInterstitial() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (!remote_rendering_started_ || show_interstitial_cb_.is_null() ||
+      pipeline_metadata_.natural_size.IsEmpty())
+    return;
+
+  RemotingInterstitialType type = RemotingInterstitialType::BETWEEN_SESSIONS;
+  switch (remoting_source_->state()) {
+    case SESSION_STARTED:
+      type = RemotingInterstitialType::IN_SESSION;
+      break;
+    case SESSION_PERMANENTLY_STOPPED:
+      type = RemotingInterstitialType::ENCRYPTED_MEDIA_FATAL_ERROR;
+      break;
+    case SESSION_UNAVAILABLE:
+    case SESSION_CAN_START:
+    case SESSION_STARTING:

[miu, 2016/12/20 21:21:04]

IMHO, we should show the "IN_SESSION" interstitial when in the SESSION_STARTING
state.

[xjz, 2016/12/20 22:15:37]

Why? We only need (and can only) show interstitial when RemoteRendererImpl is
created, which can not be in "SESSION_STARTING" state.

[miu, 2016/12/20 23:15:49]

tl;dr: Don't bake assumptions into your code when you don't have to.

We should try not to write code that makes assumptions about what code elsewhere
will or will not do. Code outside of this method will change, and so we should
try to make sure this method always does what it was intended to do. As I see
it, this method's purpose is to decide whether the interstitial *should* be
updated, and then which one should be showing, and then run the callback. It
does not know anything about why it was called, nor what the effects of running
the callback will be. It should do the same thing no matter what those
reasons/effects are.

At the most narrow scoping, we are looking at just this switch statement: Its
purpose is to map one or more RemotingSource states into a
RemotingInterstitialType. The mapping from "SESSION_STARTING" to "show the
BETWEEN_SESSIONS interstitial" is incorrect if you consider that and nothing
else.

None of this seems to matter now, but it is important in the long-run in order
to effectively manage large software systems. No one can hold perfectly detailed
knowledge of the entire codebase in their head at once; and so any given
developer's effectiveness is inversely proportional to the number of baked-in
assumptions in the existing code.

For example, what if in the future somebody (maybe not either of us) comes along
and re-works the whole interstitial UI? They want to make it so that
interstitials are rendered a bit earlier to give users a "snappier" response
when remoting is engaged. It would be nice if they could depend on the
UpdateInterstitial() method to work correctly regardless of the fact that the
conditions under which it is used have changed. With the code as you have it
now, they would encounter a bug and have to search through the codebase to
eventually find out that UpdateInterstitial() was choosing "BETWEEN_SESSIONS."
Then, they will assume the last developer had a good reason to map
"SESSION_STARTING" to "BETWEEN_SESSIONS." They really want to change it, but
will worry about whether changing it will break something else; and it will take
them time to convince themselves that it is actually safe to change it to
"IN_SESSION".

Make sense? ;-)

[xjz, 2016/12/20 23:54:54]

Thanks for the explanation. Learned a lot from your comments. :)  
As chatted face to face, still map the "SESSION_STARTING" to the
"BETWEEN_SESSIONS" interstitial, as it is the transient state between two
sessions. 

+    case SESSION_STOPPING:
+      return;

[miu, 2016/12/20 21:21:04]

I think you meant "break" instead of "return" here, so that we would paint the
"BETWEEN_SESSIONS" interstitial for these cases.

[xjz, 2016/12/20 22:15:37]

I mean "return" because we don't need to paint interstitial on other cases. The
"BETWEEN_SESSIONS" interstitial will only be painted by RemoteRendererImpl when
it is destructed. Is there any case that RemoteRendererImpl destructor is not
called whe n remoting session stops?

[miu, 2016/12/20 23:15:49]

This is another flavor of the prior comment: Don't assume what the callback will
or won't do. Just call it with the right value for the current situation. It may
have no effect, but it's not up to UpdateInterstitial() to have to know that.
Why should it matter to the code in UpdateInterstitial() what some other class's
destructor does? ;-)

[xjz, 2016/12/20 23:54:54]

Done. Thanks for the explanation. 
I see. Thanks. :)

+  }
+
+  // TODO(xjz): Download poster image when available.
+  show_interstitial_cb_.Run(SkBitmap(), pipeline_metadata_.natural_size, type);
+}
+
 }  // namespace media