Media Remoting: Update remoting interstitial when status changes.

media/remoting/remoting_interstitial_ui.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_interstitial_ui.h"
 
 #include "media/base/media_resources.h"
 #include "media/base/video_frame.h"
 #include "media/base/video_renderer_sink.h"
 #include "media/base/video_util.h"
+#include "skia/ext/image_operations.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkTypeface.h"
 #include "third_party/skia/include/effects/SkBlurImageFilter.h"
 #include "ui/gfx/color_palette.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/paint_vector_icon.h"
 #include "ui/gfx/skbitmap_operations.h"
 #include "ui/gfx/vector_icons_public.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;
+SkBitmap ResizeImage(const SkBitmap& image, const gfx::Size& scaled_size) {
+  DCHECK(!scaled_size.IsEmpty());
+
+  if (image.width() == scaled_size.width() &&
+      image.height() == scaled_size.height())
+    return image;
+
+  return skia::ImageOperations::Resize(
+      image, skia::ImageOperations::RESIZE_BEST, scaled_size.width(),
+      scaled_size.height());
 }
 
-}  // namespace
-
-RemotingInterstitialUI::RemotingInterstitialUI(
-    VideoRendererSink* video_renderer_sink,
-    const PipelineMetadata& pipeline_metadata)
-    : video_renderer_sink_(video_renderer_sink),
-      pipeline_metadata_(pipeline_metadata) {
-  DCHECK(pipeline_metadata_.has_video);
-  pipeline_metadata_.natural_size = GetRotatedVideoSize(
-      pipeline_metadata_.video_rotation, pipeline_metadata_.natural_size);
-}
-
-RemotingInterstitialUI::~RemotingInterstitialUI() {}
-
-scoped_refptr<VideoFrame> RemotingInterstitialUI::GetInterstitial(
-    const SkBitmap& background_image,
-    bool is_remoting_successful) {
-  const gfx::Size canvas_size =
-      gfx::Size(background_image.width(), background_image.height());
-  DCHECK(canvas_size == pipeline_metadata_.natural_size);
-
-  color_utils::HSL shift = {-1, 0, 0.2};  // Make monochromatic.
-  SkBitmap modified_bitmap =
-      SkBitmapOperations::CreateHSLShiftedBitmap(background_image, shift);
-
-  SkCanvas canvas(modified_bitmap);
+void RenderCastMessage(const gfx::Size& canvas_size,
+                       RemotingInterstitialType type,
+                       SkCanvas* canvas) {
+  DCHECK(canvas);
+  if (type == RemotingInterstitialType::BETWEEN_SESSIONS)
+    return;
 
   // Blur the background image.
   SkScalar sigma = SkDoubleToScalar(10);
   SkPaint paint_blur;
   paint_blur.setImageFilter(SkBlurImageFilter::Make(sigma, sigma, nullptr));
-  canvas.saveLayer(0, &paint_blur);
-  canvas.restore();
+  canvas->saveLayer(0, &paint_blur);
+  canvas->restore();
 
   // Create SkPaint for text and icon bitmap.
   // After |paint| draws, the new canvas should look like this:
   //       _________________________________
   //       |                                |
   //       |                                |
   //       |             [   ]              |
   //       |        Casting Video...        |
   //       |                                |
   //       |________________________________|
   //
   // Both text and icon are centered horizontally. Together, they are
   // centered vertically.
   SkPaint paint;
   int text_size = SkIntToScalar(30);
   paint.setAntiAlias(true);
   paint.setFilterQuality(kHigh_SkFilterQuality);
   paint.setColor(SK_ColorLTGRAY);
   paint.setTypeface(SkTypeface::MakeFromName(
       "sans", SkFontStyle::FromOldStyle(SkTypeface::kNormal)));
   paint.setTextSize(text_size);
 
   // Draw the appropriate text.
   const std::string remote_playback_message =
-      is_remoting_successful
-          ? GetLocalizedStringUTF8(MEDIA_REMOTING_CASTING_VIDEO_TEXT)
-          : GetLocalizedStringUTF8(MEDIA_REMOTING_CAST_ERROR_TEXT);
+      (type == RemotingInterstitialType::IN_SESSION
+           ? GetLocalizedStringUTF8(MEDIA_REMOTING_CASTING_VIDEO_TEXT)
+           : GetLocalizedStringUTF8(MEDIA_REMOTING_CAST_ERROR_TEXT));
   size_t display_text_width = paint.measureText(remote_playback_message.data(),
                                                 remote_playback_message.size());
   SkScalar sk_text_offset_x = (canvas_size.width() - display_text_width) / 2.0;
   SkScalar sk_text_offset_y = (canvas_size.height() / 2.0) + text_size;
-  canvas.drawText(remote_playback_message.data(),
-                  remote_playback_message.size(), sk_text_offset_x,
-                  sk_text_offset_y, paint);
+  canvas->drawText(remote_playback_message.data(),
+                   remote_playback_message.size(), sk_text_offset_x,
+                   sk_text_offset_y, paint);
 
   // Draw the appropriate Cast icon.
   gfx::VectorIconId current_icon =
-      is_remoting_successful ? gfx::VectorIconId::MEDIA_ROUTER_ACTIVE
-                             : gfx::VectorIconId::MEDIA_ROUTER_WARNING;
+      (type == RemotingInterstitialType::IN_SESSION
+           ? gfx::VectorIconId::MEDIA_ROUTER_ACTIVE
+           : gfx::VectorIconId::MEDIA_ROUTER_WARNING);
   gfx::ImageSkia icon_image =
       gfx::CreateVectorIcon(current_icon, 65, SK_ColorLTGRAY);
   const SkBitmap* icon_bitmap = icon_image.bitmap();
   SkScalar sk_image_offset_x = (canvas_size.width() - icon_image.width()) / 2.0;
   SkScalar sk_image_offset_y =
       (canvas_size.height() / 2.0) - icon_image.height();
-  canvas.drawBitmap(*icon_bitmap, sk_image_offset_x, sk_image_offset_y, &paint);
+  canvas->drawBitmap(*icon_bitmap, sk_image_offset_x, sk_image_offset_y,
+                     &paint);
+}
+
+scoped_refptr<VideoFrame> RenderInterstitialFrame(
+    const SkBitmap& image,
+    const gfx::Size& canvas_size,
+    RemotingInterstitialType type) {
+  SkBitmap canvas_bitmap;
+  canvas_bitmap.allocN32Pixels(canvas_size.width(), canvas_size.height());
+  canvas_bitmap.eraseColor(SK_ColorBLACK);
+  SkCanvas canvas(canvas_bitmap);
+
+  SkBitmap background_image;
+  // Draw |background_image| on the canvas.
+  if (!image.drawsNothing()) {
+    gfx::Rect centered_rect = ComputeLetterboxRegion(
+        gfx::Rect(canvas_size), gfx::Size(image.width(), image.height()));
+    background_image = ResizeImage(image, centered_rect.size());

[miu, 2016/12/20 21:21:04]

|background_image| is an extra variable that's not needed, and eliminating it
would simplify this code:

  SkBitmap processed_image = ResizeImage(image, centered_rect.size());
  if (type != RemotingInterstitialType::BETWEEN_SESSIONS) {
    color_utils::HSL shift = {-1, 0, 0.2};  // Make monochromatic.
    processed_image =
        SkBitmapOperations::CreateHSLShiftedBitmap(processed_image, shift);
  }
  canvas.writePixels(processed_image, centered_rect.x(), centered_rect.y());

[xjz, 2016/12/20 22:15:37]

Done.

+    SkBitmap processed_image;
+    if (type == RemotingInterstitialType::BETWEEN_SESSIONS) {
+      processed_image = background_image;
+    } else {
+      color_utils::HSL shift = {-1, 0, 0.2};  // Make monochromatic.
+      processed_image =
+          SkBitmapOperations::CreateHSLShiftedBitmap(background_image, shift);
+    }
+    canvas.writePixels(processed_image, centered_rect.x(), centered_rect.y());
+  }
+
+  RenderCastMessage(canvas_size, type, &canvas);
 
   // Create a new VideoFrame, copy the bitmap, then return it.
   scoped_refptr<media::VideoFrame> video_frame = media::VideoFrame::CreateFrame(
       media::PIXEL_FORMAT_I420, canvas_size, gfx::Rect(canvas_size),
       canvas_size, base::TimeDelta());
-  modified_bitmap.lockPixels();
+  canvas_bitmap.lockPixels();
   media::CopyRGBToVideoFrame(
-      reinterpret_cast<uint8_t*>(modified_bitmap.getPixels()),
-      modified_bitmap.rowBytes(),
+      reinterpret_cast<uint8_t*>(canvas_bitmap.getPixels()),
+      canvas_bitmap.rowBytes(),
       gfx::Rect(canvas_size.width(), canvas_size.height()), video_frame.get());
-  modified_bitmap.unlockPixels();
+  canvas_bitmap.unlockPixels();
   return video_frame;
 }
 
-void RemotingInterstitialUI::ShowInterstitial(bool is_remoting_successful) {
-  if (!video_renderer_sink_)
+}  // namespace
+
+void PaintRemotingInterstitial(const SkBitmap& image,
+                               const gfx::Size& canvas_size,
+                               RemotingInterstitialType interstitial_type,
+                               VideoRendererSink* video_renderer_sink) {
+  if (canvas_size.IsEmpty())
     return;
 
-  // TODO(xjz): Provide poster image, if available, rather than a blank, black
-  // image.
-  SkBitmap background_image;
-  const gfx::Size size = pipeline_metadata_.natural_size;
-  background_image.allocN32Pixels(size.width(), size.height());
-  background_image.eraseColor(SK_ColorBLACK);
+  const scoped_refptr<VideoFrame> interstitial =
+      RenderInterstitialFrame(image, canvas_size, interstitial_type);
 
-  const scoped_refptr<VideoFrame> interstitial =
-      GetInterstitial(background_image, is_remoting_successful);
   if (!interstitial)
     return;
-
-  video_renderer_sink_->PaintSingleFrame(interstitial);
+  video_renderer_sink->PaintSingleFrame(interstitial);
 }
 
 }  // namespace media