Media Remoting: Draw remoting interstitial on poster image.

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;
@@ skipping 29 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();
+  UpdateInterstitial(base::nullopt);
   UpdateAndMaybeSwitch();
 }
 
 bool RemotingRendererController::IsRemoteSinkAvailable() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   switch (remoting_source_->state()) {
     case SESSION_CAN_START:
     case SESSION_STARTING:
     case SESSION_STARTED:
@@ skipping 41 matching lines @@
   UpdateAndMaybeSwitch();
 }
 
 void RemotingRendererController::OnRemotePlaybackDisabled(bool disabled) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   is_remote_playback_disabled_ = disabled;
   UpdateAndMaybeSwitch();
 }
 
+void RemotingRendererController::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();
+  }
+}
+
 void RemotingRendererController::SetSwitchRendererCallback(
     const base::Closure& cb) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!cb.is_null());
 
   switch_renderer_cb_ = cb;
   UpdateAndMaybeSwitch();
 }
 
 void RemotingRendererController::SetRemoteSinkAvailableChangedCallback(
@@ skipping 33 matching lines @@
   if (has_video()) {
     is_encrypted_ |= metadata.video_decoder_config.is_encrypted();
     pipeline_metadata_.natural_size = GetRotatedVideoSize(
         pipeline_metadata_.video_rotation, pipeline_metadata_.natural_size);
   }
   if (has_audio()) {
     is_encrypted_ |= metadata.audio_decoder_config.is_encrypted();
   }
 
   if (pipeline_metadata_.natural_size != old_size)
-    UpdateInterstitial();
+    UpdateInterstitial(base::nullopt);
 
   UpdateAndMaybeSwitch();
 }
 
 bool RemotingRendererController::IsVideoCodecSupported() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(has_video());
 
   switch (pipeline_metadata_.video_decoder_config.codec()) {
     case VideoCodec::kCodecH264:
@@ skipping 137 matching lines @@
     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();
+  UpdateInterstitial(SkBitmap());
+  if (!poster_url_.is_empty())
+    DownloadPosterImage();
 }
 
-void RemotingRendererController::UpdateInterstitial() {
+void RemotingRendererController::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 RemotingRendererController::UpdateInterstitial(
+    const base::Optional<SkBitmap>& image) {
   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);
+  show_interstitial_cb_.Run(image, pipeline_metadata_.natural_size, type);
+}
+
+void RemotingRendererController::DownloadPosterImage() {
+  if (download_poster_cb_.is_null() || show_interstitial_cb_.is_null())
+    return;
+  DCHECK(!poster_url_.is_empty());
+
+  download_poster_cb_.Run(
+      poster_url_,
+      base::Bind(&RemotingRendererController::OnPosterImageDownloaded,
+                 weak_factory_.GetWeakPtr(), poster_url_));
+}
+
+void RemotingRendererController::OnPosterImageDownloaded(
+    const GURL& download_url,
+    const SkBitmap& image) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  if (download_url != poster_url_)
+    return;  // The poster image URL has changed during the download.
+  UpdateInterstitial(image);
 }
 
 }  // namespace media