WIP - Add EME

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) {}
-
-RemotingController::~RemotingController() {}
-
-void RemotingController::OnSinkAvailable() {
-  DCHECK(task_runner_->BelongsToCurrentThread());
-
-  is_sink_available_ = true;
-  UpdateAndMaybeSwitch();
+RemotingRendererController::RemotingRendererController(
+    scoped_refptr<RemotingSourceImpl> remoting_source)
+    : remoting_source_(remoting_source), weak_factory_(this) {
+  remoting_source_->AddClient(this);
 }
 
-void RemotingController::OnSinkGone() {
-  DCHECK(task_runner_->BelongsToCurrentThread());
-
-  is_sink_available_ = false;
-  UpdateAndMaybeSwitch();
+RemotingRendererController::~RemotingRendererController() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  remoting_source_->RemoveClient(this);
 }
 
-void RemotingController::OnStarted() {
-  DCHECK(task_runner_->BelongsToCurrentThread());
+void RemotingRendererController::OnStarted(bool success) {
+  DCHECK(thread_checker_.CalledOnValidThread());
 
-  VLOG(1) << "Remoting started successively.";
-  if (is_remoting_)
-    switch_renderer_cb_.Run();
-  else
-    remoter_->Stop(mojom::RemotingStopReason::LOCAL_PLAYBACK);
+  DCHECK(!switch_renderer_cb_.is_null());
+  if (success) {
+    VLOG(1) << "Remoting started successively.";
+    if (remote_rendering_started_)
+      switch_renderer_cb_.Run();
+    else
+      remoting_source_->StopRemoting(this);
+  } else {
+    VLOG(1) << "Failed to start remoting.";
+    remote_rendering_started_ = false;
+  }
 }
 
-void RemotingController::OnStartFailed(mojom::RemotingStartFailReason reason) {
-  DCHECK(task_runner_->BelongsToCurrentThread());
+void RemotingRendererController::OnSessionStateChanged() {
+  DCHECK(thread_checker_.CalledOnValidThread());
 
-  VLOG(1) << "Failed to start remoting:" << reason;
-  is_remoting_ = false;
+  VLOG(1) << "OnSessionStateChanged: " << remoting_source_->state();
+  bool session_could_remote = session_can_remote_;
+  switch (remoting_source_->state()) {
+    case SESSION_CAN_START:
+    case SESSION_STARTING:
+    case SESSION_STARTED:
+      session_can_remote_ = true;
+      break;
+    case SESSION_STOPPING:
+    case SESSION_UNAVAILABLE:
+    case SESSION_PERMANENTLY_STOPPED:
+      session_can_remote_ = false;
+      break;
+  }
+  if (session_can_remote_ != session_could_remote)
+    UpdateAndMaybeSwitch();
 }
 
-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 (!session_can_remote_)
     return false;
-
-  if (!is_sink_available_)
+  if (switch_renderer_cb_.is_null())
     return false;
-  if (!is_fullscreen_)
+  if (!has_audio_ && !has_video_)
     return false;
   if (has_video_ && !IsVideoCodecSupported())
     return false;
   if (has_audio_ && !IsAudioCodecSupported())
     return false;
-  return true;
+
+  // 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.
+  if (is_encrypted_)
+    return remoting_source_->state() == RemotingSessionState::SESSION_STARTED;
+
+  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_)
+  // When OnSetCdm() is called, if the session that creates CDM remotely was
+  // permanently terminated, we need to render the failure page.
+  if (!remote_rendering_started_ && IsTerminated() &&
+      !session_permanently_terminated_) {
+    session_permanently_terminated_ = IsTerminated();
+    DCHECK(!switch_renderer_cb_.is_null());
+    switch_renderer_cb_.Run();
+    return;
+  }
+
+  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_) {
+    // |switch_renderer_cb_.Run()| will be called after remoting is started
     // successfully.
-    remoter_->Start();
+    remoting_source_->StartRemoting(this);
   } else {
     switch_renderer_cb_.Run();
-    remoter_->Stop(mojom::RemotingStopReason::LOCAL_PLAYBACK);
+    remoting_source_->StopRemoting(this);
   }
 }
 
+bool RemotingRendererController::IsRenderingRemotely() const {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  return remote_rendering_started_;
+}
+
+bool RemotingRendererController::IsTerminated() const {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  return remoting_source_->state() ==
+         RemotingSessionState::SESSION_PERMANENTLY_STOPPED;
+}
+
 }  // namespace media