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 189 matching lines @@
       is_cdm_attached_(false),
 #if defined(OS_ANDROID)  // WMPI_CAST
       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) {
+      can_suspend_state_(CanSuspendState::UNKNOWN),
+      is_media_remoting_(false),
+      is_remote_sink_available_(false),
+      is_encrypted_content_(false),
+      is_remote_cdm_cb_(params.is_remote_cdm_cb()) {
   DCHECK(!adjust_allocated_memory_cb_.is_null());
   DCHECK(renderer_factory_);
   DCHECK(client_);
 
   force_video_overlays_ = base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kForceVideoOverlays);
 
   if (delegate_)
     delegate_id_ = delegate_->AddObserver(this);
 
@@ skipping 83 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_)
     EnableOverlay();
+  videoEnteredFullscreen();
 }
 
 void WebMediaPlayerImpl::exitedFullscreen() {
   if (!force_video_overlays_)
     DisableOverlay();
+  videoExitedFullscreen();
 }
 
 void WebMediaPlayerImpl::DoLoad(LoadType load_type,
                                 const blink::WebURL& url,
                                 CORSMode cors_mode) {
   DVLOG(1) << __FUNCTION__;
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   GURL gurl(url);
   ReportMetrics(load_type, gurl, frame_->getSecurityOrigin());
@@ skipping 528 matching lines @@
 }
 
 void WebMediaPlayerImpl::OnEncryptedMediaInitData(
     EmeInitDataType init_data_type,
     const std::vector<uint8_t>& init_data) {
   DCHECK(init_data_type != EmeInitDataType::UNKNOWN);
 
   // TODO(xhwang): Update this UMA name. https://crbug.com/589251
   UMA_HISTOGRAM_COUNTS("Media.EME.NeedKey", 1);
 
+  is_encrypted_content_ = true;
+  // Check whether we can switch to remoting for encrypted video. Once switching
+  // happens, it is not able to switch back to local media renderer without
+  // refreshing the page.
+  if (is_remote_sink_available_ && !is_media_remoting_ &&
+      !is_remote_cdm_cb_.is_null() && is_remote_cdm_cb_.Run()) {
+    is_media_remoting_ = true;
+    SwitchMediaRenderer();
+  }
+
   encrypted_client_->encrypted(
       ConvertToWebInitDataType(init_data_type), init_data.data(),
       base::saturated_cast<unsigned int>(init_data.size()));
 }
 
 void WebMediaPlayerImpl::OnFFmpegMediaTracksUpdated(
     std::unique_ptr<MediaTracks> tracks) {
   // For MSE/chunk_demuxer case the media track updates are handled by
   // WebSourceBufferImpl.
   DCHECK(demuxer_.get());
@@ skipping 841 matching lines @@
   // Remote players will be suspended and locally paused.
   if (isRemote())
     return;
 #endif
 
   // Idle timeout chosen arbitrarily.
   background_pause_timer_.Start(FROM_HERE, base::TimeDelta::FromSeconds(5),
                                 this, &WebMediaPlayerImpl::OnPause);
 }
 
+void WebMediaPlayerImpl::videoEnteredFullscreen() {
+  if (is_encrypted_content_ || is_media_remoting_ || !is_remote_sink_available_)
+    return;
+
+  is_media_remoting_ = true;
+  SwitchMediaRenderer();
+}
+
+void WebMediaPlayerImpl::videoExitedFullscreen() {
+  if (is_encrypted_content_ || !is_media_remoting_)
+    return;
+
+  is_media_remoting_ = false;
+  SwitchMediaRenderer();
+}
+
+void WebMediaPlayerImpl::OnSinkAvailable() {

[liberato (no reviews please), 2016/08/29 16:49:12]

would it be clearer if these things were pulled out into another class?

for example, could wmpi check someNewCastStateThing_.IsMediaRemoting()?  it
could chain calls to videoEnteredFullscreen over to someNewCastStateThing, too. 
OnSink* could be moved over.

it might make things more cumbersome, but it depends a lot on how much code is
going to be added.  it also depends on where the callbacks are set up, etc.

not sure if it would make things clearer, or just end up with a bunch of chained
methods from wmpi => new thing without really removing much code.

[xjz, 2016/09/09 23:13:06]

Yes. Done. 

+  is_remote_sink_available_ = true;
+}
+
+void WebMediaPlayerImpl::OnSinkGone() {
+  is_remote_sink_available_ = false;
+  if (is_media_remoting_) {
+    is_media_remoting_ = false;
+    if (!is_encrypted_content_) {
+      SwitchMediaRenderer();
+    } else {
+      // TODO(xjz): Need to tell the user to refresh the page.
+    }
+  }
+}
+
+// Switch media renderer between local playing back and remoting media renderer

[liberato (no reviews please), 2016/08/29 16:49:12]

please move this to the .h (good comment, by the way).

[xjz, 2016/09/09 23:13:06]

Done.

+// according to |is_media_remoting_|.
+// Note: Always set |is_media_remoting_| accordingly before calling this method.
+void WebMediaPlayerImpl::SwitchMediaRenderer() {

[liberato (no reviews please), 2016/08/29 16:49:12]

maybe take the new value of is_media_remoting_ as an argument, and have it take
responsibility for setting it.

[xjz, 2016/09/09 23:13:06]

Done.

+  VLOG(2) << "Switch to: " << (is_media_remoting_ ? "Remoting" : "Local");
+  pipeline_controller_.Suspend();
+  pipeline_controller_.Resume();

[liberato (no reviews please), 2016/08/29 16:49:12]

how does this switch to remote playback?

is there there logic going to go into CreateRenderer to check
is_media_remoting_?

[xjz, 2016/09/09 23:13:06]

Yes. The implementation will be in the upcoming CL. Added comment for this.

+}
+
 }  // namespace media