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_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) {
   remoting_source_->AddClient(this);
 }
 
 RemotingRendererController::~RemotingRendererController() {
   DCHECK(thread_checker_.CalledOnValidThread());
   remoting_source_->RemoveClient(this);
 }
@@ skipping 42 matching lines @@
   auto* remoting_cdm_context = RemotingCdmContext::From(cdm_context);
   if (!remoting_cdm_context)
     return;
 
   remoting_source_->RemoveClient(this);
   remoting_source_ = remoting_cdm_context->GetRemotingSource();
   remoting_source_->AddClient(this);  // Calls OnSessionStateChanged().
   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());
   DCHECK(!cb.is_null());
 
   switch_renderer_cb_ = cb;
   UpdateAndMaybeSwitch();
 }
 
 base::WeakPtr<remoting::RpcBroker> RemotingRendererController::GetRpcBroker()
@@ skipping 150 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::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