Register MediaPlayerRenderer service

media/blink/webmediaplayer_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 "media/blink/webmediaplayer_impl.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <string>
@@ skipping 16 matching lines @@
 #include "build/build_config.h"
 #include "cc/blink/web_layer_impl.h"
 #include "cc/layers/video_layer.h"
 #include "media/audio/null_audio_sink.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/cdm_context.h"
 #include "media/base/limits.h"
 #include "media/base/media_content_type.h"
 #include "media/base/media_log.h"
 #include "media/base/media_switches.h"
+#include "media/base/media_url_demuxer.h"
 #include "media/base/text_renderer.h"
 #include "media/base/timestamp_constants.h"
 #include "media/base/video_frame.h"
 #include "media/blink/texttrack_impl.h"
 #include "media/blink/watch_time_reporter.h"
 #include "media/blink/webaudiosourceprovider_impl.h"
 #include "media/blink/webcontentdecryptionmodule_impl.h"
 #include "media/blink/webinbandtexttrack_impl.h"
 #include "media/blink/webmediaplayer_delegate.h"
 #include "media/blink/webmediaplayer_util.h"
 #include "media/blink/webmediasource_impl.h"
 #include "media/filters/chunk_demuxer.h"
 #include "media/filters/ffmpeg_demuxer.h"
+#include "media/media_features.h"
 #include "third_party/WebKit/public/platform/WebEncryptedMediaTypes.h"
 #include "third_party/WebKit/public/platform/WebMediaPlayerClient.h"
 #include "third_party/WebKit/public/platform/WebMediaPlayerEncryptedMediaClient.h"
 #include "third_party/WebKit/public/platform/WebMediaPlayerSource.h"
 #include "third_party/WebKit/public/platform/WebMediaSource.h"
 #include "third_party/WebKit/public/platform/WebRect.h"
 #include "third_party/WebKit/public/platform/WebSecurityOrigin.h"
 #include "third_party/WebKit/public/platform/WebSize.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
@@ skipping 1155 matching lines @@
 
   TRACE_EVENT0("media", "WebMediaPlayerImpl::OnNaturalSizeChanged");
   media_log_->AddEvent(media_log_->CreateVideoSizeSetEvent(
       rotated_size.width(), rotated_size.height()));
 
   if (overlay_enabled_ && surface_manager_)
     surface_manager_->NaturalSizeChanged(rotated_size);
 
   pipeline_metadata_.natural_size = rotated_size;
   client_->sizeChanged();
+
+  // Re-create the WatchTimeReporter, since it was created using an initial
+  // video size of (0,0).
+  if (use_fallback_path_)

[liberato (no reviews please), 2016/10/07 20:17:38]

if we aren't doing this on every natural size change normally, then i doubt what
we should do it here every time after the first.

in general, i'm worried that things like WatchTimeReporter::OnPlaying won't get
called in this case -- we don't get onNaturalSizeChanged from MP until after
play(), right?

WatchTimeReporter might need to learn how to change the size.  it looks like it
already keeps the appropriate state for "is playing", etc.  if so, then it might
be worth doing that as a separate CL, and just leave the failover path watch
time metrics broken (with comments) in this CL.

[tguilbert, 2016/10/11 18:54:33]

Ok. I need to do an HLS related UMA cleanup anyways, I will also cover this when
doing so. See 650891

+    CreateWatchTimeReporter();
 }
 
 void WebMediaPlayerImpl::OnVideoOpacityChange(bool opaque) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   DCHECK_NE(ready_state_, WebMediaPlayer::ReadyStateHaveNothing);
 
   opaque_ = opaque;
   // Modify content opaqueness of cc::Layer directly so that
   // SetContentsOpaqueIsFixed is ignored.
   if (video_weblayer_)
@@ skipping 110 matching lines @@
   return video_weblayer_->bounds();
 }
 
 void WebMediaPlayerImpl::SetDeviceScaleFactor(float scale_factor) {
   cast_impl_.SetDeviceScaleFactor(scale_factor);
 }
 
 void WebMediaPlayerImpl::setPoster(const blink::WebURL& poster) {
   cast_impl_.setPoster(poster);
 }
+
+void WebMediaPlayerImpl::EnableFallbackMediaPlayer(const GURL& url) {

[liberato (no reviews please), 2016/10/07 20:17:37]

this is very implementation-detail-like for an external caller.  can WMPI figure
this out internally, based on (e.g.) the url it's given?

[tguilbert, 2016/10/11 18:54:33]

Right now, as of this patch, |use_fallback_path_| is only used in StartPipeline.

We could accurately deduce it based off the the RendererFactory type, but that
is just a consequent of what UseWebMediaPlayerImpl() returns... I'm not sure how
I feel about adding a "prefered demuxer type" to the renderer factory interface.
We could also move the "UseWMPI/UseFallback" inside of WMPI; I don't know if
there any gotchas with the fact that the renderer factory is created outside of
WMPI, and the final redirected URL might change and not correspond to a type of
media that can be played with the renderer factory we were given.

WDYT?

+  fallback_url_ = url;

[liberato (no reviews please), 2016/10/06 14:55:46]

what's the difference between this and the one used in DoLoad?

[tguilbert, 2016/10/11 18:54:33]

None. Updated :)

+  use_fallback_path_ = true;
+}
 #endif  // defined(OS_ANDROID)  // WMPI_CAST
 
 void WebMediaPlayerImpl::DataSourceInitialized(bool success) {
   DVLOG(1) << __func__;
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
-#if defined(OS_ANDROID)
+#if defined(OS_ANDROID) && !BUILDFLAG(ENABLE_MOJO_MEDIA_PLAYER_RENDERER)
   // We can't play HLS URLs with WebMediaPlayerImpl, so in cases where they are
   // encountered, instruct the HTML media element to create a new WebMediaPlayer
   // instance with the correct URL to trigger WebMediaPlayerAndroid creation.
   //
   // TODO(tguilbert): Remove this code path once we have the ability to host a
   // MediaPlayer within a Mojo media renderer.  http://crbug.com/580626
   if (data_source_) {
     const GURL url_after_redirects = data_source_->GetUrlAfterRedirects();
     if (MediaCodecUtil::IsHLSPath(url_after_redirects)) {
       client_->requestReload(url_after_redirects);
@@ skipping 35 matching lines @@
   overlay_surface_id_ = surface_id;
   if (!pending_surface_request_cb_.is_null())
     base::ResetAndReturn(&pending_surface_request_cb_).Run(surface_id);
 }
 
 // TODO(watk): Move this state management out of WMPI.
 void WebMediaPlayerImpl::OnSurfaceRequested(
     const SurfaceCreatedCB& surface_created_cb) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   DCHECK(surface_manager_);
+  DCHECK(!use_fallback_path_);
 
   // A null callback indicates that the decoder is going away.
   if (surface_created_cb.is_null()) {
     decoder_requires_restart_for_overlay_ = false;
     pending_surface_request_cb_.Reset();
     return;
   }
 
   // If we're getting a surface request it means GVD is initializing, so until
   // we get a null surface request, GVD is the active decoder. While that's the
@@ skipping 27 matching lines @@
       media_task_runner_, worker_task_runner_, audio_source_provider_.get(),
       compositor_, request_surface_cb);
 }
 
 void WebMediaPlayerImpl::StartPipeline() {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   Demuxer::EncryptedMediaInitDataCB encrypted_media_init_data_cb =
       BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnEncryptedMediaInitData);
 
+  if (use_fallback_path_) {
+    demuxer_.reset(new MediaUrlDemuxer(media_task_runner_, fallback_url_));
+
+    // TODO(tguilbert): For reviewers -- What are the proper values for
+    // |is_streaming| and |is_static|?
+    pipeline_controller_.Start(demuxer_.get(), this, false, false);
+    return;
+  }
+
   // Figure out which demuxer to use.
   if (load_type_ != LoadTypeMediaSource) {
     DCHECK(!chunk_demuxer_);
     DCHECK(data_source_);
 
 #if !defined(MEDIA_DISABLE_FFMPEG)
     Demuxer::MediaTracksUpdatedCB media_tracks_updated_cb =
         BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnFFmpegMediaTracksUpdated);
 
     demuxer_.reset(new FFmpegDemuxer(media_task_runner_, data_source_.get(),
@@ skipping 341 matching lines @@
       pipeline_metadata_.natural_size,
       base::Bind(&GetCurrentTimeInternal, this)));
   watch_time_reporter_->OnVolumeChange(volume_);
   if (delegate_ && delegate_->IsHidden())
     watch_time_reporter_->OnHidden();
   else
     watch_time_reporter_->OnShown();
 }
 
 }  // namespace media