[Chromecast] Change canPlayType() for individual apps

Each WebApplication sends the supported audio codecs to its
CastContentRendererClient using Mojo.

Bug: internal b/73180315
Test: cast to Chromecast
Change-Id: I405f2765ede611ed81488f78bca7bb9b2734f769
Reviewed-on: https://chromium-review.googlesource.com/910711
Commit-Queue: James West <jameswest@chromium.org>
Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Reviewed-by: Stephen Lanham <slan@chromium.org>
Reviewed-by: Luke Halliwell <halliwell@chromium.org>
Reviewed-by: Kenneth MacKay <kmackay@chromium.org>
Cr-Commit-Position: refs/heads/master@{#537166}

chromecast/BUILD.gn

@@ -552,7 +552,9 @@ group("chromecast_locales_pak") {
 
 buildflag_header("chromecast_features") {
   header = "chromecast_features.h"
+  enable_application_media_capabilities = chromecast_branding != "public"
   flags = [
+    "ENABLE_APPLICATION_MEDIA_CAPABILITIES=$enable_application_media_capabilities",
     "ENABLE_ASSISTANT=$enable_assistant",
     "ENABLE_VOLUME_TABLES_ACCESS=$enable_volume_tables_access",
     "IS_ANDROID_THINGS=$is_android_things",

chromecast/base/BUILD.gn

@@ -45,6 +45,8 @@ cast_source_set("base") {
     "android/system_time_change_notifier_android.cc",
     "android/system_time_change_notifier_android.h",
     "bind_to_task_runner.h",
+    "bitstream_audio_codecs.cc",
+    "bitstream_audio_codecs.h",
     "cast_constants.cc",
     "cast_constants.h",
     "cast_features.cc",

chromecast/base/bitstream_audio_codecs.cc

+// Copyright 2018 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 "chromecast/base/bitstream_audio_codecs.h"
+
+#include <vector>
+
+#include "base/strings/string_piece.h"
+#include "base/strings/string_util.h"
+
+namespace chromecast {
+
+namespace {
+
+const char* BitstreamAudioCodecToString(int codec) {
+  switch (codec) {
+    case kBitstreamAudioCodecNone:
+      return "None";
+    case kBitstreamAudioCodecAc3:
+      return "AC3";
+    case kBitstreamAudioCodecDts:
+      return "DTS";
+    case kBitstreamAudioCodecDtsHd:
+      return "DTS-HD";
+    case kBitstreamAudioCodecEac3:
+      return "EAC3";
+    case kBitstreamAudioCodecPcmSurround:
+      return "PCM";
+    default:
+      return "";
+  }
+}
+
+}  // namespace
+
+std::string BitstreamAudioCodecsToString(int codecs) {
+  std::string codec_string = BitstreamAudioCodecToString(codecs);
+  if (!codec_string.empty()) {
+    return codec_string;
+  }
+  std::vector<base::StringPiece> codec_strings;
+  for (int codec : {kBitstreamAudioCodecAc3, kBitstreamAudioCodecDts,
+                    kBitstreamAudioCodecDtsHd, kBitstreamAudioCodecEac3,
+                    kBitstreamAudioCodecPcmSurround}) {
+    if ((codec & codecs) != 0) {
+      codec_strings.push_back(BitstreamAudioCodecToString(codec));
+    }
+  }
+  return "[" + base::JoinString(codec_strings, ", ") + "]";
+}
+
+}  // namespace chromecast

chromecast/base/bitstream_audio_codecs.h

+// Copyright 2018 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.
+
+#ifndef CHROMECAST_BASE_BITSTREAM_AUDIO_CODECS_H_
+#define CHROMECAST_BASE_BITSTREAM_AUDIO_CODECS_H_
+
+#include <string>
+
+namespace chromecast {
+
+constexpr int kBitstreamAudioCodecNone = 0b00000;
+constexpr int kBitstreamAudioCodecAc3 = 0b00001;
+constexpr int kBitstreamAudioCodecDts = 0b00010;
+constexpr int kBitstreamAudioCodecDtsHd = 0b00100;
+constexpr int kBitstreamAudioCodecEac3 = 0b01000;
+constexpr int kBitstreamAudioCodecPcmSurround = 0b10000;
+constexpr int kBitstreamAudioCodecAll = 0b11111;
+
+std::string BitstreamAudioCodecsToString(int codecs);
+
+}  // namespace chromecast
+
+#endif  // CHROMECAST_BASE_BITSTREAM_AUDIO_CODECS_H_

chromecast/browser/media/media_caps_impl.cc

@@ -22,8 +22,7 @@ mojom::CodecProfileLevelPtr ConvertCodecProfileLevelToMojo(
 }
 
 MediaCapsImpl::MediaCapsImpl()
-    : supported_codecs_bitmask_(0),
-      hdcp_version_(0),
+    : hdcp_version_(0),
       supported_eotfs_(0),
       dolby_vision_flags_(0),
       screen_width_mm_(0),
@@ -44,16 +43,6 @@ void MediaCapsImpl::AddBinding(
   bindings_.AddBinding(this, std::move(request));
 }
 
-void MediaCapsImpl::SetSupportedHdmiSinkCodecs(
-    unsigned int supported_codecs_bitmask) {
-  supported_codecs_bitmask_ = supported_codecs_bitmask;
-
-  observers_.ForAllPtrs(
-      [supported_codecs_bitmask](mojom::MediaCapsObserver* observer) {
-        observer->SupportedHdmiSinkCodecsChanged(supported_codecs_bitmask);
-      });
-}
-
 void MediaCapsImpl::ScreenResolutionChanged(unsigned width, unsigned height) {
   screen_resolution_ = gfx::Size(width, height);
 
@@ -101,7 +90,6 @@ void MediaCapsImpl::AddSupportedCodecProfileLevel(
 }
 
 void MediaCapsImpl::AddObserver(mojom::MediaCapsObserverPtr observer) {
-  observer->SupportedHdmiSinkCodecsChanged(supported_codecs_bitmask_);
   observer->ScreenResolutionChanged(screen_resolution_.width(),
                                     screen_resolution_.height());
   observer->ScreenInfoChanged(hdcp_version_, supported_eotfs_,

chromecast/browser/media/media_caps_impl.h

@@ -26,7 +26,6 @@ class MediaCapsImpl : public mojom::MediaCaps {
   void Initialize();
   void AddBinding(mojom::MediaCapsRequest request);
 
-  void SetSupportedHdmiSinkCodecs(unsigned int supported_codecs_bitmask);
   void ScreenResolutionChanged(unsigned width, unsigned height);
   void ScreenInfoChanged(int hdcp_version,
                          int supported_eotfs,
@@ -42,7 +41,6 @@ class MediaCapsImpl : public mojom::MediaCaps {
   // chromecast::mojom::MediaCaps implementation.
   void AddObserver(mojom::MediaCapsObserverPtr observer) override;
 
-  unsigned int supported_codecs_bitmask_;
   int hdcp_version_;
   int supported_eotfs_;
   int dolby_vision_flags_;

chromecast/common/BUILD.gn

@@ -46,10 +46,12 @@ cast_source_set("common") {
   }
 }
 
-if (!is_android) {
-  mojom("interfaces") {
-    sources = [
-      "memory_pressure.mojom",
-    ]
+mojom("interfaces") {
+  sources = [
+    "application_media_capabilities.mojom",
+  ]
+
+  if (!is_android) {
+    sources += [ "memory_pressure.mojom" ]
   }
 }

chromecast/common/application_media_capabilities.mojom

+// Copyright 2018 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.
+
+module chromecast.shell.mojom;
+
+// Observes changes in an individual application's media capabilities.
+// See chromecast/base/bitstream_audio_codecs.h for codec values.
+interface ApplicationMediaCapabilitiesObserver {
+  OnSupportedBitstreamAudioCodecsChanged(int32 codecs);
+};
+
+// Media capabilities for an individual application.
+interface ApplicationMediaCapabilities {
+  AddObserver(ApplicationMediaCapabilitiesObserver observer);
+};

chromecast/common/media/media_caps.mojom

@@ -10,13 +10,13 @@ struct CodecProfileLevel {
   int32 level;
 };
 
+// Media capabilities that apply to all applications.
 interface MediaCaps {
   AddObserver(MediaCapsObserver observer);
 };
 
+// Observes changes in media capabilities that apply to all applications.
 interface MediaCapsObserver {
-  // Bitmask values defined in enum HdmiSinkCodec (avsettings.h)
-  SupportedHdmiSinkCodecsChanged(uint32 supported_codec_bitmask);
   ScreenResolutionChanged(uint32 width, uint32 height);
 
   // EOTFs and Dolby Vision flags defined in avsettings.h

chromecast/media/base/media_caps.cc

@@ -10,7 +10,6 @@
 namespace chromecast {
 namespace media {
 
-unsigned int MediaCapabilities::g_hdmi_codecs = 0;
 int MediaCapabilities::g_hdcp_version = 0;
 int MediaCapabilities::g_supported_eotfs = 0;
 int MediaCapabilities::g_dolby_vision_flags = 0;
@@ -18,30 +17,6 @@ bool MediaCapabilities::g_cur_mode_supports_hdr = false;
 bool MediaCapabilities::g_cur_mode_supports_dv = false;
 gfx::Size MediaCapabilities::g_screen_resolution(0, 0);
 
-void MediaCapabilities::SetHdmiSinkCodecs(unsigned int codecs_mask) {
-  g_hdmi_codecs = codecs_mask;
-}
-
-bool MediaCapabilities::HdmiSinkSupportsAC3() {
-  return g_hdmi_codecs & HdmiSinkCodec::kSinkCodecAc3;
-}
-
-bool MediaCapabilities::HdmiSinkSupportsDTS() {
-  return g_hdmi_codecs & HdmiSinkCodec::kSinkCodecDts;
-}
-
-bool MediaCapabilities::HdmiSinkSupportsDTSHD() {
-  return g_hdmi_codecs & HdmiSinkCodec::kSinkCodecDtsHd;
-}
-
-bool MediaCapabilities::HdmiSinkSupportsEAC3() {
-  return g_hdmi_codecs & HdmiSinkCodec::kSinkCodecEac3;
-}
-
-bool MediaCapabilities::HdmiSinkSupportsPcmSurroundSound() {
-  return g_hdmi_codecs & HdmiSinkCodec::kSinkCodecPcmSurroundSound;
-}
-
 void MediaCapabilities::ScreenResolutionChanged(const gfx::Size& res) {
   VLOG(1) << __FUNCTION__ << " resolution=" << res.ToString();
   g_screen_resolution = res;

chromecast/media/base/media_caps.h

@@ -16,24 +16,6 @@ namespace media {
 // currently only available in the browser process).
 class MediaCapabilities {
  public:
-  enum HdmiSinkCodec {
-    kSinkCodecAc3 = 1,
-    kSinkCodecDts = 1 << 1,
-    kSinkCodecDtsHd = 1 << 2,
-    kSinkCodecEac3 = 1 << 3,
-    kSinkCodecPcmSurroundSound = 1 << 4,
-  };
-
-  // Records the known supported codecs for the current HDMI sink, as a bit mask
-  // of HdmiSinkCodec values.
-  static void SetHdmiSinkCodecs(unsigned int codecs_mask);
-
-  static bool HdmiSinkSupportsAC3();
-  static bool HdmiSinkSupportsDTS();
-  static bool HdmiSinkSupportsDTSHD();
-  static bool HdmiSinkSupportsEAC3();
-  static bool HdmiSinkSupportsPcmSurroundSound();
-
   static void ScreenResolutionChanged(const gfx::Size& res);
   static void ScreenInfoChanged(int hdcp_version,
                                 int supported_eotfs,

chromecast/renderer/BUILD.gn

@@ -28,6 +28,7 @@ cast_source_set("renderer") {
     "//base",
     "//chromecast:chromecast_features",
     "//chromecast/base",
+    "//chromecast/common:interfaces",
     "//chromecast/common/media",
     "//chromecast/media",
     "//components/network_hints/renderer",

chromecast/renderer/cast_content_renderer_client.cc

@@ -4,14 +4,12 @@
 
 #include "chromecast/renderer/cast_content_renderer_client.h"
 
-#include <stdint.h>
+#include <utility>
 
 #include "base/command_line.h"
-#include "base/macros.h"
 #include "base/strings/string_number_conversions.h"
-#include "build/build_config.h"
+#include "chromecast/base/bitstream_audio_codecs.h"
 #include "chromecast/base/chromecast_switches.h"
-#include "chromecast/media/base/media_caps.h"
 #include "chromecast/media/base/media_codec_support.h"
 #include "chromecast/media/base/supported_codec_profile_levels_memo.h"
 #include "chromecast/public/media/media_capabilities_shlib.h"
@@ -25,7 +23,9 @@
 #include "content/public/renderer/render_thread.h"
 #include "content/public/renderer/render_view.h"
 #include "media/base/media.h"
+#include "mojo/public/cpp/bindings/interface_request.h"
 #include "services/service_manager/public/cpp/connector.h"
+#include "services/service_manager/public/cpp/interface_provider.h"
 #include "third_party/WebKit/public/platform/WebColor.h"
 #include "third_party/WebKit/public/platform/WebRuntimeFeatures.h"
 #include "third_party/WebKit/public/web/WebFrameWidget.h"
@@ -67,9 +67,11 @@ const blink::WebColor kColorBlack = 0xFF000000;
 
 CastContentRendererClient::CastContentRendererClient()
     : supported_profiles_(new media::SupportedCodecProfileLevelsMemo()),
+      app_media_capabilities_observer_binding_(this),
       allow_hidden_media_playback_(
           base::CommandLine::ForCurrentProcess()->HasSwitch(
-              switches::kAllowHiddenMediaPlayback)) {
+              switches::kAllowHiddenMediaPlayback)),
+      supported_bitstream_audio_codecs_(kBitstreamAudioCodecNone) {
 #if defined(OS_ANDROID)
   DCHECK(::media::MediaCodecUtil::IsMediaCodecAvailable())
       << "MediaCodec is not available!";
@@ -81,8 +83,7 @@ CastContentRendererClient::CastContentRendererClient()
 #endif  // OS_ANDROID
 }
 
-CastContentRendererClient::~CastContentRendererClient() {
-}
+CastContentRendererClient::~CastContentRendererClient() = default;
 
 void CastContentRendererClient::RenderThreadStarted() {
   // Register as observer for media capabilities
@@ -97,10 +98,10 @@ void CastContentRendererClient::RenderThreadStarted() {
 
 #if !defined(OS_ANDROID)
   // Register to observe memory pressure changes
-  mojom::MemoryPressureControllerPtr memory_pressure_controller;
+  chromecast::mojom::MemoryPressureControllerPtr memory_pressure_controller;
   thread->GetConnector()->BindInterface(content::mojom::kBrowserServiceName,
                                         &memory_pressure_controller);
-  mojom::MemoryPressureObserverPtr memory_pressure_proxy;
+  chromecast::mojom::MemoryPressureObserverPtr memory_pressure_proxy;
   memory_pressure_observer_.reset(
       new MemoryPressureObserverImpl(&memory_pressure_proxy));
   memory_pressure_controller->AddObserver(std::move(memory_pressure_proxy));
@@ -155,6 +156,18 @@ void CastContentRendererClient::RenderViewCreated(
 
 void CastContentRendererClient::RenderFrameCreated(
     content::RenderFrame* render_frame) {
+  DCHECK(render_frame);
+#if BUILDFLAG(ENABLE_APPLICATION_MEDIA_CAPABILITIES)
+  if (!app_media_capabilities_observer_binding_.is_bound()) {
+    mojom::ApplicationMediaCapabilitiesObserverPtr observer;
+    app_media_capabilities_observer_binding_.Bind(mojo::MakeRequest(&observer));
+    mojom::ApplicationMediaCapabilitiesPtr app_media_capabilities;
+    render_frame->GetRemoteInterfaces()->GetInterface(
+        mojo::MakeRequest(&app_media_capabilities));
+    app_media_capabilities->AddObserver(std::move(observer));
+  }
+#endif
+
 #if BUILDFLAG(ENABLE_CHROMECAST_EXTENSIONS)
   extensions::Dispatcher* dispatcher =
       extensions_renderer_client_->GetDispatcher();
@@ -205,33 +218,28 @@ void CastContentRendererClient::AddSupportedKeySystems(
 bool CastContentRendererClient::IsSupportedAudioConfig(
     const ::media::AudioConfig& config) {
 #if defined(OS_ANDROID)
-  media::AudioCodec codec = media::ToCastAudioCodec(config.codec);
-
   // No ATV device we know of has (E)AC3 decoder, so it relies on the audio sink
   // device.
-  if (codec == media::kCodecEAC3)
-    return media::MediaCapabilities::HdmiSinkSupportsEAC3();
-  if (codec == media::kCodecAC3)
-    return media::MediaCapabilities::HdmiSinkSupportsAC3();
+  if (config.codec == ::media::kCodecEAC3)
+    return kBitstreamAudioCodecEac3 & supported_bitstream_audio_codecs_;
+  if (config.codec == ::media::kCodecAC3)
+    return kBitstreamAudioCodecAc3 & supported_bitstream_audio_codecs_;
 
   // TODO(sanfin): Implement this for Android.
   return true;
 #else
+  // If the HDMI sink supports bitstreaming the codec, then the vendor backend
+  // does not need to support it.
+  if (IsSupportedBitstreamAudioCodec(config.codec)) {
+    return true;
+  }
+
   media::AudioCodec codec = media::ToCastAudioCodec(config.codec);
   // Cast platform implements software decoding of Opus and FLAC, so only PCM
   // support is necessary in order to support Opus and FLAC.
   if (codec == media::kCodecOpus || codec == media::kCodecFLAC)
     codec = media::kCodecPCM;
 
-  // If HDMI sink supports AC3/EAC3 codecs then we don't need the vendor backend
-  // to support these codec directly.
-  if (codec == media::kCodecEAC3 &&
-      media::MediaCapabilities::HdmiSinkSupportsEAC3())
-    return true;
-  if (codec == media::kCodecAC3 &&
-      media::MediaCapabilities::HdmiSinkSupportsAC3())
-    return true;
-
   media::AudioConfig cast_audio_config;
   cast_audio_config.codec = codec;
   return media::MediaCapabilitiesShlib::IsSupportedAudioConfig(
@@ -256,9 +264,9 @@ bool CastContentRendererClient::IsSupportedVideoConfig(
 bool CastContentRendererClient::IsSupportedBitstreamAudioCodec(
     ::media::AudioCodec codec) {
   return (codec == ::media::kCodecAC3 &&
-          media::MediaCapabilities::HdmiSinkSupportsAC3()) ||
+          (kBitstreamAudioCodecAc3 & supported_bitstream_audio_codecs_)) ||
          (codec == ::media::kCodecEAC3 &&
-          media::MediaCapabilities::HdmiSinkSupportsEAC3());
+          (kBitstreamAudioCodecEac3 & supported_bitstream_audio_codecs_));
 }
 
 blink::WebPrescientNetworking*
@@ -300,5 +308,10 @@ void CastContentRendererClient::
   blink::WebRuntimeFeatures::EnableMediaControlsOverlayPlayButton(false);
 }
 
+void CastContentRendererClient::OnSupportedBitstreamAudioCodecsChanged(
+    int codecs) {
+  supported_bitstream_audio_codecs_ = codecs;
+}
+
 }  // namespace shell
 }  // namespace chromecast

chromecast/renderer/cast_content_renderer_client.h

@@ -11,7 +11,10 @@
 #include "base/macros.h"
 #include "build/build_config.h"
 #include "chromecast/chromecast_features.h"
+#include "chromecast/common/application_media_capabilities.mojom.h"
 #include "content/public/renderer/content_renderer_client.h"
+#include "media/base/audio_codecs.h"
+#include "mojo/public/cpp/bindings/binding.h"
 
 #if defined(CHROMECAST_BUILD)
 #include <string>
@@ -36,7 +39,9 @@ class SupportedCodecProfileLevelsMemo;
 
 namespace shell {
 
-class CastContentRendererClient : public content::ContentRendererClient {
+class CastContentRendererClient
+    : public content::ContentRendererClient,
+      public mojom::ApplicationMediaCapabilitiesObserver {
  public:
   // Creates an implementation of CastContentRendererClient. Platform should
   // link in an implementation as needed.
@@ -74,10 +79,15 @@ class CastContentRendererClient : public content::ContentRendererClient {
                                    const base::Closure& closure);
 
  private:
+  // mojom::ApplicationMediaCapabilitiesObserver implementation:
+  void OnSupportedBitstreamAudioCodecsChanged(int codecs) override;
+
   std::unique_ptr<network_hints::PrescientNetworkingDispatcher>
       prescient_networking_dispatcher_;
   std::unique_ptr<media::MediaCapsObserverImpl> media_caps_observer_;
   std::unique_ptr<media::SupportedCodecProfileLevelsMemo> supported_profiles_;
+  mojo::Binding<mojom::ApplicationMediaCapabilitiesObserver>
+      app_media_capabilities_observer_binding_;
 #if !defined(OS_ANDROID)
   std::unique_ptr<MemoryPressureObserverImpl> memory_pressure_observer_;
 #endif
@@ -91,6 +101,7 @@ class CastContentRendererClient : public content::ContentRendererClient {
 #endif
 
   const bool allow_hidden_media_playback_;
+  int supported_bitstream_audio_codecs_;
 
   DISALLOW_COPY_AND_ASSIGN(CastContentRendererClient);
 };

chromecast/renderer/media/media_caps_observer_impl.cc

@@ -19,11 +19,6 @@ MediaCapsObserverImpl::MediaCapsObserverImpl(
 
 MediaCapsObserverImpl::~MediaCapsObserverImpl() = default;
 
-void MediaCapsObserverImpl::SupportedHdmiSinkCodecsChanged(
-    uint32_t codec_support_bitmask) {
-  MediaCapabilities::SetHdmiSinkCodecs(codec_support_bitmask);
-}
-
 void MediaCapsObserverImpl::ScreenResolutionChanged(uint32_t width,
                                                     uint32_t height) {
   MediaCapabilities::ScreenResolutionChanged(gfx::Size(width, height));

chromecast/renderer/media/media_caps_observer_impl.h

@@ -23,8 +23,6 @@ class MediaCapsObserverImpl : public mojom::MediaCapsObserver {
   ~MediaCapsObserverImpl() override;
 
  private:
-  void SupportedHdmiSinkCodecsChanged(
-      uint32_t supported_codec_bitmask) override;
   void ScreenResolutionChanged(uint32_t width, uint32_t height) override;
   void ScreenInfoChanged(int32_t hdcp_version,
                          int32_t supported_eotfs,