WIP - WebMediaPlayer switch media renderer.

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 149 matching lines @@
   (DCHECK(main_task_runner_->BelongsToCurrentThread()), \
   BindToCurrentLoop(base::Bind(function, AsWeakPtr(), arg1)))
 
 WebMediaPlayerImpl::WebMediaPlayerImpl(
     blink::WebLocalFrame* frame,
     blink::WebMediaPlayerClient* client,
     blink::WebMediaPlayerEncryptedMediaClient* encrypted_client,
     base::WeakPtr<WebMediaPlayerDelegate> delegate,
     std::unique_ptr<RendererFactory> renderer_factory,
     linked_ptr<UrlIndex> url_index,
+    RendererController* renderer_controller,
     const WebMediaPlayerParams& params)
     : frame_(frame),
       delegate_state_(DelegateState::GONE),
       is_idle_(false),
       must_suspend_(false),
       network_state_(WebMediaPlayer::NetworkStateEmpty),
       ready_state_(WebMediaPlayer::ReadyStateHaveNothing),
       highest_ready_state_(WebMediaPlayer::ReadyStateHaveNothing),
       preload_(MultibufferDataSource::AUTO),
       buffering_strategy_(MultibufferDataSource::BUFFERING_STRATEGY_NORMAL),
@@ skipping 40 matching lines @@
       cast_impl_(this, client_, params.context_3d_cb()),
 #endif
       volume_(1.0),
       volume_multiplier_(1.0),
       renderer_factory_(std::move(renderer_factory)),
       surface_manager_(params.surface_manager()),
       overlay_surface_id_(SurfaceManager::kNoSurfaceID),
       suppress_destruction_errors_(false),
       can_suspend_state_(CanSuspendState::UNKNOWN),
       is_encrypted_(false),
-      underflow_count_(0) {
+      underflow_count_(0),
+      renderer_controller_(renderer_controller) {
   DCHECK(!adjust_allocated_memory_cb_.is_null());
   DCHECK(renderer_factory_);
   DCHECK(client_);
 
   force_video_overlays_ = base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kForceVideoOverlays);
 
   disable_fullscreen_video_overlays_ =
       !base::FeatureList::IsEnabled(media::kOverlayFullscreenVideo);
 
@@ skipping 10 matching lines @@
   }
 
   // TODO(xhwang): When we use an external Renderer, many methods won't work,
   // e.g. GetCurrentFrameFromCompositor(). See http://crbug.com/434861
 
   // Use the null sink if no sink was provided.
   audio_source_provider_ = new WebAudioSourceProviderImpl(
       params.audio_renderer_sink().get()
           ? params.audio_renderer_sink()
           : new NullAudioSink(media_task_runner_));
+
+  if (renderer_controller_)
+    renderer_controller_->SetSwitchRenderCallback(
+        base::Bind(&WebMediaPlayerImpl::ScheduleRestart, AsWeakPtr()));
 }
 
 WebMediaPlayerImpl::~WebMediaPlayerImpl() {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
+  renderer_controller_ = nullptr;

[miu, 2016/09/28 01:33:31]

Along the lines of other comments: Call controller_->SetMediaPlayer(nullptr)
here to notify the controller that it cannot reference the MediaPlayer anymore.

[xjz, 2016/09/29 22:54:21]

Removed this line.

+
   suppress_destruction_errors_ = true;
   if (delegate_) {
     delegate_->PlayerGone(delegate_id_);
     delegate_->RemoveObserver(delegate_id_);
   }
 
   // Finalize any watch time metrics before destroying the pipeline.
   watch_time_reporter_.reset();
 
   // Pipeline must be stopped before it is destroyed.
@@ skipping 54 matching lines @@
   surface_created_cb_.Cancel();
   overlay_surface_id_ = SurfaceManager::kNoSurfaceID;
 
   if (decoder_requires_restart_for_overlay_)
     ScheduleRestart();
 }
 
 void WebMediaPlayerImpl::enteredFullscreen() {
   if (!force_video_overlays_ && !disable_fullscreen_video_overlays_)
     EnableOverlay();
+  if (renderer_controller_)
+    renderer_controller_->OnEnteredFullscreen();
 }
 
 void WebMediaPlayerImpl::exitedFullscreen() {
   if (!force_video_overlays_ && !disable_fullscreen_video_overlays_)
     DisableOverlay();
+  if (renderer_controller_)
+    renderer_controller_->OnExitedFullscreen();
 }
 
 void WebMediaPlayerImpl::DoLoad(LoadType load_type,
                                 const blink::WebURL& url,
                                 CORSMode cors_mode) {
   DVLOG(1) << __func__;
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   GURL gurl(url);
   ReportMetrics(load_type, gurl, frame_->getSecurityOrigin());
@@ skipping 591 matching lines @@
   }
 }
 
 void WebMediaPlayerImpl::SetCdm(const CdmAttachedCB& cdm_attached_cb,
                                 CdmContext* cdm_context) {
   if (!cdm_context) {
     cdm_attached_cb.Run(false);
     return;
   }
 
+  if (renderer_controller_)
+    renderer_controller_->OnSetCdm(cdm_context);
+
   // If CDM initialization succeeded, tell the pipeline about it.
   pipeline_.SetCdm(cdm_context, cdm_attached_cb);
 }
 
 void WebMediaPlayerImpl::OnCdmAttached(bool success) {
   if (success) {
     set_cdm_result_->complete();
     set_cdm_result_.reset();
     is_cdm_attached_ = true;
     return;
@@ skipping 116 matching lines @@
 
     if (overlay_enabled_ && surface_manager_)
       surface_manager_->NaturalSizeChanged(pipeline_metadata_.natural_size);
 
     DCHECK(!video_weblayer_);
     video_weblayer_.reset(new cc_blink::WebLayerImpl(cc::VideoLayer::Create(
         compositor_, pipeline_metadata_.video_rotation)));
     video_weblayer_->layer()->SetContentsOpaque(opaque_);
     video_weblayer_->SetContentsOpaqueIsFixed(true);
     client_->setWebLayer(video_weblayer_.get());
+    if (renderer_controller_)
+      renderer_controller_->OnSetDecoderConfig(

[miu, 2016/09/28 01:33:31]

naming nit: If this could be called multiple times, let's name this
OnDecoderConfigChanged().

[xjz, 2016/09/29 22:54:21]

Done.

+          pipeline_metadata_.audio_decoder_config,
+          pipeline_metadata_.video_decoder_config);
   }
 
   CreateWatchTimeReporter();
   UpdatePlayState();
 }
 
 void WebMediaPlayerImpl::OnBufferingStateChange(BufferingState state) {
   DVLOG(1) << __func__ << "(" << state << ")";
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
@@ skipping 712 matching lines @@
       hasAudio(), hasVideo(), !!chunk_demuxer_, is_encrypted_, media_log_,
       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();
 }
 
+void WebMediaPlayerImpl::ancestorEnteredFullscreen() {
+  if (renderer_controller_)
+    renderer_controller_->OnEnteredFullscreen();
+}
+
+void WebMediaPlayerImpl::ancestorExitedFullscreen() {
+  if (renderer_controller_)
+    renderer_controller_->OnExitedFullscreen();
+}
+
 }  // namespace media