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 15 matching lines @@
   }
 }
 
 void RemotingRendererController::OnSessionStateChanged() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   VLOG(1) << "OnSessionStateChanged: " << remoting_source_->state();
   if (!sink_available_changed_cb_.is_null())
     sink_available_changed_cb_.Run(IsRemoteSinkAvailable());
 
+  UpdateInterstitial();
   UpdateAndMaybeSwitch();
 }
 
 bool RemotingRendererController::IsRemoteSinkAvailable() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   switch (remoting_source_->state()) {
     case SESSION_CAN_START:
     case SESSION_STARTING:
     case SESSION_STARTED:
@@ skipping 80 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;
   }
 }
 
 void RemotingRendererController::OnPlaying() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   is_paused_ = false;
   UpdateAndMaybeSwitch();
 }
@@ skipping 89 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 (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:
+    case SESSION_STOPPING:
+      break;
+  }
+
+  // TODO(xjz): Download poster image when available.
+  show_interstitial_cb_.Run(SkBitmap(), pipeline_metadata_.natural_size, type);
+}
+
 }  // namespace media