Media Remoting: Draw remoting interstitial on poster image.

media/remoting/remoting_renderer_controller.cc

Index: media/remoting/remoting_renderer_controller.cc
diff --git a/media/remoting/remoting_renderer_controller.cc b/media/remoting/remoting_renderer_controller.cc
index 5f0d37eacdbc7a5939d49d5b0941e7077d07da8f..a388ad4a641a94cd3d4a0795d0d3d46a1a414752 100644
--- a/media/remoting/remoting_renderer_controller.cc
+++ b/media/remoting/remoting_renderer_controller.cc
@@ -7,10 +7,42 @@
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/threading/thread_checker.h"
+#include "media/base/video_renderer_sink.h"
+#include "media/base/video_util.h"
 #include "media/remoting/remoting_cdm_context.h"
+#include "media/remoting/remoting_interstitial_ui.h"
+#include "skia/ext/image_operations.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;
+}
+
+// Resizes |image| to fit in the center of |canvas_size| and preserves the
+// image's aspect ratio as close as possible.
+SkBitmap ResizeImage(const SkBitmap& image, const gfx::Size& canvas_size) {

[miu, 2016/12/03 01:05:31]

This is view, not controller functionality. It should be moved to the
interstitial_ui.h/.cc module.

[xjz, 2016/12/06 19:50:55]

Done.

+  DCHECK(!canvas_size.IsEmpty());

[miu, 2016/12/03 01:05:31]

ditto here: Maybe this should be:

  if (canvas_size.IsEmpty())
    return SkBitmap();

[xjz, 2016/12/06 19:50:55]

Not applicable now. If canvas_size is empty, we won't download poster image or
show anything. 

+
+  const gfx::Size image_size = gfx::Size(image.width(), image.height());
+  if (image_size == canvas_size)
+    return image;
+
+  gfx::Size scaled_size = ScaleSizeToFitWithinTarget(image_size, canvas_size);
+  if (scaled_size == image_size)
+    return image;
+
+  return skia::ImageOperations::Resize(
+      image, skia::ImageOperations::RESIZE_BEST, scaled_size.width(),
+      scaled_size.height());
+}
+
+}  // namespace
+
 RemotingRendererController::RemotingRendererController(
     scoped_refptr<RemotingSourceImpl> remoting_source)
     : remoting_source_(remoting_source), weak_factory_(this) {
@@ -73,6 +105,17 @@ void RemotingRendererController::OnSetCdm(CdmContext* cdm_context) {
   UpdateAndMaybeSwitch();
 }
 
+void RemotingRendererController::OnSetPoster(const GURL& poster) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  // Clear |post_image_| if url changes.
+  SkBitmap empty;
+  if (poster != poster_)
+    poster_image_.swap(empty);
+
+  poster_ = poster;

[miu, 2016/12/03 01:05:31]

If the URL has changed, we need to re-render a new interstitial to update the
background. (See large comment below.)

[xjz, 2016/12/06 19:50:55]

Done.

+}
+
 void RemotingRendererController::SetSwitchRendererCallback(
     const base::Closure& cb) {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ -243,4 +286,48 @@ void RemotingRendererController::UpdateAndMaybeSwitch() {
   }
 }
 
+void RemotingRendererController::SetDownloadPosterCallback(
+    const DownloadPosterCallback& cb) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(download_poster_cb_.is_null());
+  download_poster_cb_ = cb;
+}
+
+void RemotingRendererController::ShowInterstitial(
+    VideoRendererSink* video_renderer_sink) {
+  if (!video_renderer_sink)

[miu, 2016/12/03 01:05:31]

Please add: DCHECK(thread_checker_.CalledOnValidThread());

[xjz, 2016/12/06 19:50:55]

Done.

+    return;
+
+  if (poster_image_.drawsNothing() && !poster_.is_empty() &&
+      !download_poster_cb_.is_null()) {
+    download_poster_cb_.Run(
+        poster_, base::Bind(&RemotingRendererController::PosterImageDownloaded,
+                            weak_factory_.GetWeakPtr(), video_renderer_sink));
+  } else {
+    ShowInterstitialOnSink(
+        video_renderer_sink, SkBitmap(),
+        GetRotatedVideoSize(pipeline_metadata_.video_rotation,
+                            pipeline_metadata_.natural_size),
+        remoting_source_->state() == RemotingSessionState::SESSION_STARTED);
+  }
+}
+
+void RemotingRendererController::PosterImageDownloaded(
+    VideoRendererSink* video_renderer_sink,
+    const SkBitmap& image) {
+  DCHECK(poster_image_.drawsNothing());

[miu, 2016/12/03 01:05:31]

ditto: Please add DCHECK(thread_checker_.CalledOnValidThread());

[xjz, 2016/12/06 19:50:55]

Done.

+  DCHECK(video_renderer_sink);
+
+  const gfx::Size canvas_size = GetRotatedVideoSize(

[miu, 2016/12/03 01:05:31]

The rest of this method is view, not controller functionality.

Stepping back, the design requirements are to always download the new poster
image, from the cached source via SingleImageDownloader, and then render a new
interstitial to the VideoRendererSink whenever any of these events occurs:

1. The RemotingRendererImpl is constructed (initial rendering).

2. Any time the poster URL changes (to update the background image).

3. Any time the success/fail state of the remoting session changes (to update
the status message in the interstitial).

4. Any time the size of the canvas changes (because the scaling of the
background and position of the status message will be different).

The controller is what receives the poster URL updates, and knows whenever the
state of the media remoting session changes. So, it seems logical for the
controller to always be the entity to decide when to update the interstitial.
The only thing left that we don't have yet: The RemotingRendererImpl needs to
notify the controller whenever the canvas size changes.

Once that's settled, the controller should have an OnInterstitialNeedsUpdate()
method that is called whenever any of #1-#4 happen. This method would: 1)
download the poster image; and 2) upon receipt of the SkBitmap from the
downloader, pass the bitmap to RemotingRendererImpl to update its view. Then,
RemotingRendererImpl would take this SkBitmap, pass it to the function that
renders everything, and finally call VideoRendererSink::PaintSingleFrame().

[xjz, 2016/12/06 19:50:55]

Done. Added a callback to RemotingRendererController to draw and show
interstitial after poster imaged is downloaded.

+      pipeline_metadata_.video_rotation, pipeline_metadata_.natural_size);
+
+  if (!image.drawsNothing()) {
+    poster_image_ = ResizeImage(image, canvas_size);
+  }
+
+  ShowInterstitialOnSink(
+      video_renderer_sink, poster_image_, canvas_size,
+      remoting_source_->state() == RemotingSessionState::SESSION_STARTED);
+}
+
 }  // namespace media