Media Remoting: Remove old interstitial implementation.

media/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/renderer_controller.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/threading/thread_checker.h"
 #include "base/time/time.h"
@@ skipping 37 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   UpdateFromSessionState(SINK_AVAILABLE, ROUTE_TERMINATED);
 }
 
 void RendererController::UpdateFromSessionState(StartTrigger start_trigger,
                                                 StopTrigger stop_trigger) {
   VLOG(1) << "UpdateFromSessionState: " << session_->state();
   if (client_)
     client_->ActivateViewportIntersectionMonitoring(IsRemoteSinkAvailable());
 
-  UpdateInterstitial(base::nullopt);
   UpdateAndMaybeSwitch(start_trigger, stop_trigger);
 }
 
 bool RendererController::IsRemoteSinkAvailable() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   switch (session_->state()) {
     case SharedSession::SESSION_CAN_START:
     case SharedSession::SESSION_STARTING:
     case SharedSession::SESSION_STARTED:
@@ skipping 63 matching lines @@
 }
 
 void RendererController::OnRemotePlaybackDisabled(bool disabled) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   is_remote_playback_disabled_ = disabled;
   metrics_recorder_.OnRemotePlaybackDisabled(disabled);
   UpdateAndMaybeSwitch(ENABLED_BY_PAGE, DISABLED_BY_PAGE);
 }
 
-void RendererController::OnSetPoster(const GURL& poster_url) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-
-  if (poster_url != poster_url_) {
-    poster_url_ = poster_url;
-    if (poster_url_.is_empty())
-      UpdateInterstitial(SkBitmap());
-    else
-      DownloadPosterImage();
-  }
-}
-
 base::WeakPtr<RpcBroker> RendererController::GetRpcBroker() const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   return session_->rpc_broker()->GetWeakPtr();
 }
 
 void RendererController::StartDataPipe(
     std::unique_ptr<mojo::DataPipe> audio_data_pipe,
     std::unique_ptr<mojo::DataPipe> video_data_pipe,
     const SharedSession::DataPipeStartCallback& done_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   session_->StartDataPipe(std::move(audio_data_pipe),
                           std::move(video_data_pipe), done_callback);
 }
 
 void RendererController::OnMetadataChanged(const PipelineMetadata& metadata) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  const gfx::Size old_size = pipeline_metadata_.natural_size;
   const bool was_audio_codec_supported = has_audio() && IsAudioCodecSupported();
   const bool was_video_codec_supported = has_video() && IsVideoCodecSupported();
   pipeline_metadata_ = metadata;
   const bool is_audio_codec_supported = has_audio() && IsAudioCodecSupported();
   const bool is_video_codec_supported = has_video() && IsVideoCodecSupported();
   metrics_recorder_.OnPipelineMetadataChanged(metadata);
 
   is_encrypted_ = false;
   if (has_video())
     is_encrypted_ |= metadata.video_decoder_config.is_encrypted();
   if (has_audio())
     is_encrypted_ |= metadata.audio_decoder_config.is_encrypted();
 
-  if (pipeline_metadata_.natural_size != old_size)
-    UpdateInterstitial(base::nullopt);
-
   StartTrigger start_trigger = UNKNOWN_START_TRIGGER;
   if (!was_audio_codec_supported && is_audio_codec_supported)
     start_trigger = SUPPORTED_AUDIO_CODEC;
   if (!was_video_codec_supported && is_video_codec_supported) {
     start_trigger = start_trigger == SUPPORTED_AUDIO_CODEC
                         ? SUPPORTED_AUDIO_AND_VIDEO_CODECS
                         : SUPPORTED_VIDEO_CODEC;
   }
   StopTrigger stop_trigger = UNKNOWN_STOP_TRIGGER;
   if (was_audio_codec_supported && !is_audio_codec_supported)
@@ skipping 69 matching lines @@
   if (!client_) {
     DCHECK(!remote_rendering_started_);
     return false;  // No way to switch to the remoting renderer.
   }
 
   const SharedSession::SessionState state = session_->state();
   if (is_encrypted_) {
     // Due to technical limitations when playing encrypted content, once a
     // remoting session has been started, always return true here to indicate
     // that the CourierRenderer should continue to be used. In the stopped
-    // states, CourierRenderer will display an interstitial to notify the user
-    // that local rendering cannot be resumed.
+    // states, an interstitial will be shown to notify the user that local

[miu, 2017/04/13 02:15:10]

I'm wondering if we need this last sentence anymore. Maybe we could say,
"Playback connot be resumed without reloading the page, so leave the
CourierRenderer in-place to avoid having the default renderer attempt and fail
to play the content."

WDYT?

[xjz, 2017/04/13 23:48:36]

Done.

+    // rendering cannot be resumed.
     //
     // TODO(miu): Revisit this once more of the encrypted-remoting impl is
     // in-place. For example, this will prevent metrics from recording session
     // stop reasons.
     return state == SharedSession::SESSION_STARTED ||
            state == SharedSession::SESSION_STOPPING ||
            state == SharedSession::SESSION_PERMANENTLY_STOPPED;
   }
 
   if (encountered_renderer_fatal_error_)
@@ skipping 66 matching lines @@
     // started successfully.
     session_->StartRemoting(this);
   } else {
     // 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_);
     DCHECK_NE(stop_trigger, UNKNOWN_STOP_TRIGGER);
     metrics_recorder_.WillStopSession(stop_trigger);
-    // Update the interstitial one last time before switching back to the local
-    // Renderer.
-    UpdateInterstitial(base::nullopt);
     client_->SwitchRenderer(false);
     session_->StopRemoting(this);
   }
 }
 
-void RendererController::SetShowInterstitialCallback(
-    const ShowInterstitialCallback& cb) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  show_interstitial_cb_ = cb;
-  UpdateInterstitial(SkBitmap());
-  if (!poster_url_.is_empty())
-    DownloadPosterImage();
-}
-
-void RendererController::SetDownloadPosterCallback(
-    const DownloadPosterCallback& cb) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(download_poster_cb_.is_null());
-  download_poster_cb_ = cb;
-  if (!poster_url_.is_empty())
-    DownloadPosterImage();
-}
-
-void RendererController::UpdateInterstitial(
-    const base::Optional<SkBitmap>& image) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  if (show_interstitial_cb_.is_null())
-    return;
-
-  InterstitialType type = InterstitialType::BETWEEN_SESSIONS;
-  switch (remote_rendering_started_ ? session_->state()
-                                    : SharedSession::SESSION_STOPPING) {
-    case SharedSession::SESSION_STARTED:
-      type = InterstitialType::IN_SESSION;
-      break;
-    case SharedSession::SESSION_PERMANENTLY_STOPPED:
-      type = InterstitialType::ENCRYPTED_MEDIA_FATAL_ERROR;
-      break;
-    case SharedSession::SESSION_UNAVAILABLE:
-    case SharedSession::SESSION_CAN_START:
-    case SharedSession::SESSION_STARTING:
-    case SharedSession::SESSION_STOPPING:
-      break;
-  }
-
-  bool needs_update = false;
-  if (image.has_value()) {
-    interstitial_background_ = image.value();
-    needs_update = true;
-  }
-  if (interstitial_natural_size_ != pipeline_metadata_.natural_size) {
-    interstitial_natural_size_ = pipeline_metadata_.natural_size;
-    needs_update = true;
-  }
-  if (interstitial_type_ != type) {
-    interstitial_type_ = type;
-    needs_update = true;
-  }
-  if (!needs_update)
-    return;
-
-  show_interstitial_cb_.Run(interstitial_background_,
-                            interstitial_natural_size_, interstitial_type_);
-}
-
-void RendererController::DownloadPosterImage() {
-  if (download_poster_cb_.is_null() || show_interstitial_cb_.is_null())
-    return;
-  DCHECK(!poster_url_.is_empty());
-
-  const base::TimeTicks download_start_time = base::TimeTicks::Now();
-  download_poster_cb_.Run(
-      poster_url_,
-      base::Bind(&RendererController::OnPosterImageDownloaded,
-                 weak_factory_.GetWeakPtr(), poster_url_, download_start_time));
-}
-
-void RendererController::OnPosterImageDownloaded(
-    const GURL& download_url,
-    base::TimeTicks download_start_time,
-    const SkBitmap& image) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-
-  metrics_recorder_.OnPosterImageDownloaded(
-      base::TimeTicks::Now() - download_start_time, !image.drawsNothing());
-  if (download_url != poster_url_)
-    return;  // The poster image URL has changed during the download.
-  UpdateInterstitial(image);
-}
-
 void RendererController::OnRendererFatalError(StopTrigger stop_trigger) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Do not act on errors caused by things like Mojo pipes being closed during
   // shutdown.
   if (!remote_rendering_started_)
     return;
 
   encountered_renderer_fatal_error_ = true;
   UpdateAndMaybeSwitch(UNKNOWN_START_TRIGGER, stop_trigger);
 }
 
 void RendererController::SetClient(MediaObserverClient* client) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(client);
   DCHECK(!client_);
 
   client_ = client;
   client_->ActivateViewportIntersectionMonitoring(IsRemoteSinkAvailable());
 }
 
 }  // namespace remoting
 }  // namespace media