media: Replace DecryptorReadyCB with CdmReadyCB.

content/renderer/media/android/webmediaplayer_android.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 "content/renderer/media/android/webmediaplayer_android.h"
 
 #include <limits>
 
 #include "base/android/build_info.h"
 #include "base/bind.h"
@@ skipping 168 matching lines @@
       media_permission_(params.media_permission()),
       network_state_(WebMediaPlayer::NetworkStateEmpty),
       ready_state_(WebMediaPlayer::ReadyStateHaveNothing),
       texture_id_(0),
       stream_id_(0),
       is_player_initialized_(false),
       is_playing_(false),
       needs_establish_peer_(true),
       has_size_info_(false),
       // Threaded compositing isn't enabled universally yet.
-      compositor_task_runner_(
-          params.compositor_task_runner()
-              ? params.compositor_task_runner()
-              : base::ThreadTaskRunnerHandle::Get()),
+      compositor_task_runner_(params.compositor_task_runner()
+                                  ? params.compositor_task_runner()
+                                  : base::ThreadTaskRunnerHandle::Get()),
       stream_texture_factory_(factory),
       needs_external_surface_(false),
       is_fullscreen_(false),
-      video_frame_provider_client_(NULL),
+      video_frame_provider_client_(nullptr),
       player_type_(MEDIA_PLAYER_TYPE_URL),
       is_remote_(false),
       media_log_(params.media_log()),
       init_data_type_(media::EmeInitDataType::UNKNOWN),
-      cdm_context_(NULL),
+      cdm_context_(nullptr),
       allow_stored_credentials_(false),
       is_local_resource_(false),
       interpolator_(&default_tick_clock_),
       weak_factory_(this) {
   DCHECK(player_manager_);
   DCHECK(cdm_factory_);
 
   DCHECK(main_thread_checker_.CalledOnValidThread());
   stream_texture_factory_->AddObserver(this);
 
@@ skipping 107 matching lines @@
 
     media_source_delegate_.reset(new MediaSourceDelegate(
         demuxer, demuxer_client_id, media_task_runner_, media_log_));
 
     if (player_type_ == MEDIA_PLAYER_TYPE_MEDIA_SOURCE) {
       media_source_delegate_->InitializeMediaSource(
           base::Bind(&WebMediaPlayerAndroid::OnMediaSourceOpened,
                      weak_factory_.GetWeakPtr()),
           base::Bind(&WebMediaPlayerAndroid::OnEncryptedMediaInitData,
                      weak_factory_.GetWeakPtr()),
-          base::Bind(&WebMediaPlayerAndroid::SetDecryptorReadyCB,
+          base::Bind(&WebMediaPlayerAndroid::SetCdmReadyCB,
                      weak_factory_.GetWeakPtr()),
           base::Bind(&WebMediaPlayerAndroid::UpdateNetworkState,
                      weak_factory_.GetWeakPtr()),
           base::Bind(&WebMediaPlayerAndroid::OnDurationChanged,
                      weak_factory_.GetWeakPtr()),
           base::Bind(&WebMediaPlayerAndroid::OnWaitingForDecryptionKey,
                      weak_factory_.GetWeakPtr()));
       InitializePlayer(url_, frame_->document().firstPartyForCookies(),
                        true, demuxer_client_id);
     }
@@ skipping 1364 matching lines @@
   if (!cdm) {
     result.completeWithError(
         blink::WebContentDecryptionModuleExceptionInvalidStateError, 0,
         "The existing MediaKeys object cannot be removed at this time.");
     return;
   }
 
   cdm_context_ = media::ToWebContentDecryptionModuleImpl(cdm)->GetCdmContext();
 
   if (is_player_initialized_) {
-    SetCdmInternal(media::BindToCurrentLoop(
+    SetCdmInternal(
         base::Bind(&WebMediaPlayerAndroid::ContentDecryptionModuleAttached,
-                   weak_factory_.GetWeakPtr(), result)));
+                   weak_factory_.GetWeakPtr(), result));
   } else {
     // No pipeline/decoder connected, so resolve the promise. When something
-    // is connected, setting the CDM will happen in SetDecryptorReadyCB().
+    // is connected, setting the CDM will happen in SetCdmReadyCB().
     ContentDecryptionModuleAttached(result, true);
   }
 }
 
 void WebMediaPlayerAndroid::ContentDecryptionModuleAttached(
     blink::WebContentDecryptionModuleResult result,
     bool success) {
   if (success) {
     result.complete();
     return;
@@ skipping 93 matching lines @@
   }
 
   cdm_context_ = cdm_context;
 
   if (is_player_initialized_)
     SetCdmInternal(base::Bind(&media::IgnoreCdmAttached));
 }
 
 void WebMediaPlayerAndroid::SetCdmInternal(
     const media::CdmAttachedCB& cdm_attached_cb) {
+  DCHECK(main_thread_checker_.CalledOnValidThread());
   DCHECK(cdm_context_ && is_player_initialized_);
   DCHECK(cdm_context_->GetDecryptor() ||
          cdm_context_->GetCdmId() != media::CdmContext::kInvalidCdmId)
       << "CDM should support either a Decryptor or a CDM ID.";
 
-  media::Decryptor* decryptor = cdm_context_->GetDecryptor();
+  if (cdm_ready_cb_.is_null()) {
+    cdm_attached_cb.Run(true);
+    return;
+  }
 
-  // Note:
-  // - If |decryptor| is non-null, only handles |decryptor_ready_cb_| and
-  //   ignores the CDM ID.
-  // - If |decryptor| is null (in which case the CDM ID should be valid),
-  //   returns any pending |decryptor_ready_cb_| with null, so that
-  //   MediaSourceDelegate will fall back to use a browser side (IPC-based) CDM,
-  //   then calls SetCdm() through the |player_manager_|.
+  // Satisfy |cdm_ready_cb_|. Use BindToCurrentLoop() since the callback could
+  // be fired on other threads.
+  base::ResetAndReturn(&cdm_ready_cb_)
+      .Run(cdm_context_, media::BindToCurrentLoop(base::Bind(
+                             &WebMediaPlayerAndroid::OnCdmAttached,
+                             weak_factory_.GetWeakPtr(), cdm_attached_cb)));
+}
 
-  if (decryptor) {
-    if (!decryptor_ready_cb_.is_null()) {
-      base::ResetAndReturn(&decryptor_ready_cb_)
-          .Run(decryptor, cdm_attached_cb);
-    } else {
-      cdm_attached_cb.Run(true);
+void WebMediaPlayerAndroid::OnCdmAttached(
+    const media::CdmAttachedCB& cdm_attached_cb,
+    bool success) {
+  DCHECK(main_thread_checker_.CalledOnValidThread());
+
+  if (!success) {
+    if (cdm_context_->GetCdmId() == media::CdmContext::kInvalidCdmId) {
+      NOTREACHED() << "CDM cannot be attached to media player.";
+      cdm_attached_cb.Run(false);
+      return;
+    }
+
+    // If the CDM is not attached (e.g. the CDM does not support a Decryptor),
+    // MediaSourceDelegate will fall back to use a browser side (IPC-based) CDM.
+    player_manager_->SetCdm(player_id_, cdm_context_->GetCdmId());
+  }
+
+  cdm_attached_cb.Run(true);
+}
+
+void WebMediaPlayerAndroid::SetCdmReadyCB(
+    const media::CdmReadyCB& cdm_ready_cb) {
+  DCHECK(main_thread_checker_.CalledOnValidThread());
+  DCHECK(is_player_initialized_);
+
+  // Cancels the previous CDM request.
+  if (cdm_ready_cb.is_null()) {
+    if (!cdm_ready_cb_.is_null()) {
+      base::ResetAndReturn(&cdm_ready_cb_)
+          .Run(nullptr, base::Bind(&media::IgnoreCdmAttached));
     }
     return;
   }
 
-  // |decryptor| is null.
-  if (!decryptor_ready_cb_.is_null()) {
-    base::ResetAndReturn(&decryptor_ready_cb_)
-        .Run(nullptr, base::Bind(&media::IgnoreCdmAttached));
-  }
-
-  DCHECK(cdm_context_->GetCdmId() != media::CdmContext::kInvalidCdmId);
-  player_manager_->SetCdm(player_id_, cdm_context_->GetCdmId());
-  cdm_attached_cb.Run(true);
-}
-
-void WebMediaPlayerAndroid::SetDecryptorReadyCB(
-    const media::DecryptorReadyCB& decryptor_ready_cb) {
-  DCHECK(main_thread_checker_.CalledOnValidThread());
-  DCHECK(is_player_initialized_);
-
-  // Cancels the previous decryptor request.
-  if (decryptor_ready_cb.is_null()) {
-    if (!decryptor_ready_cb_.is_null()) {
-      base::ResetAndReturn(&decryptor_ready_cb_)
-          .Run(NULL, base::Bind(&media::IgnoreCdmAttached));
-    }
-    return;
-  }
-
-  // TODO(xhwang): Support multiple decryptor notification request (e.g. from
+  // TODO(xhwang): Support multiple CDM notification request (e.g. from
   // video and audio). The current implementation is okay for the current
   // media pipeline since we initialize audio and video decoders in sequence.
-  // But WebMediaPlayerImpl should not depend on media pipeline's implementation
-  // detail.
-  DCHECK(decryptor_ready_cb_.is_null());
+  // But WebMediaPlayerAndroid should not depend on media pipeline's
+  // implementation detail.
+  DCHECK(cdm_ready_cb_.is_null());
+  cdm_ready_cb_ = cdm_ready_cb;
 
-  if (cdm_context_) {
-    decryptor_ready_cb.Run(cdm_context_->GetDecryptor(),
-                           base::Bind(&media::IgnoreCdmAttached));
-    return;
-  }
-
-  decryptor_ready_cb_ = decryptor_ready_cb;
+  if (cdm_context_)
+    SetCdmInternal(base::Bind(&media::IgnoreCdmAttached));
 }
 
 bool WebMediaPlayerAndroid::supportsOverlayFullscreenVideo() {
   return true;
 }
 
 void WebMediaPlayerAndroid::enterFullscreen() {
   if (is_player_initialized_)
     player_manager_->EnterFullscreen(player_id_);
   SetNeedsEstablishPeer(false);
@@ skipping 14 matching lines @@
 
   bool is_hls = IsHLSStream();
   UMA_HISTOGRAM_BOOLEAN("Media.Android.IsHttpLiveStreamingMedia", is_hls);
   if (is_hls) {
     media::RecordOriginOfHLSPlayback(
         GURL(frame_->document().securityOrigin().toString()));
   }
 }
 
 }  // namespace content