Media Remoting: Add remoting control logic for encrypted contents.

media/remoting/remoting_renderer_controller.cc

 // Copyright 2016 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/remoting/remoting_controller.h"
+#include "media/remoting/remoting_renderer_controller.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
-#include "base/single_thread_task_runner.h"
+#include "base/threading/thread_checker.h"
+#include "media/remoting/remoting_cdm.h"
 
 namespace media {
 
-RemotingController::RemotingController(
-    mojom::RemotingSourceRequest source_request,
-    mojom::RemoterPtr remoter)
-    : binding_(this, std::move(source_request)),
-      remoter_(std::move(remoter)),
-      task_runner_(base::ThreadTaskRunnerHandle::Get()),
-      weak_factory_(this) {}
+RemotingRendererController::RemotingRendererController(
+    scoped_refptr<RemotingSourceImpl> remoting_source)
+    : remoting_source_(remoting_source), weak_factory_(this) {
+  remoting_source_->AddClient(this);
+}
 
-RemotingController::~RemotingController() {}
+RemotingRendererController::~RemotingRendererController() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  remoting_source_->RemoveClient(this);
+}
 
-void RemotingController::OnSinkAvailable() {
-  DCHECK(task_runner_->BelongsToCurrentThread());
+void RemotingRendererController::OnStarted(bool success) {
+  DCHECK(thread_checker_.CalledOnValidThread());
 
-  is_sink_available_ = true;
+  if (success) {
+    VLOG(1) << "Remoting started successively.";
+    if (remote_rendering_started_) {
+      DCHECK(!switch_renderer_cb_.is_null());
+      switch_renderer_cb_.Run();
+    } else {
+      remoting_source_->StopRemoting(this);
+    }
+  } else {
+    VLOG(1) << "Failed to start remoting.";
+    remote_rendering_started_ = false;
+  }
+}
+
+void RemotingRendererController::OnSessionStateChanged() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  VLOG(1) << "OnSessionStateChanged: " << remoting_source_->state();
   UpdateAndMaybeSwitch();
 }
 
-void RemotingController::OnSinkGone() {
-  DCHECK(task_runner_->BelongsToCurrentThread());
-
-  is_sink_available_ = false;
-  UpdateAndMaybeSwitch();
-}
-
-void RemotingController::OnStarted() {
-  DCHECK(task_runner_->BelongsToCurrentThread());
-
-  VLOG(1) << "Remoting started successively.";
-  if (is_remoting_)
-    switch_renderer_cb_.Run();
-  else
-    remoter_->Stop(mojom::RemotingStopReason::LOCAL_PLAYBACK);
-}
-
-void RemotingController::OnStartFailed(mojom::RemotingStartFailReason reason) {
-  DCHECK(task_runner_->BelongsToCurrentThread());
-
-  VLOG(1) << "Failed to start remoting:" << reason;
-  is_remoting_ = false;
-}
-
-void RemotingController::OnMessageFromSink(
-    const std::vector<uint8_t>& message) {
-  DCHECK(task_runner_->BelongsToCurrentThread());
-
-  // TODO(xjz): Merge with Eric's CL to handle the RPC messages here.
-  NOTIMPLEMENTED();
-}
-
-void RemotingController::OnStopped(mojom::RemotingStopReason reason) {
-  DCHECK(task_runner_->BelongsToCurrentThread());
-
-  VLOG(1) << "Remoting stopped: " << reason;
-  is_remoting_ = false;
-}
-
-void RemotingController::OnEnteredFullscreen() {
-  DCHECK(task_runner_->BelongsToCurrentThread());
+void RemotingRendererController::OnEnteredFullscreen() {
+  DCHECK(thread_checker_.CalledOnValidThread());
 
   is_fullscreen_ = true;
   UpdateAndMaybeSwitch();
 }
 
-void RemotingController::OnExitedFullscreen() {
-  DCHECK(task_runner_->BelongsToCurrentThread());
+void RemotingRendererController::OnExitedFullscreen() {
+  DCHECK(thread_checker_.CalledOnValidThread());
 
   is_fullscreen_ = false;
   UpdateAndMaybeSwitch();
 }
 
-void RemotingController::OnSetCdm(CdmContext* cdm_context) {
-  DCHECK(task_runner_->BelongsToCurrentThread());
+void RemotingRendererController::OnSetCdm(CdmContext* cdm_context) {
+  DCHECK(thread_checker_.CalledOnValidThread());
 
-  // TODO(xjz): Not implemented. Will add in up-coming change.
-  NOTIMPLEMENTED();
+  auto* cdm = RemotingCdm::From(cdm_context);
+  if (!cdm)
+    return;
+
+  remoting_source_->RemoveClient(this);
+  remoting_source_ = cdm->GetRemotingSource();
+  remoting_source_->AddClient(this);  // Calls OnSessionStateChanged().
+  UpdateAndMaybeSwitch();
 }
 
-void RemotingController::SetSwitchRendererCallback(
-    const SwitchRendererCallback& cb) {
-  DCHECK(task_runner_->BelongsToCurrentThread());
+void RemotingRendererController::SetSwitchRendererCallback(
+    const base::Closure& cb) {
+  DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!cb.is_null());
 
   switch_renderer_cb_ = cb;
+  UpdateAndMaybeSwitch();
 }
 
-void RemotingController::OnMetadataChanged(const PipelineMetadata& metadata) {
-  DCHECK(task_runner_->BelongsToCurrentThread());
+void RemotingRendererController::OnMetadataChanged(
+    const PipelineMetadata& metadata) {
+  DCHECK(thread_checker_.CalledOnValidThread());
 
-  has_video_ = metadata.has_video;
-  has_audio_ = metadata.has_audio;
-  if (!has_video_ && !has_audio_)
-    return;
+  has_video_ =
+      metadata.has_video && metadata.video_decoder_config.IsValidConfig();
+  has_audio_ =
+      metadata.has_audio && metadata.audio_decoder_config.IsValidConfig();
 
-  // On Android, when using the MediaPlayerRenderer, |has_video_| and
-  // |has_audio_| will be true, but the respective configs will be empty.
-  // We cannot make any assumptions on the validity of configs.
+  is_encrypted_ = false;
   if (has_video_) {
     video_decoder_config_ = metadata.video_decoder_config;
     is_encrypted_ |= video_decoder_config_.is_encrypted();
   }
   if (has_audio_) {
     audio_decoder_config_ = metadata.audio_decoder_config;
     is_encrypted_ |= audio_decoder_config_.is_encrypted();
   }
   UpdateAndMaybeSwitch();
 }
 
-bool RemotingController::IsVideoCodecSupported() {
-  DCHECK(task_runner_->BelongsToCurrentThread());
+bool RemotingRendererController::IsVideoCodecSupported() {
+  DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(has_video_);
 
   switch (video_decoder_config_.codec()) {
     case VideoCodec::kCodecH264:
     case VideoCodec::kCodecVP8:
       return true;
     default:
       VLOG(2) << "Remoting does not support video codec: "
               << video_decoder_config_.codec();
       return false;
   }
 }
 
-bool RemotingController::IsAudioCodecSupported() {
-  DCHECK(task_runner_->BelongsToCurrentThread());
+bool RemotingRendererController::IsAudioCodecSupported() {
+  DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(has_audio_);
 
   switch (audio_decoder_config_.codec()) {
     case AudioCodec::kCodecAAC:
     case AudioCodec::kCodecMP3:
     case AudioCodec::kCodecPCM:
     case AudioCodec::kCodecVorbis:
     case AudioCodec::kCodecFLAC:
     case AudioCodec::kCodecAMR_NB:
     case AudioCodec::kCodecAMR_WB:
     case AudioCodec::kCodecPCM_MULAW:
     case AudioCodec::kCodecGSM_MS:
     case AudioCodec::kCodecPCM_S16BE:
     case AudioCodec::kCodecPCM_S24BE:
     case AudioCodec::kCodecOpus:
     case AudioCodec::kCodecEAC3:
     case AudioCodec::kCodecPCM_ALAW:
     case AudioCodec::kCodecALAC:
     case AudioCodec::kCodecAC3:
       return true;
     default:
       VLOG(2) << "Remoting does not support audio codec: "
               << audio_decoder_config_.codec();
       return false;
   }
 }
 
-bool RemotingController::ShouldBeRemoting() {
-  DCHECK(task_runner_->BelongsToCurrentThread());
+bool RemotingRendererController::ShouldBeRemoting() {
+  DCHECK(thread_checker_.CalledOnValidThread());
 
-  // TODO(xjz): The control logic for EME will be added in a later CL.
-  if (is_encrypted_)
+  if (switch_renderer_cb_.is_null())
+    return false;
+  if (!has_audio_ && !has_video_)

[miu, 2016/10/31 20:10:31]

Does the pipeline ever give us "null" config change at the end of an encrypted
stream? If so, maybe this should be after the switch() statement?

[xjz, 2016/11/01 16:45:44]

It sounds to me checking this either before or after switch() statement is
correct. But |is_encrypted_| could be set to true only when this check returns
false, so there is no need to check this again for encrypted content. Now moved
this check after switch() statement.

     return false;
 
-  if (!is_sink_available_)
-    return false;
-  if (!is_fullscreen_)
-    return false;
+  // Explicitly ignoring |is_fullscreen_| since all EME content should trigger
+  // the start of remoting immediately, and not later after switching into
+  // fullscreen. This is required by current technical limitations.
+  // Note: For encrypted contents, once the CDM is created remotely, we will let
+  // RemotingRendererImpl handle all failures, e.g., video/audio codec is not
+  // supported, or session is permanently terminated.
+  RemotingSessionState state = remoting_source_->state();

[miu, 2016/10/31 20:10:31]

nit: const

[xjz, 2016/11/01 16:45:44]

Done.

+  if (is_encrypted_) {
+    return state == RemotingSessionState::SESSION_STARTED ||

[miu, 2016/10/31 20:10:31]

Let's make sure and have a comment explaining this logic (so we don't forget
prior discussions/conclusions). Something like:

"Due to technical limitations when playing encrypted content, once a remoting
session has been started, always return true here to indicate that the
RemotingRendererImpl should be used. In the stopped states, RemotingRendererImpl
will display an interstitial to notify the user that local rendering cannot be
resumed."

Also, in the last round of review, I had code comments explaining reasons for
returning true/false, and I think it makes sense to include those (again, for
documentative reasons). So, consider adding code comments here:

  if (switch_renderer_cb_.is_null())
    return false;  // No way to switch to a remoting Renderer impl.

and here:

  switch (state) {
    case SESSION_UNAVAILABLE:
      return false;  // Cannot remote media without a remote sink.
    case SESSION_CAN_START:
    case SESSION_STARTING:
    case SESSION_STARTED:
      break;  // Media remoting is possible, assuming other req's are met.
    case SESSION_STOPPING:
    case SESSION_PERMANENTLY_STOPPED:
      return false;  // Use local rendering after stopping remoting.
  }

and here:

  // Normally, entering fullscreen is the signal that starts remote rendering.
  // However, current technical limitations require encrypted content be remoted
  // without waiting for a user signal.
  return is_fullscreen_;

[xjz, 2016/11/01 16:45:44]

Done.

+           state == RemotingSessionState::SESSION_STOPPING ||
+           state == RemotingSessionState::SESSION_PERMANENTLY_STOPPED;
+  }
+
+  switch (state) {
+    case SESSION_CAN_START:
+    case SESSION_STARTING:
+    case SESSION_STARTED:
+      break;
+    case SESSION_STOPPING:
+    case SESSION_UNAVAILABLE:
+    case SESSION_PERMANENTLY_STOPPED:
+      return false;
+  }
   if (has_video_ && !IsVideoCodecSupported())
     return false;
   if (has_audio_ && !IsAudioCodecSupported())
     return false;
-  return true;
+  return is_fullscreen_;
 }
 
-void RemotingController::UpdateAndMaybeSwitch() {
-  DCHECK(task_runner_->BelongsToCurrentThread());
+void RemotingRendererController::UpdateAndMaybeSwitch() {
+  DCHECK(thread_checker_.CalledOnValidThread());
 
-  // TODO(xjz): The switching logic for encrypted content will be added in a
-  // later CL.
+  bool should_be_remoting = ShouldBeRemoting();
 
-  // Demuxer is not initialized yet.
-  if (!has_audio_ && !has_video_)
+  if (remote_rendering_started_ == should_be_remoting)
     return;
 
-  DCHECK(!switch_renderer_cb_.is_null());
+  // Switch between local renderer and remoting renderer.
+  remote_rendering_started_ = should_be_remoting;
 
-  bool should_be_remoting = ShouldBeRemoting();
-  if (is_remoting_ == should_be_remoting)
-    return;
-
-  // Switch between local and remoting.
-  is_remoting_ = should_be_remoting;
-  if (is_remoting_) {
-    // |swithc_renderer_cb_.Run()| will be called after remoting is started
+  if (remote_rendering_started_) {
+    DCHECK(!switch_renderer_cb_.is_null());
+    if (remoting_source_->state() ==
+        RemotingSessionState::SESSION_PERMANENTLY_STOPPED) {
+      switch_renderer_cb_.Run();
+      return;
+    }
+    // |switch_renderer_cb_.Run()| will be called after remoting is started
     // successfully.
-    remoter_->Start();
+    remoting_source_->StartRemoting(this);
   } else {
+    // For encrypted contents, it's only valid to switch to remoting renderer,

[miu, 2016/10/31 20:10:31]

s/contents/content/

Oh, and I just noticed we call StopRemoting(this) a few lines down. So, this
code comment should probably also explain (for other developers' benefit): "The
RemotingCdmController will force-stop the session when remoting has ended; so no
need to call StopRemoting() from here."

[xjz, 2016/11/01 16:45:45]

Done.

+    // and never back to the local renderer.
+    DCHECK(!is_encrypted_);
     switch_renderer_cb_.Run();
-    remoter_->Stop(mojom::RemotingStopReason::LOCAL_PLAYBACK);
+    remoting_source_->StopRemoting(this);
   }
 }
 
 }  // namespace media