media: Enable Unified Media Pipeline for MSE and EME on Android

content/renderer/render_frame_impl.cc

 // Copyright 2013 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 "content/renderer/render_frame_impl.h"
 
 #include <map>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 196 matching lines @@
 #include "content/renderer/media/android/stream_texture_factory_impl.h"
 #include "content/renderer/media/android/webmediaplayer_android.h"
 #include "content/renderer/media/android/webmediasession_android.h"
 #include "media/base/android/media_codec_util.h"
 #include "third_party/WebKit/public/platform/WebFloatPoint.h"
 #else
 #include "cc/blink/context_provider_web_context.h"
 #endif
 
 #if defined(ENABLE_PEPPER_CDMS)
+#include "content/renderer/media/cdm/render_cdm_factory.h"
 #include "content/renderer/media/cdm/pepper_cdm_wrapper_impl.h"
 #elif defined(ENABLE_BROWSER_CDMS)
+#include "content/renderer/media/cdm/render_cdm_factory.h"
 #include "content/renderer/media/cdm/renderer_cdm_manager.h"
 #endif
 
 #if defined(ENABLE_MOJO_MEDIA)
 #include "content/renderer/media/media_interface_provider.h"
 #endif
 
 #if defined(ENABLE_MOJO_CDM)
 #include "media/mojo/services/mojo_cdm_factory.h"  // nogncheck
-#else
-#include "content/renderer/media/cdm/render_cdm_factory.h"
 #endif
 
 #if defined(ENABLE_MOJO_RENDERER)
 #include "media/mojo/services/mojo_renderer_factory.h"  // nogncheck
 #else
 #include "media/renderers/default_renderer_factory.h"
 #endif
 
 #if defined(ENABLE_MOJO_AUDIO_DECODER) || defined(ENABLE_MOJO_VIDEO_DECODER)
 #include "media/mojo/services/mojo_decoder_factory.h"  // nogncheck
@@ skipping 513 matching lines @@
           main_resource_ssl_status.security_bits != ssl_status.security_bits ||
           main_resource_ssl_status.connection_status !=
               ssl_status.connection_status);
 }
 
 #if defined(OS_ANDROID)
 // Returns true if WMPI should be used for playback, false otherwise.
 //
 // Note that HLS and MP4 detection are pre-redirect and path-based. It is
 // possible to load such a URL and find different content.
-bool UseWebMediaPlayerImpl(blink::WebMediaPlayer::LoadType load_type,
-                           const GURL& url) {
-  if (load_type == blink::WebMediaPlayer::LoadTypeMediaSource)
-    return media::IsUnifiedMediaPipelineEnabledForMse();
-
+bool UseWebMediaPlayerImpl(const GURL& url) {

[DaleCurtis, 2016/03/23 17:51:54]

I wonder if we should have a if (!url.isHttpOrHttps()) return true here to avoid
any accidental blob/data urls ending with hls or mp4 extensions.

[xhwang, 2016/03/24 21:26:04]

For HLS, this is kinda covered in IsHLSPath().

For mp4, I have no strong opinions. We can probably add this check in in "if"
statement one line 770.

[wolenetz, 2016/03/24 22:16:26]

There should be no blob URL containing trailing .mp4 (or .m3u8). I think it'd be
incorrect currently for a properly formatted blob URL [1] [2] to have a 
trailing ".mp4" or (or ".m3u8"), since [.mpu] chars are not allowed within the
UUID portion of such a URL [3]. Otherwise, no strong opinion. We could
potentially protect against those specs changing by strengthening line 770. 

[1] code:
https://code.google.com/p/chromium/codesearch#chromium/src/third_party/WebKit...
[2] FILE API spec: https://www.w3.org/TR/FileAPI/#unicodeBlobURL
[3] RFC for the UUID portion of a blob URL: https://tools.ietf.org/html/rfc4122

   // WMPI does not support HLS.
   if (media::MediaCodecUtil::IsHLSPath(url))
     return false;
 
   // Don't use WMPI if the container likely contains a codec we can't decode in
   // software and hardware decoders are not available.

[ddorwin, 2016/03/24 18:05:11]

s/hardware/platform/

[xhwang, 2016/03/24 21:26:03]

Done.

   if (base::EndsWith(url.path(), ".mp4",
                      base::CompareCase::INSENSITIVE_ASCII) &&
       !media::HasPlatformDecoderSupport()) {
     return false;
   }

[xhwang, 2016/03/23 16:35:54]

ddorwin: So for HLS and .mp4 URL we'll still use mojo CDM if unified pipeline is
enabled. I think this is fine because EME isn't supported in either case
anyways.

[DaleCurtis, 2016/03/23 17:51:54]

At least for mp4, this is only in the case that we don't have a MediaCodec, so
we couldn't play the mp4 even if EME was supported.

[ddorwin, 2016/03/24 18:05:11]

For HLS, it doesn't make sense to use EME, so that's fine.

For MP4, .src= does not work anywhere because of
https://bugs.chromium.org/p/chromium/issues/detail?id=170793, so this is fine
for now.

If we fixed that bug:
* Not having platform decoder support means (I believe) that MediaCodec is not
available or the GPU process is not working. The former means EME won't work
anyway. The latter could work with WMPA, but I don't think it is an expected
case. Dale?
* Clear Key doesn't need platform decoders, but we won't use Mojo CDM for that,
right?

MimeUtil appears to be accurate (for H.264). When the unified pipeline is
enabled, we require HasPlatformDecoderSupport() for encrypted content.

More generally, do we plan to continue to support EME in the WMPA path once
we've fully switched to WMPI? Since MediaCodec is necessary, it would seem that
broken GPU process is the only case where we might fall back. (The current
MimeUtil logic doesn't appear to report support in this case anyway.)

[DaleCurtis, 2016/03/24 18:09:10]

Even if we "fixed" that bug for desktop/unified path, I don't think it would
ever be fixed for MediaPlayer so that case seems impossible.
I expect we'll kill off the non-unified MSE paths very quickly (M53?) since it's
not needed for any blacklist or non-Chrome codecs.

[xhwang, 2016/03/24 21:26:03]

MojoCdmFactory actually support Clear Key [1]. This is how Clear Key works with
unified pipeline (so that we could use DDS to decrypt on the render side).

But even with that, we still need a decoder to decode MP4, which won't work in
the unified pipeline. So we are not breaking anything.
Agreed. The non-unified EME path should go away too.


[1]
https://code.google.com/p/chromium/codesearch#chromium/src/media/mojo/service...

[ddorwin, 2016/03/24 21:43:49]

Unencrypted or Clear Key AAC does not require a decoder. Also,
https://bugs.chromium.org/p/chromium/issues/detail?id=580623.

[xhwang, 2016/03/24 22:37:23]

Good catch. We'll need to detect more to fix these cases. But I don't know
whether it's worth the effort.

 
   // Otherwise enable WMPI if indicated via experiment or command line.
   return media::IsUnifiedMediaPipelineEnabled();
 }
 #endif  // defined(OS_ANDROID)
 
 }  // namespace
 
 // static
 RenderFrameImpl* RenderFrameImpl::Create(RenderViewImpl* render_view,
@@ skipping 1586 matching lines @@
 
   WebPluginParams params_to_use = params;
   params_to_use.mimeType = WebString::fromUTF8(mime_type);
   return CreatePlugin(frame, info, params_to_use, nullptr /* throttler */);
 #else
   return NULL;
 #endif  // defined(ENABLE_PLUGINS)
 }
 
 blink::WebMediaPlayer* RenderFrameImpl::createMediaPlayer(
-    blink::WebMediaPlayer::LoadType load_type,
     const blink::WebURL& url,
     WebMediaPlayerClient* client,
     WebMediaPlayerEncryptedMediaClient* encrypted_client,
     WebContentDecryptionModule* initial_cdm,
     const blink::WebString& sink_id,
     WebMediaSession* media_session) {
 #if defined(VIDEO_HOLE)
   if (!contains_media_player_) {
     render_view_->RegisterVideoHoleFrame(this);
     contains_media_player_ = true;
@@ skipping 26 matching lines @@
                  static_cast<RenderFrame*>(this),
                  GetWebMediaPlayerDelegate()->has_played_media()),
       audio_renderer_sink, media_log, render_thread->GetMediaThreadTaskRunner(),
       render_thread->GetWorkerTaskRunner(),
       render_thread->compositor_task_runner(), context_3d_cb,
       base::Bind(&v8::Isolate::AdjustAmountOfExternalAllocatedMemory,
                  base::Unretained(blink::mainThreadIsolate())),
       initial_cdm, media_surface_manager_, media_session);
 
 #if defined(OS_ANDROID)
-  if (!UseWebMediaPlayerImpl(load_type, url))
+  if (!UseWebMediaPlayerImpl(url))
     return CreateAndroidWebMediaPlayer(client, encrypted_client, params);
 #endif  // defined(OS_ANDROID)
 
 #if defined(ENABLE_MOJO_RENDERER)
   scoped_ptr<media::RendererFactory> media_renderer_factory(
       new media::MojoRendererFactory(GetMediaInterfaceProvider()));
 #else
   scoped_ptr<media::RendererFactory> media_renderer_factory =
       GetContentClient()->renderer()->CreateMediaRendererFactory(
           this, render_thread->GetGpuFactories(), media_log);
@@ skipping 3454 matching lines @@
 #if defined(OS_ANDROID)
   // Hardware-secure codecs are only supported if secure surfaces are enabled.
   return render_view_->renderer_preferences_
       .use_video_overlay_for_embedded_encrypted_video;
 #else
   return false;
 #endif  // defined(OS_ANDROID)
 }
 
 media::CdmFactory* RenderFrameImpl::GetCdmFactory() {
-#if defined(ENABLE_BROWSER_CDMS)
+  if (cdm_factory_)
+    return cdm_factory_.get();
+
+#if defined(ENABLE_MOJO_CDM)
+  if (media::IsMojoCdmEnabled()) {

[Tima Vaisburd, 2016/03/23 19:27:52]

It looks like if ENABLE_MOJO_CDM is defined, and media::IsMojoCdmEnabled()
returns false, and neither CDMS is defined, this method returns nullptr. Is this
expected?

[xhwang, 2016/03/23 20:44:06]

Today we have ENABLE_BROWSER_CDMS enabled by default on Android. So in the case
you described, we'll fallback to linr 5919, which is the old WMPA EME path.

In the future, when to switch to mojo CDM exclusively and drop
ENABLE_BROWSER_CDMS, we'll end up with a null CDM factory, which is expected.

+    cdm_factory_.reset(new media::MojoCdmFactory(GetMediaInterfaceProvider()));
+    return cdm_factory_.get();
+  }
+#endif  //  defined(ENABLE_MOJO_CDM)
+
+#if defined(ENABLE_PEPPER_CDMS)
+  DCHECK(frame_);
+  cdm_factory_.reset(
+      new RenderCdmFactory(base::Bind(&PepperCdmWrapperImpl::Create, frame_)));
+#elif defined(ENABLE_BROWSER_CDMS)
   if (!cdm_manager_)
     cdm_manager_ = new RendererCdmManager(this);
-#endif  // defined(ENABLE_BROWSER_CDMS)
-
-  if (!cdm_factory_) {
-    DCHECK(frame_);
-
-#if defined(ENABLE_MOJO_CDM)
-    cdm_factory_.reset(new media::MojoCdmFactory(GetMediaInterfaceProvider()));
-#else
-    cdm_factory_.reset(new RenderCdmFactory(
-#if defined(ENABLE_PEPPER_CDMS)
-        base::Bind(&PepperCdmWrapperImpl::Create, frame_)
-#elif defined(ENABLE_BROWSER_CDMS)
-        cdm_manager_
-#endif
-            ));
-#endif  //  defined(ENABLE_MOJO_CDM)
-  }
+  cdm_factory_.reset(new RenderCdmFactory(cdm_manager_));
+#endif  // defined(ENABLE_PEPPER_CDMS)
 
   return cdm_factory_.get();
 }
 
 media::DecoderFactory* RenderFrameImpl::GetDecoderFactory() {
 #if defined(ENABLE_MOJO_AUDIO_DECODER) || defined(ENABLE_MOJO_VIDEO_DECODER)
   if (!decoder_factory_) {
     decoder_factory_.reset(
         new media::MojoDecoderFactory(GetMediaInterfaceProvider()));
   }
@@ skipping 64 matching lines @@
                                     int match_count,
                                     int ordinal,
                                     const WebRect& selection_rect,
                                     bool final_status_update) {
   Send(new FrameHostMsg_Find_Reply(routing_id_, request_id, match_count,
                                    selection_rect, ordinal,
                                    final_status_update));
 }
 
 }  // namespace content