Delete browser MSE implementation.

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 <stddef.h>
 
 #include <limits>
 
 #include "base/android/build_info.h"
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "cc/blink/web_layer_impl.h"
 #include "cc/layers/video_layer.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/renderer_preferences.h"
 #include "content/public/renderer/render_frame.h"
-#include "content/renderer/media/android/renderer_demuxer_android.h"
 #include "content/renderer/media/android/renderer_media_player_manager.h"
 #include "content/renderer/render_frame_impl.h"
 #include "content/renderer/render_thread_impl.h"
 #include "content/renderer/render_view_impl.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/command_buffer/common/constants.h"
 #include "gpu/command_buffer/common/mailbox_holder.h"
 #include "media/base/android/media_codec_util.h"
 #include "media/base/android/media_common_android.h"
 #include "media/base/android/media_player_android.h"
 #include "media/base/bind_to_current_loop.h"
-#include "media/base/cdm_context.h"
 #include "media/base/media_content_type.h"
 #include "media/base/media_keys.h"
 #include "media/base/media_log.h"
 #include "media/base/media_switches.h"
 #include "media/base/timestamp_constants.h"
 #include "media/base/video_frame.h"
 #include "media/blink/webcontentdecryptionmodule_impl.h"
 #include "media/blink/webmediaplayer_cast_android.h"
 #include "media/blink/webmediaplayer_delegate.h"
 #include "media/blink/webmediaplayer_util.h"
@@ skipping 83 matching lines @@
     blink::WebMediaPlayerClient* client,
     blink::WebMediaPlayerEncryptedMediaClient* encrypted_client,
     base::WeakPtr<media::WebMediaPlayerDelegate> delegate,
     RendererMediaPlayerManager* player_manager,
     scoped_refptr<StreamTextureFactory> factory,
     int frame_id,
     bool enable_texture_copy,
     const media::WebMediaPlayerParams& params)
     : frame_(frame),
       client_(client),
-      encrypted_client_(encrypted_client),
       delegate_(delegate),
       delegate_id_(0),
       defer_load_cb_(params.defer_load_cb()),
       buffered_(static_cast<size_t>(1)),
       media_task_runner_(params.media_task_runner()),
       ignore_metadata_duration_change_(false),

[wolenetz, 2016/09/30 23:23:24]

Without MSE, this field and associated conditions are no longer necessary in
WMPA.

[DaleCurtis, 2016/09/30 23:34:24]

Removed.

       pending_seek_(false),
       seeking_(false),
       did_loading_progress_(false),
       player_manager_(player_manager),
       network_state_(WebMediaPlayer::NetworkStateEmpty),
       ready_state_(WebMediaPlayer::ReadyStateHaveNothing),
       texture_id_(0),
       stream_id_(0),
       is_player_initialized_(false),
       is_playing_(false),
       is_play_pending_(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()),
       stream_texture_factory_(factory),
       is_fullscreen_(false),
       video_frame_provider_client_(nullptr),
       player_type_(MEDIA_PLAYER_TYPE_URL),
       is_remote_(false),
       media_log_(params.media_log()),
-      cdm_context_(nullptr),
       allow_stored_credentials_(false),
       is_local_resource_(false),
       interpolator_(&default_tick_clock_),
       frame_id_(frame_id),
       enable_texture_copy_(enable_texture_copy),
       suppress_deleting_texture_(false),
       playback_completed_(false),
       volume_(1.0),
       volume_multiplier_(1.0),
       weak_factory_(this) {
   DCHECK(player_manager_);
 
   DCHECK(main_thread_checker_.CalledOnValidThread());
 
   if (delegate_)
     delegate_id_ = delegate_->AddObserver(this);
 
   player_id_ = player_manager_->RegisterMediaPlayer(this);
 
   TryCreateStreamTextureProxyIfNeeded();
   interpolator_.SetUpperBound(base::TimeDelta());
-
-  if (params.initial_cdm()) {
-    cdm_context_ = media::ToWebContentDecryptionModuleImpl(params.initial_cdm())
-                       ->GetCdmContext();
-  }
 }
 
 WebMediaPlayerAndroid::~WebMediaPlayerAndroid() {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   SetVideoFrameProviderClient(NULL);
   client_->setWebLayer(NULL);
 
   if (is_player_initialized_)
     player_manager_->DestroyPlayer(player_id_);
 
@@ skipping 11 matching lines @@
 
   {
     base::AutoLock auto_lock(current_frame_lock_);
     current_frame_ = NULL;
   }
 
   if (delegate_) {
     delegate_->PlayerGone(delegate_id_);
     delegate_->RemoveObserver(delegate_id_);
   }
-
-  if (media_source_delegate_) {
-    // Part of |media_source_delegate_| needs to be stopped on the media thread.
-    // Wait until |media_source_delegate_| is fully stopped before tearing
-    // down other objects.
-    base::WaitableEvent waiter(base::WaitableEvent::ResetPolicy::AUTOMATIC,
-                               base::WaitableEvent::InitialState::NOT_SIGNALED);
-    media_source_delegate_->Stop(
-        base::Bind(&base::WaitableEvent::Signal, base::Unretained(&waiter)));
-    waiter.Wait();
-  }
 }
 
 void WebMediaPlayerAndroid::load(LoadType load_type,
                                  const blink::WebMediaPlayerSource& source,
                                  CORSMode cors_mode) {
   // Only URL or MSE blob URL is supported.
   DCHECK(source.isURL());
   blink::WebURL url = source.getAsURL();
   if (!defer_load_cb_.is_null()) {
     defer_load_cb_.Run(base::Bind(&WebMediaPlayerAndroid::DoLoad,
                                   weak_factory_.GetWeakPtr(), load_type, url,
                                   cors_mode));
     return;
   }
   DoLoad(load_type, url, cors_mode);
 }
 
 void WebMediaPlayerAndroid::DoLoad(LoadType load_type,
                                    const blink::WebURL& url,
                                    CORSMode cors_mode) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
 
   media::ReportMetrics(load_type, GURL(url), frame_->getSecurityOrigin());
-
-  switch (load_type) {
-    case LoadTypeURL:
-      player_type_ = MEDIA_PLAYER_TYPE_URL;
-      break;
-
-    case LoadTypeMediaSource:
-      player_type_ = MEDIA_PLAYER_TYPE_MEDIA_SOURCE;
-      break;
-
-    case LoadTypeMediaStream:
-      CHECK(false) << "WebMediaPlayerAndroid doesn't support MediaStream on "
-                      "this platform";
-      return;
-  }
+  DCHECK_EQ(load_type, LoadTypeURL)
+      << "WebMediaPlayerAndroid doesn't support MediaStream or "
+         "MediaSource on this platform";
 
   url_ = url;
   is_local_resource_ = IsLocalResource();
-  int demuxer_client_id = 0;
-  if (player_type_ != MEDIA_PLAYER_TYPE_URL) {
-    RendererDemuxerAndroid* demuxer =
-        RenderThreadImpl::current()->renderer_demuxer();
-    demuxer_client_id = demuxer->GetNextDemuxerClientID();
-
-    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::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);
-    }
-  } else {
-    info_loader_.reset(
-        new MediaInfoLoader(
-            url,
-            cors_mode,
-            base::Bind(&WebMediaPlayerAndroid::DidLoadMediaInfo,
-                       weak_factory_.GetWeakPtr())));
-    info_loader_->Start(frame_);
-  }
+  info_loader_.reset(new MediaInfoLoader(
+      url, cors_mode, base::Bind(&WebMediaPlayerAndroid::DidLoadMediaInfo,
+                                 weak_factory_.GetWeakPtr())));
+  info_loader_->Start(frame_);
 
   UpdateNetworkState(WebMediaPlayer::NetworkStateLoading);
   UpdateReadyState(WebMediaPlayer::ReadyStateHaveNothing);
 }
 
 void WebMediaPlayerAndroid::DidLoadMediaInfo(
     MediaInfoLoader::Status status,
     const GURL& redirected_url,
     const GURL& first_party_for_cookies,
     bool allow_stored_credentials) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
-  DCHECK(!media_source_delegate_);
   if (status == MediaInfoLoader::kFailed) {
     info_loader_.reset();
     UpdateNetworkState(WebMediaPlayer::NetworkStateNetworkError);
     return;
   }
   redirected_url_ = redirected_url;
-  InitializePlayer(
-      redirected_url, first_party_for_cookies, allow_stored_credentials, 0);
+  InitializePlayer(redirected_url, first_party_for_cookies,
+                   allow_stored_credentials);
 
   UpdateNetworkState(WebMediaPlayer::NetworkStateIdle);
 }
 
 bool WebMediaPlayerAndroid::IsLocalResource() {
   if (url_.SchemeIsFile() || url_.SchemeIsBlob())
     return true;
 
   std::string host = url_.host();
   if (!host.compare("localhost") || !host.compare("127.0.0.1") ||
@@ skipping 53 matching lines @@
 
 void WebMediaPlayerAndroid::seek(double seconds) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   DVLOG(1) << __FUNCTION__ << "(" << seconds << ")";
 
   playback_completed_ = false;
   base::TimeDelta new_seek_time = base::TimeDelta::FromSecondsD(seconds);
 
   if (seeking_) {
     if (new_seek_time == seek_time_) {
-      if (media_source_delegate_) {
-        // Don't suppress any redundant in-progress MSE seek. There could have
-        // been changes to the underlying buffers after seeking the demuxer and
-        // before receiving OnSeekComplete() for the currently in-progress seek.
-        MEDIA_LOG(DEBUG, media_log_)
-            << "Detected MediaSource seek to same time as in-progress seek to "
-            << seek_time_ << ".";
-      } else {
-        // Suppress all redundant seeks if unrestricted by media source
-        // demuxer API.
-        pending_seek_ = false;
-        return;
-      }
+      pending_seek_ = false;
+      return;
     }
 
     pending_seek_ = true;
     pending_seek_time_ = new_seek_time;
 
-    if (media_source_delegate_)
-      media_source_delegate_->CancelPendingSeek(pending_seek_time_);
-
     // Later, OnSeekComplete will trigger the pending seek.
     return;
   }
 
   seeking_ = true;
   seek_time_ = new_seek_time;
 
-  if (media_source_delegate_)
-    media_source_delegate_->StartWaitingForSeek(seek_time_);
-
   // Kick off the asynchronous seek!
   player_manager_->Seek(player_id_, seek_time_);
 }
 
 bool WebMediaPlayerAndroid::supportsSave() const {
   return false;
 }
 
 void WebMediaPlayerAndroid::setRate(double rate) {}
 
@@ skipping 67 matching lines @@
   DCHECK(main_thread_checker_.CalledOnValidThread());
   if (duration_ == media::kInfiniteDuration)
     return std::numeric_limits<double>::infinity();
 
   return duration_.InSecondsF();
 }
 
 double WebMediaPlayerAndroid::timelineOffset() const {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   base::Time timeline_offset;
-  if (media_source_delegate_)
-    timeline_offset = media_source_delegate_->GetTimelineOffset();
-
   if (timeline_offset.is_null())
     return std::numeric_limits<double>::quiet_NaN();
 
   return timeline_offset.ToJsTime();
 }
 
 double WebMediaPlayerAndroid::currentTime() const {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   // If the player is processing a seek, return the seek time.
   // Blink may still query us if updatePlaybackState() occurs while seeking.
@@ skipping 17 matching lines @@
 
 WebMediaPlayer::ReadyState WebMediaPlayerAndroid::getReadyState() const {
   return ready_state_;
 }
 
 blink::WebString WebMediaPlayerAndroid::getErrorMessage() {
   return blink::WebString::fromUTF8(media_log_->GetLastErrorMessage());
 }
 
 blink::WebTimeRanges WebMediaPlayerAndroid::buffered() const {
-  if (media_source_delegate_)
-    return media_source_delegate_->Buffered();
   return buffered_;
 }
 
 blink::WebTimeRanges WebMediaPlayerAndroid::seekable() const {
   if (ready_state_ < WebMediaPlayer::ReadyStateHaveMetadata)
     return blink::WebTimeRanges();
 
   // TODO(dalecurtis): Technically this allows seeking on media which return an
   // infinite duration.  While not expected, disabling this breaks semi-live
   // players, http://crbug.com/427412.
@@ skipping 152 matching lines @@
   if (info_loader_)
     return info_loader_->DidPassCORSAccessCheck();
   return false;
 }
 
 double WebMediaPlayerAndroid::mediaTimeForTimeValue(double timeValue) const {
   return base::TimeDelta::FromSecondsD(timeValue).InSecondsF();
 }
 
 unsigned WebMediaPlayerAndroid::decodedFrameCount() const {
-  if (media_source_delegate_)
-    return media_source_delegate_->DecodedFrameCount();
   NOTIMPLEMENTED();
   return 0;
 }
 
 unsigned WebMediaPlayerAndroid::droppedFrameCount() const {
-  if (media_source_delegate_)
-    return media_source_delegate_->DroppedFrameCount();
   NOTIMPLEMENTED();
   return 0;
 }
 
 size_t WebMediaPlayerAndroid::audioDecodedByteCount() const {
-  if (media_source_delegate_)
-    return media_source_delegate_->AudioDecodedByteCount();
   NOTIMPLEMENTED();
   return 0;
 }
 
 size_t WebMediaPlayerAndroid::videoDecodedByteCount() const {
-  if (media_source_delegate_)
-    return media_source_delegate_->VideoDecodedByteCount();
   NOTIMPLEMENTED();
   return 0;
 }
 
 void WebMediaPlayerAndroid::OnMediaMetadataChanged(
     base::TimeDelta duration, int width, int height, bool success) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   bool need_to_signal_duration_changed = false;
 
   if (is_local_resource_)
     UpdateNetworkState(WebMediaPlayer::NetworkStateLoaded);
 
   // For HLS streams, the reported duration may be zero for infinite streams.
   // See http://crbug.com/501213.
   if (duration.is_zero() && IsHLSStream())
     duration = media::kInfiniteDuration;
 
   // Update duration, if necessary, prior to ready state updates that may
   // cause duration() query.
   if (!ignore_metadata_duration_change_ && duration_ != duration) {
     duration_ = duration;
     if (is_local_resource_)
       buffered_[0].end = duration_.InSecondsF();
     // Client readyState transition from HAVE_NOTHING to HAVE_METADATA
     // already triggers a durationchanged event. If this is a different
     // transition, remember to signal durationchanged.
-    // Do not ever signal durationchanged on metadata change in MSE case
-    // because OnDurationChanged() handles this.
-    if (ready_state_ > WebMediaPlayer::ReadyStateHaveNothing &&
-        player_type_ != MEDIA_PLAYER_TYPE_MEDIA_SOURCE) {
+    if (ready_state_ > WebMediaPlayer::ReadyStateHaveNothing)
       need_to_signal_duration_changed = true;
-    }
   }
 
   if (ready_state_ != WebMediaPlayer::ReadyStateHaveEnoughData) {
     UpdateReadyState(WebMediaPlayer::ReadyStateHaveMetadata);
     UpdateReadyState(WebMediaPlayer::ReadyStateHaveEnoughData);
   }
 
   // TODO(wolenetz): Should we just abort early and set network state to an
   // error if success == false? See http://crbug.com/248399
   if (success)
@@ skipping 199 matching lines @@
 void WebMediaPlayerAndroid::OnMediaPlayerPause() {
   UpdatePlayingState(false);
   client_->playbackStateChanged();
 }
 
 void WebMediaPlayerAndroid::OnRemoteRouteAvailabilityChanged(
     bool routes_available) {
   client_->remoteRouteAvailabilityChanged(routes_available);
 }
 
-void WebMediaPlayerAndroid::OnDurationChanged(const base::TimeDelta& duration) {
-  DCHECK(main_thread_checker_.CalledOnValidThread());
-  // Only MSE |player_type_| registers this callback.
-  DCHECK_EQ(player_type_, MEDIA_PLAYER_TYPE_MEDIA_SOURCE);
-
-  // Cache the new duration value and trust it over any subsequent duration
-  // values received in OnMediaMetadataChanged().
-  duration_ = duration;
-  ignore_metadata_duration_change_ = true;
-
-  // Notify MediaPlayerClient that duration has changed, if > HAVE_NOTHING.
-  if (ready_state_ > WebMediaPlayer::ReadyStateHaveNothing)
-    client_->durationChanged();
-}
-
 void WebMediaPlayerAndroid::UpdateNetworkState(
     WebMediaPlayer::NetworkState state) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   if (ready_state_ == WebMediaPlayer::ReadyStateHaveNothing &&
       (state == WebMediaPlayer::NetworkStateNetworkError ||
        state == WebMediaPlayer::NetworkStateDecodeError)) {
     // Any error that occurs before reaching ReadyStateHaveMetadata should
     // be considered a format error.
     network_state_ = WebMediaPlayer::NetworkStateFormatError;
   } else {
@@ skipping 39 matching lines @@
     case WebMediaPlayer::NetworkStateDecodeError:
       break;
   }
   player_manager_->SuspendAndReleaseResources(player_id_);
   SetNeedsEstablishPeer(true);
 }
 
 void WebMediaPlayerAndroid::InitializePlayer(
     const GURL& url,
     const GURL& first_party_for_cookies,
-    bool allow_stored_credentials,
-    int demuxer_client_id) {
+    bool allow_stored_credentials) {
   ReportHLSMetrics();
 
   allow_stored_credentials_ = allow_stored_credentials;
-  player_manager_->Initialize(
-      player_type_, player_id_, url, first_party_for_cookies, demuxer_client_id,
-      frame_->document().url(), allow_stored_credentials, delegate_id_);
+  player_manager_->Initialize(player_type_, player_id_, url,
+                              first_party_for_cookies, frame_->document().url(),
+                              allow_stored_credentials, delegate_id_);
   is_player_initialized_ = true;
 
   if (is_fullscreen_)
     player_manager_->EnterFullscreen(player_id_);
-
-  if (cdm_context_)
-    SetCdmInternal(base::Bind(&media::IgnoreCdmAttached));
 }
 
 void WebMediaPlayerAndroid::Pause(bool is_media_related_action) {
   player_manager_->Pause(player_id_, is_media_related_action);
   UpdatePlayingState(false);
 }
 
 void WebMediaPlayerAndroid::DrawRemotePlaybackText(
     const std::string& remote_playback_message) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
@@ skipping 229 matching lines @@
                           playback_completed_ || currentTime() >= duration());
     }
   }
 }
 
 void WebMediaPlayerAndroid::setContentDecryptionModule(
     blink::WebContentDecryptionModule* cdm,
     blink::WebContentDecryptionModuleResult result) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
 
-  // Once the CDM is set it can't be cleared as there may be frames being
-  // decrypted on other threads. So fail this request.
-  // http://crbug.com/462365#c7.
-  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(
-        base::Bind(&WebMediaPlayerAndroid::ContentDecryptionModuleAttached,
-                   weak_factory_.GetWeakPtr(), result));
-  } else {
-    // No pipeline/decoder connected, so resolve the promise. When something
-    // 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;
-  }
-
   result.completeWithError(
-      blink::WebContentDecryptionModuleExceptionNotSupportedError,
-      0,
-      "Unable to set MediaKeys object");
-}
-
-void WebMediaPlayerAndroid::OnMediaSourceOpened(
-    blink::WebMediaSource* web_media_source) {
-  client_->mediaSourceOpened(web_media_source);
-}
-
-void WebMediaPlayerAndroid::OnEncryptedMediaInitData(
-    media::EmeInitDataType init_data_type,
-    const std::vector<uint8_t>& init_data) {
-  DCHECK(main_thread_checker_.CalledOnValidThread());
-
-  // TODO(xhwang): Update this UMA name. https://crbug.com/589251
-  UMA_HISTOGRAM_COUNTS("Media.EME.NeedKey", 1);
-
-  DCHECK(init_data_type != media::EmeInitDataType::UNKNOWN);
-
-  encrypted_client_->encrypted(ConvertToWebInitDataType(init_data_type),
-                               init_data.data(), init_data.size());
-}
-
-void WebMediaPlayerAndroid::OnWaitingForDecryptionKey() {
-  encrypted_client_->didBlockPlaybackWaitingForKey();
-
-  // TODO(jrummell): didResumePlaybackBlockedForKey() should only be called
-  // when a key has been successfully added (e.g. OnSessionKeysChange() with
-  // |has_additional_usable_key| = true). http://crbug.com/461903
-  encrypted_client_->didResumePlaybackBlockedForKey();
+      blink::WebContentDecryptionModuleExceptionInvalidStateError, 0,

[wolenetz, 2016/09/30 23:23:24]

nit: blink::WebContentDecryptionModuleExceptionNotSupportedError ? I'm not sure
-- jrummell@ / ddorwin@ / xhwang@ will know better, but completeWithError has
promise resolution condition attached only to the NotSupportedError IIUC. Also,
the default impl of this method in the base class is: 
result.completeWithError(WebContentDecryptionModuleExceptionNotSupportedError,
0, "ERROR");

[DaleCurtis, 2016/09/30 23:34:24]

Deleted.

+      "EME is not supported for this playback.");
 }
 
 void WebMediaPlayerAndroid::OnHidden() {
   // Pause audible video preserving its session.
   if (hasVideo() && IsBackgroundVideoCandidate() && !paused()) {
     Pause(false);
     is_play_pending_ = true;
     return;
   }
 
@@ skipping 28 matching lines @@
 void WebMediaPlayerAndroid::OnPause() {
   pause();
   client_->playbackStateChanged();
 }
 
 void WebMediaPlayerAndroid::OnVolumeMultiplierUpdate(double multiplier) {
   volume_multiplier_ = multiplier;
   setVolume(volume_);
 }
 
-void WebMediaPlayerAndroid::OnCdmContextReady(media::CdmContext* cdm_context) {
-  DCHECK(!cdm_context_);
-
-  if (!cdm_context) {
-    LOG(ERROR) << "CdmContext not available (e.g. CDM creation failed).";
-    return;
-  }
-
-  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.";
-
-  if (cdm_ready_cb_.is_null()) {
-    cdm_attached_cb.Run(true);
-    return;
-  }
-
-  // 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)));
-}
-
-void WebMediaPlayerAndroid::OnCdmAttached(
-    const media::CdmAttachedCB& cdm_attached_cb,
-    bool success) {
-  DVLOG(1) << __FUNCTION__ << ": success: " << 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 MediaSourceDelegate::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;
-  }
-
-  // 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 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_)
-    SetCdmInternal(base::Bind(&media::IgnoreCdmAttached));
-}
-
 bool WebMediaPlayerAndroid::supportsOverlayFullscreenVideo() {
   return true;
 }
 
 void WebMediaPlayerAndroid::enteredFullscreen() {
   if (is_player_initialized_)
     player_manager_->EnterFullscreen(player_id_);
   SetNeedsEstablishPeer(false);
   is_fullscreen_ = true;
   suppress_deleting_texture_ = false;
@@ skipping 47 matching lines @@
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableMediaSuspend)) {
     return false;
   }
 
   return base::FeatureList::IsEnabled(media::kResumeBackgroundVideo) &&
       hasAudio() && !isRemote() && delegate_ && delegate_->IsHidden();
 }
 
 }  // namespace content