Delete MediaCodecPlayer, it's time!

media/base/android/media_codec_player.cc

Index: media/base/android/media_codec_player.cc
diff --git a/media/base/android/media_codec_player.cc b/media/base/android/media_codec_player.cc
deleted file mode 100644
index 0e318d888cbf9f1448332d9a1b97f30e8283a81b..0000000000000000000000000000000000000000
--- a/media/base/android/media_codec_player.cc
+++ /dev/null
@@ -1,1422 +0,0 @@
-// Copyright 2015 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/base/android/media_codec_player.h"
-
-#include <utility>
-
-#include "base/barrier_closure.h"
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/lazy_instance.h"
-#include "base/logging.h"
-#include "base/threading/thread.h"
-#include "base/threading/thread_task_runner_handle.h"
-#include "media/base/android/audio_media_codec_decoder.h"
-#include "media/base/android/media_drm_bridge.h"
-#include "media/base/android/media_player_manager.h"
-#include "media/base/android/media_task_runner.h"
-#include "media/base/android/video_media_codec_decoder.h"
-#include "media/base/bind_to_current_loop.h"
-#include "media/base/timestamp_constants.h"
-
-#define RUN_ON_MEDIA_THREAD(METHOD, ...)                                     \
-  do {                                                                       \
-    if (!GetMediaTaskRunner()->BelongsToCurrentThread()) {                   \
-      DCHECK(ui_task_runner_->BelongsToCurrentThread());                     \
-      GetMediaTaskRunner()->PostTask(                                        \
-          FROM_HERE, base::Bind(&MediaCodecPlayer::METHOD, media_weak_this_, \
-                                ##__VA_ARGS__));                             \
-      return;                                                                \
-    }                                                                        \
-  } while (0)
-
-namespace media {
-
-// MediaCodecPlayer implementation.
-
-MediaCodecPlayer::MediaCodecPlayer(
-    int player_id,
-    base::WeakPtr<MediaPlayerManager> manager,
-    const OnDecoderResourcesReleasedCB& on_decoder_resources_released_cb,
-    std::unique_ptr<DemuxerAndroid> demuxer,
-    const GURL& frame_url,
-    int media_session_id)
-    : MediaPlayerAndroid(player_id,
-                         manager.get(),
-                         on_decoder_resources_released_cb,
-                         frame_url,
-                         media_session_id),
-      ui_task_runner_(base::ThreadTaskRunnerHandle::Get()),
-      demuxer_(std::move(demuxer)),
-      state_(kStatePaused),
-      interpolator_(&default_tick_clock_),
-      pending_start_(false),
-      pending_seek_(kNoTimestamp),
-      cdm_registration_id_(0),
-      key_is_required_(false),
-      key_is_added_(false),
-      media_weak_factory_(this) {
-  DCHECK(ui_task_runner_->BelongsToCurrentThread());
-
-  DVLOG(1) << "MediaCodecPlayer::MediaCodecPlayer: player_id:" << player_id;
-
-  completion_cb_ =
-      base::Bind(&MediaPlayerManager::OnPlaybackComplete, manager, player_id);
-  waiting_for_decryption_key_cb_ = base::Bind(
-      &MediaPlayerManager::OnWaitingForDecryptionKey, manager, player_id);
-  seek_done_cb_ =
-      base::Bind(&MediaPlayerManager::OnSeekComplete, manager, player_id);
-  error_cb_ = base::Bind(&MediaPlayerManager::OnError, manager, player_id);
-
-  attach_listener_cb_ = base::Bind(&MediaPlayerAndroid::AttachListener,
-                                   WeakPtrForUIThread(), nullptr);
-  detach_listener_cb_ =
-      base::Bind(&MediaPlayerAndroid::DetachListener, WeakPtrForUIThread());
-  metadata_changed_cb_ = base::Bind(&MediaPlayerAndroid::OnMediaMetadataChanged,
-                                    WeakPtrForUIThread());
-  time_update_cb_ =
-      base::Bind(&MediaPlayerAndroid::OnTimeUpdate, WeakPtrForUIThread());
-
-  media_weak_this_ = media_weak_factory_.GetWeakPtr();
-
-  // Finish initializaton on Media thread
-  GetMediaTaskRunner()->PostTask(
-      FROM_HERE, base::Bind(&MediaCodecPlayer::Initialize, media_weak_this_));
-}
-
-MediaCodecPlayer::~MediaCodecPlayer()
-{
-  DVLOG(1) << "MediaCodecPlayer::~MediaCodecPlayer";
-  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
-
-  media_stat_->StopAndReport(GetInterpolatedTime());
-
-  // Currently the unit tests wait for the MediaCodecPlayer destruction by
-  // watching the demuxer, which is destroyed as one of the member variables.
-  // Release the codecs here, before any member variable is destroyed to make
-  // the unit tests happy.
-
-  if (video_decoder_)
-    video_decoder_->ReleaseDecoderResources();
-  if (audio_decoder_)
-    audio_decoder_->ReleaseDecoderResources();
-
-  if (cdm_) {
-    // Cancel previously registered callback (if any).
-    static_cast<MediaDrmBridge*>(cdm_.get())
-        ->SetMediaCryptoReadyCB(MediaDrmBridge::MediaCryptoReadyCB());
-
-    DCHECK(cdm_registration_id_);
-    static_cast<MediaDrmBridge*>(cdm_.get())
-        ->UnregisterPlayer(cdm_registration_id_);
-  }
-}
-
-void MediaCodecPlayer::Initialize() {
-  DVLOG(1) << __FUNCTION__;
-  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
-
-  interpolator_.SetUpperBound(base::TimeDelta());
-
-  CreateDecoders();
-
-  // This call might in turn call MediaCodecPlayer::OnDemuxerConfigsAvailable()
-  // which propagates configs into decoders. Therefore CreateDecoders() should
-  // be called first.
-  demuxer_->Initialize(this);
-}
-
-// The implementation of MediaPlayerAndroid interface.
-
-void MediaCodecPlayer::DeleteOnCorrectThread() {
-  DVLOG(1) << __FUNCTION__;
-  DCHECK(ui_task_runner_->BelongsToCurrentThread());
-
-  DetachListener();
-
-  // The base class part that deals with MediaPlayerListener
-  // has to be destroyed on UI thread.
-  DestroyListenerOnUIThread();
-
-  // Post deletion onto Media thread
-  GetMediaTaskRunner()->DeleteSoon(FROM_HERE, this);
-}
-
-void MediaCodecPlayer::SetVideoSurface(gl::ScopedJavaSurface surface) {
-  RUN_ON_MEDIA_THREAD(SetVideoSurface, base::Passed(&surface));
-
-  DVLOG(1) << __FUNCTION__ << (surface.IsEmpty() ? " empty" : " non-empty");
-
-  // Save the empty-ness before we pass the surface to the decoder.
-  bool surface_is_empty = surface.IsEmpty();
-
-  // Apparently RemoveVideoSurface() can be called several times in a row,
-  // ignore the second and subsequent calls.
-  if (surface_is_empty && !video_decoder_->HasVideoSurface()) {
-    DVLOG(1) << __FUNCTION__ << ": surface already removed, ignoring";
-    return;
-  }
-
-  // Do not set unprotected surface if we know that we need a protected one.
-  // Empty surface means the surface removal and we always allow for it.
-  if (!surface_is_empty && video_decoder_->IsProtectedSurfaceRequired() &&
-      !surface.is_protected()) {
-    DVLOG(0) << __FUNCTION__ << ": surface is not protected, ignoring";
-    return;
-  }
-
-  video_decoder_->SetVideoSurface(std::move(surface));
-
-  if (surface_is_empty) {
-    // Remove video surface.
-    switch (state_) {
-      case kStatePlaying:
-        if (VideoFinished())
-          break;
-
-        DVLOG(1) << __FUNCTION__ << ": stopping and restarting";
-        // Stop decoders as quickly as possible.
-        StopDecoders();  // synchronous stop
-
-        // Prefetch or wait for initial configuration.
-        if (HasAudio() || HasVideo()) {
-          SetState(kStatePrefetching);
-          StartPrefetchDecoders();
-        } else {
-          SetState(kStateWaitingForConfig);
-        }
-        break;
-
-      default:
-        break;  // ignore
-    }
-  } else {
-    // Replace video surface.
-    switch (state_) {
-      case kStateWaitingForSurface:
-        SetState(kStatePlaying);
-        StartPlaybackOrBrowserSeek();
-        break;
-
-      case kStatePlaying:
-        if (VideoFinished())
-          break;
-
-        DVLOG(1) << __FUNCTION__ << ": requesting to stop and restart";
-        SetState(kStateStopping);
-        RequestToStopDecoders();
-        SetPendingStart(true);
-        break;
-
-      default:
-        break;  // ignore
-    }
-  }
-}
-
-void MediaCodecPlayer::Start() {
-  RUN_ON_MEDIA_THREAD(Start);
-
-  DVLOG(1) << __FUNCTION__;
-
-  switch (state_) {
-    case kStatePaused:
-      // Request play permission or wait for initial configuration.
-      if (HasAudio() || HasVideo()) {
-        SetState(kStateWaitingForPermission);
-        RequestPlayPermission();
-      } else {
-        SetState(kStateWaitingForConfig);
-      }
-      break;
-    case kStateStopping:
-    case kStateWaitingForSeek:
-      SetPendingStart(true);
-      break;
-    case kStateWaitingForConfig:
-    case kStateWaitingForPermission:
-    case kStatePrefetching:
-    case kStatePlaying:
-    case kStateWaitingForSurface:
-    case kStateWaitingForKey:
-    case kStateWaitingForMediaCrypto:
-    case kStateError:
-      break;  // Ignore
-    default:
-      NOTREACHED();
-      break;
-  }
-}
-
-void MediaCodecPlayer::Pause(bool is_media_related_action) {
-  RUN_ON_MEDIA_THREAD(Pause, is_media_related_action);
-
-  DVLOG(1) << __FUNCTION__;
-
-  media_stat_->StopAndReport(GetInterpolatedTime());
-
-  SetPendingStart(false);
-
-  switch (state_) {
-    case kStateWaitingForConfig:
-    case kStateWaitingForPermission:
-    case kStatePrefetching:
-    case kStateWaitingForSurface:
-    case kStateWaitingForKey:
-    case kStateWaitingForMediaCrypto:
-      SetState(kStatePaused);
-      StopDecoders();
-      break;
-    case kStatePlaying:
-      SetState(kStateStopping);
-      RequestToStopDecoders();
-      break;
-    case kStatePaused:
-    case kStateStopping:
-    case kStateWaitingForSeek:
-    case kStateError:
-      break;  // Ignore
-    default:
-      NOTREACHED();
-      break;
-  }
-}
-
-void MediaCodecPlayer::SeekTo(base::TimeDelta timestamp) {
-  RUN_ON_MEDIA_THREAD(SeekTo, timestamp);
-
-  DVLOG(1) << __FUNCTION__ << " " << timestamp;
-
-  media_stat_->StopAndReport(GetInterpolatedTime());
-
-  switch (state_) {
-    case kStatePaused:
-      SetState(kStateWaitingForSeek);
-      RequestDemuxerSeek(timestamp);
-      break;
-    case kStateWaitingForConfig:
-    case kStateWaitingForPermission:
-    case kStatePrefetching:
-    case kStateWaitingForSurface:
-    case kStateWaitingForKey:
-    case kStateWaitingForMediaCrypto:
-      SetState(kStateWaitingForSeek);
-      StopDecoders();
-      SetPendingStart(true);
-      RequestDemuxerSeek(timestamp);
-      break;
-    case kStatePlaying:
-      SetState(kStateStopping);
-      RequestToStopDecoders();
-      SetPendingStart(true);
-      SetPendingSeek(timestamp);
-      break;
-    case kStateStopping:
-      SetPendingSeek(timestamp);
-      break;
-    case kStateWaitingForSeek:
-      SetPendingSeek(timestamp);
-      break;
-    case kStateError:
-      break;  // ignore
-    default:
-      NOTREACHED();
-      break;
-  }
-}
-
-void MediaCodecPlayer::Release() {
-  // TODO(qinmin): the callback should be posted onto the UI thread when
-  // Release() finishes on media thread. However, the BrowserMediaPlayerManager
-  // could be gone in that case, which cause the MediaThrottler unable to
-  // track the active players. We should pass
-  // MediaThrottler::OnDecodeRequestFinished() to this class in the ctor, but
-  // also need a way for BrowserMediaPlayerManager to track active players.
-  if (ui_task_runner_->BelongsToCurrentThread())
-    on_decoder_resources_released_cb_.Run(player_id());
-
-  RUN_ON_MEDIA_THREAD(Release);
-
-  DVLOG(1) << __FUNCTION__;
-
-  media_stat_->StopAndReport(GetInterpolatedTime());
-
-  // Stop decoding threads and delete MediaCodecs, but keep IPC between browser
-  // and renderer processes going. Seek should work across and after Release().
-
-  ReleaseDecoderResources();
-
-  SetPendingStart(false);
-
-  if (state_ != kStateWaitingForSeek)
-    SetState(kStatePaused);
-
-  // Crear encryption key related flags.
-  key_is_required_ = false;
-  key_is_added_ = false;
-
-  base::TimeDelta pending_seek_time = GetPendingSeek();
-  if (pending_seek_time != kNoTimestamp) {
-    SetPendingSeek(kNoTimestamp);
-    SetState(kStateWaitingForSeek);
-    RequestDemuxerSeek(pending_seek_time);
-  }
-}
-
-void MediaCodecPlayer::UpdateEffectiveVolumeInternal(double effective_volume) {
-  RUN_ON_MEDIA_THREAD(UpdateEffectiveVolumeInternal, effective_volume);
-
-  DVLOG(1) << __FUNCTION__ << " " << effective_volume;
-  audio_decoder_->SetVolume(effective_volume);
-}
-
-bool MediaCodecPlayer::HasAudio() const {
-  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
-  return audio_decoder_->HasStream();
-}
-
-bool MediaCodecPlayer::HasVideo() const {
-  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
-  return video_decoder_->HasStream();
-}
-
-int MediaCodecPlayer::GetVideoWidth() {
-  DCHECK(ui_task_runner_->BelongsToCurrentThread());
-  return metadata_cache_.video_size.width();
-}
-
-int MediaCodecPlayer::GetVideoHeight() {
-  DCHECK(ui_task_runner_->BelongsToCurrentThread());
-  return metadata_cache_.video_size.height();
-}
-
-base::TimeDelta MediaCodecPlayer::GetCurrentTime() {
-  DCHECK(ui_task_runner_->BelongsToCurrentThread());
-  return current_time_cache_;
-}
-
-base::TimeDelta MediaCodecPlayer::GetDuration() {
-  DCHECK(ui_task_runner_->BelongsToCurrentThread());
-  return metadata_cache_.duration;
-}
-
-bool MediaCodecPlayer::IsPlaying() {
-  DCHECK(ui_task_runner_->BelongsToCurrentThread());
-
-  // TODO(timav): Use another variable since |state_| should only be accessed on
-  // Media thread.
-  return state_ == kStatePlaying || state_ == kStateStopping;
-}
-
-bool MediaCodecPlayer::CanPause() {
-  DCHECK(ui_task_runner_->BelongsToCurrentThread());
-  NOTIMPLEMENTED();
-  return false;
-}
-
-bool MediaCodecPlayer::CanSeekForward() {
-  DCHECK(ui_task_runner_->BelongsToCurrentThread());
-  NOTIMPLEMENTED();
-  return false;
-}
-
-bool MediaCodecPlayer::CanSeekBackward() {
-  DCHECK(ui_task_runner_->BelongsToCurrentThread());
-  NOTIMPLEMENTED();
-  return false;
-}
-
-bool MediaCodecPlayer::IsPlayerReady() {
-  DCHECK(ui_task_runner_->BelongsToCurrentThread());
-  // This method is called to check whether it's safe to release the player when
-  // the OS needs more resources. This class can be released at any time.
-  return true;
-}
-
-void MediaCodecPlayer::SetCdm(const scoped_refptr<MediaKeys>& cdm) {
-  DCHECK(cdm);
-  RUN_ON_MEDIA_THREAD(SetCdm, cdm);
-
-  DVLOG(1) << __FUNCTION__;
-
-  // Currently we don't support DRM change during the middle of playback, even
-  // if the player is paused. There is no current plan to support it, see
-  // http://crbug.com/253792.
-  if (state_ != kStatePaused || GetInterpolatedTime() > base::TimeDelta()) {
-    VLOG(0) << "Setting DRM bridge after playback has started is not supported";
-    return;
-  }
-
-  if (cdm_) {
-    NOTREACHED() << "Currently we do not support resetting CDM.";
-    return;
-  }
-
-  cdm_ = cdm;
-
-  // Only MediaDrmBridge will be set on MediaCodecPlayer.
-  MediaDrmBridge* drm_bridge = static_cast<MediaDrmBridge*>(cdm_.get());
-
-  // Register CDM callbacks. The callbacks registered will be posted back to the
-  // media thread via BindToCurrentLoop.
-
-  // Since |this| holds a reference to the |cdm_|, by the time the CDM is
-  // destructed, UnregisterPlayer() must have been called and |this| has been
-  // destructed as well. So the |cdm_unset_cb| will never have a chance to be
-  // called.
-  // TODO(xhwang): Remove |cdm_unset_cb| after it's not used on all platforms.
-  cdm_registration_id_ = drm_bridge->RegisterPlayer(
-      BindToCurrentLoop(
-          base::Bind(&MediaCodecPlayer::OnKeyAdded, media_weak_this_)),
-      base::Bind(&base::DoNothing));
-
-  drm_bridge->SetMediaCryptoReadyCB(BindToCurrentLoop(
-      base::Bind(&MediaCodecPlayer::OnMediaCryptoReady, media_weak_this_)));
-}
-
-// Callbacks from Demuxer.
-
-void MediaCodecPlayer::OnDemuxerConfigsAvailable(
-    const DemuxerConfigs& configs) {
-  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
-
-  DVLOG(1) << __FUNCTION__;
-
-  duration_ = configs.duration;
-
-  SetDemuxerConfigs(configs);
-
-  // Update cache and notify manager on UI thread
-  gfx::Size video_size = HasVideo() ? configs.video_size : gfx::Size();
-  ui_task_runner_->PostTask(
-      FROM_HERE, base::Bind(metadata_changed_cb_, duration_, video_size));
-}
-
-void MediaCodecPlayer::OnDemuxerDataAvailable(const DemuxerData& data) {
-  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
-
-  DCHECK_LT(0u, data.access_units.size());
-  CHECK_GE(1u, data.demuxer_configs.size());
-
-  DVLOG(2) << "Player::" << __FUNCTION__;
-
-  if (data.type == DemuxerStream::AUDIO)
-    audio_decoder_->OnDemuxerDataAvailable(data);
-
-  if (data.type == DemuxerStream::VIDEO)
-    video_decoder_->OnDemuxerDataAvailable(data);
-}
-
-void MediaCodecPlayer::OnDemuxerSeekDone(
-    base::TimeDelta actual_browser_seek_time) {
-  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
-
-  DVLOG(1) << __FUNCTION__ << " actual_time:" << actual_browser_seek_time;
-
-  DCHECK(seek_info_.get());
-  DCHECK(seek_info_->seek_time != kNoTimestamp);
-
-  // A browser seek must not jump into the past. Ideally, it seeks to the
-  // requested time, but it might jump into the future.
-  DCHECK(!seek_info_->is_browser_seek ||
-         seek_info_->seek_time <= actual_browser_seek_time);
-
-  // Restrict the current time to be equal to seek_time
-  // for the next StartPlaybackDecoders() call.
-
-  base::TimeDelta seek_time = seek_info_->is_browser_seek
-                                  ? actual_browser_seek_time
-                                  : seek_info_->seek_time;
-
-  interpolator_.SetBounds(seek_time, seek_time);
-
-  audio_decoder_->SetBaseTimestamp(seek_time);
-
-  audio_decoder_->SetPrerollTimestamp(seek_time);
-  video_decoder_->SetPrerollTimestamp(seek_time);
-
-  // The Flush() might set the state to kStateError.
-  if (state_ == kStateError) {
-    // Notify the Renderer.
-    if (!seek_info_->is_browser_seek)
-      ui_task_runner_->PostTask(FROM_HERE,
-                                base::Bind(seek_done_cb_, seek_time));
-
-    seek_info_.reset();
-    return;
-  }
-
-  DCHECK_EQ(kStateWaitingForSeek, state_);
-
-  base::TimeDelta pending_seek_time = GetPendingSeek();
-  if (pending_seek_time != kNoTimestamp) {
-    // Keep kStateWaitingForSeek
-    SetPendingSeek(kNoTimestamp);
-    RequestDemuxerSeek(pending_seek_time);
-    return;
-  }
-
-  if (HasPendingStart()) {
-    SetPendingStart(false);
-    // Request play permission or wait for initial configuration.
-    if (HasAudio() || HasVideo()) {
-      SetState(kStateWaitingForPermission);
-      RequestPlayPermission();
-    } else {
-      SetState(kStateWaitingForConfig);
-    }
-  } else {
-    SetState(kStatePaused);
-  }
-
-  // Notify the Renderer.
-  if (!seek_info_->is_browser_seek)
-    ui_task_runner_->PostTask(FROM_HERE, base::Bind(seek_done_cb_, seek_time));
-
-  seek_info_.reset();
-}
-
-void MediaCodecPlayer::OnDemuxerDurationChanged(
-    base::TimeDelta duration) {
-  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
-  DVLOG(1) << __FUNCTION__ << " duration:" << duration;
-
-  duration_ = duration;
-}
-
-void MediaCodecPlayer::SetDecodersTimeCallbackForTests(
-    DecodersTimeCallback cb) {
-  DCHECK(ui_task_runner_->BelongsToCurrentThread());
-  decoders_time_cb_ = cb;
-}
-
-void MediaCodecPlayer::SetCodecCreatedCallbackForTests(
-    CodecCreatedCallback cb) {
-  DCHECK(ui_task_runner_->BelongsToCurrentThread());
-  DCHECK(audio_decoder_ && video_decoder_);
-
-  audio_decoder_->SetCodecCreatedCallbackForTests(
-      base::Bind(cb, DemuxerStream::AUDIO));
-  video_decoder_->SetCodecCreatedCallbackForTests(
-      base::Bind(cb, DemuxerStream::VIDEO));
-}
-
-void MediaCodecPlayer::SetAlwaysReconfigureForTests(DemuxerStream::Type type) {
-  DCHECK(ui_task_runner_->BelongsToCurrentThread());
-  DCHECK(audio_decoder_ && video_decoder_);
-
-  if (type == DemuxerStream::AUDIO)
-    audio_decoder_->SetAlwaysReconfigureForTests();
-  else if (type == DemuxerStream::VIDEO)
-    video_decoder_->SetAlwaysReconfigureForTests();
-}
-
-bool MediaCodecPlayer::IsPrerollingForTests(DemuxerStream::Type type) const {
-  DCHECK(ui_task_runner_->BelongsToCurrentThread());
-  DCHECK(audio_decoder_ && video_decoder_);
-
-  if (type == DemuxerStream::AUDIO)
-    return audio_decoder_->IsPrerollingForTests();
-  else if (type == DemuxerStream::VIDEO)
-    return video_decoder_->IsPrerollingForTests();
-  else
-    return false;
-}
-
-// Events from Player, called on UI thread
-
-void MediaCodecPlayer::RequestPermissionAndPostResult(base::TimeDelta duration,
-                                                      bool has_audio) {
-  DCHECK(ui_task_runner_->BelongsToCurrentThread());
-  DVLOG(1) << __FUNCTION__ << " duration:" << duration;
-
-  bool granted = manager()->RequestPlay(player_id(), duration, has_audio);
-  GetMediaTaskRunner()->PostTask(
-      FROM_HERE, base::Bind(&MediaCodecPlayer::OnPermissionDecided,
-                            media_weak_this_, granted));
-}
-
-void MediaCodecPlayer::OnMediaMetadataChanged(base::TimeDelta duration,
-                                              const gfx::Size& video_size) {
-  DCHECK(ui_task_runner_->BelongsToCurrentThread());
-
-  if (duration != kNoTimestamp)
-    metadata_cache_.duration = duration;
-
-  if (!video_size.IsEmpty())
-    metadata_cache_.video_size = video_size;
-
-  manager()->OnMediaMetadataChanged(player_id(), metadata_cache_.duration,
-                                    metadata_cache_.video_size.width(),
-                                    metadata_cache_.video_size.height(), true);
-}
-
-void MediaCodecPlayer::OnTimeUpdate(base::TimeDelta current_timestamp,
-                                    base::TimeTicks current_time_ticks) {
-  DCHECK(ui_task_runner_->BelongsToCurrentThread());
-
-  current_time_cache_ = current_timestamp;
-  manager()->OnTimeUpdate(player_id(), current_timestamp, current_time_ticks);
-}
-
-// Event from manager, called on Media thread
-
-void MediaCodecPlayer::OnPermissionDecided(bool granted) {
-  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
-
-  DVLOG(1) << __FUNCTION__ << ": " << (granted ? "granted" : "denied");
-
-  switch (state_) {
-    case kStateWaitingForPermission:
-      if (granted) {
-        SetState(kStatePrefetching);
-        StartPrefetchDecoders();
-      } else {
-        SetState(kStatePaused);
-        StopDecoders();
-      }
-      break;
-
-    default:
-      break;  // ignore
-  }
-}
-
-// Events from Decoders, called on Media thread
-
-void MediaCodecPlayer::RequestDemuxerData(DemuxerStream::Type stream_type) {
-  DVLOG(2) << __FUNCTION__ << " streamType:" << stream_type;
-
-  // Use this method instead of directly binding with
-  // DemuxerAndroid::RequestDemuxerData() to avoid the race condition on
-  // deletion:
-  // 1. DeleteSoon is posted from UI to Media thread.
-  // 2. RequestDemuxerData callback is posted from Decoder to Media thread.
-  // 3. DeleteSoon arrives, we delete the player and detach from
-  //    BrowserDemuxerAndroid.
-  // 4. RequestDemuxerData is processed by the media thread queue. Since the
-  //    weak_ptr was invalidated in (3), this is a no-op. If we used
-  //    DemuxerAndroid::RequestDemuxerData() it would arrive and will try to
-  //    call the client, but the client (i.e. this player) would not exist.
-  demuxer_->RequestDemuxerData(stream_type);
-}
-
-void MediaCodecPlayer::OnPrefetchDone() {
-  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
-
-  if (state_ != kStatePrefetching) {
-    DVLOG(1) << __FUNCTION__ << " wrong state " << AsString(state_)
-             << " ignoring";
-    return;  // Ignore
-  }
-
-  DVLOG(1) << __FUNCTION__;
-
-  if (!HasAudio() && !HasVideo()) {
-    // No configuration at all after prefetching.
-    // This is an error, initial configuration is expected
-    // before the first data chunk.
-    DCHECK(!internal_error_cb_.is_null());
-    GetMediaTaskRunner()->PostTask(FROM_HERE, internal_error_cb_);
-    return;
-  }
-
-  if (HasVideo() && !video_decoder_->HasVideoSurface()) {
-    SetState(kStateWaitingForSurface);
-    return;
-  }
-
-  if (key_is_required_ && !key_is_added_) {
-    SetState(kStateWaitingForKey);
-    ui_task_runner_->PostTask(FROM_HERE, waiting_for_decryption_key_cb_);
-    return;
-  }
-
-  SetState(kStatePlaying);
-  StartPlaybackOrBrowserSeek();
-}
-
-void MediaCodecPlayer::OnPrerollDone() {
-  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
-
-  if (state_ != kStatePlaying) {
-    DVLOG(1) << __FUNCTION__ << ": in state " << AsString(state_)
-             << ", ignoring";
-    return;
-  }
-
-  DVLOG(1) << __FUNCTION__;
-
-  StartStatus status = StartDecoders();
-  if (status != kStartOk)
-    GetMediaTaskRunner()->PostTask(FROM_HERE, internal_error_cb_);
-}
-
-void MediaCodecPlayer::OnDecoderDrained(DemuxerStream::Type type) {
-  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
-  DVLOG(1) << __FUNCTION__ << " " << type;
-
-  // We expect that OnStopDone() comes next.
-
-  DCHECK(type == DemuxerStream::AUDIO || type == DemuxerStream::VIDEO);
-
-  // DCHECK(state_ == kStatePlaying || state_ == kStateStopping)
-  //    << __FUNCTION__ << " illegal state: " << AsString(state_);
-  //
-  // With simultaneous reconfiguration of audio and video streams the state
-  // can be kStatePrefetching as well:
-  // OnLastFrameRendered VIDEO (VIDEO decoder is stopped)
-  // OnLastFrameRendered AUDIO (AUDIO decoder is stopped)
-  // OnDecoderDrained VIDEO (kStatePlaying -> kStateStopping)
-  // OnStopDone VIDEO (kStateStopping -> kStatePrefetching)
-  // OnDecoderDrained AUDIO
-  // OnStopDone AUDIO
-  //
-  // TODO(timav): combine OnDecoderDrained() and OnStopDone() ?
-
-  switch (state_) {
-    case kStatePlaying:
-      SetState(kStateStopping);
-      SetPendingStart(true);
-
-      if (type == DemuxerStream::AUDIO && !VideoFinished()) {
-        DVLOG(1) << __FUNCTION__ << " requesting to stop video";
-        video_decoder_->RequestToStop();
-      } else if (type == DemuxerStream::VIDEO && !AudioFinished()) {
-        DVLOG(1) << __FUNCTION__ << " requesting to stop audio";
-        audio_decoder_->RequestToStop();
-      }
-      break;
-
-    default:
-      break;
-  }
-}
-
-void MediaCodecPlayer::OnStopDone(DemuxerStream::Type type) {
-  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
-  DVLOG(1) << __FUNCTION__ << " " << type
-           << " interpolated time:" << GetInterpolatedTime();
-
-  if (!(audio_decoder_->IsStopped() && video_decoder_->IsStopped())) {
-    DVLOG(1) << __FUNCTION__ << " both audio and video has to be stopped"
-             << ", ignoring";
-    return;  // Wait until other stream is stopped
-  }
-
-  // At this point decoder threads should not be running
-  if (interpolator_.interpolating())
-    interpolator_.StopInterpolating();
-
-  base::TimeDelta seek_time;
-  switch (state_) {
-    case kStateStopping: {
-      base::TimeDelta seek_time = GetPendingSeek();
-      if (seek_time != kNoTimestamp) {
-        SetState(kStateWaitingForSeek);
-        SetPendingSeek(kNoTimestamp);
-        RequestDemuxerSeek(seek_time);
-      } else if (HasPendingStart()) {
-        SetPendingStart(false);
-        SetState(kStateWaitingForPermission);
-        RequestPlayPermission();
-      } else {
-        SetState(kStatePaused);
-      }
-    } break;
-    case kStatePlaying:
-      // Unexpected stop means completion
-      SetState(kStatePaused);
-      break;
-    default:
-      // DVLOG(0) << __FUNCTION__ << " illegal state: " << AsString(state_);
-      // NOTREACHED();
-      // Ignore! There can be a race condition: audio posts OnStopDone,
-      // then video posts, then first OnStopDone arrives at which point
-      // both streams are already stopped, then second OnStopDone arrives. When
-      // the second one arrives, the state us not kStateStopping any more.
-      return;
-  }
-
-  // DetachListener to UI thread
-  ui_task_runner_->PostTask(FROM_HERE, detach_listener_cb_);
-
-  if (AudioFinished() && VideoFinished()) {
-    media_stat_->StopAndReport(GetInterpolatedTime());
-    ui_task_runner_->PostTask(FROM_HERE, completion_cb_);
-  }
-}
-
-void MediaCodecPlayer::OnMissingKeyReported(DemuxerStream::Type type) {
-  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
-  DVLOG(1) << __FUNCTION__ << " " << type;
-
-  // Request stop and restart to pick up the key.
-  key_is_required_ = true;
-
-  if (state_ == kStatePlaying) {
-    media_stat_->StopAndReport(GetInterpolatedTime());
-
-    SetState(kStateStopping);
-    RequestToStopDecoders();
-    SetPendingStart(true);
-  }
-}
-
-void MediaCodecPlayer::OnError() {
-  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
-  DVLOG(1) << __FUNCTION__;
-
-  media_stat_->StopAndReport(GetInterpolatedTime());
-
-  // kStateError blocks all events
-  SetState(kStateError);
-
-  ReleaseDecoderResources();
-
-  ui_task_runner_->PostTask(FROM_HERE,
-                            base::Bind(error_cb_, MEDIA_ERROR_DECODE));
-}
-
-void MediaCodecPlayer::OnStarvation(DemuxerStream::Type type) {
-  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
-  DVLOG(1) << __FUNCTION__ << " stream type:" << type;
-
-  if (state_ != kStatePlaying)
-    return;  // Ignore
-
-  SetState(kStateStopping);
-  RequestToStopDecoders();
-  SetPendingStart(true);
-
-  media_stat_->AddStarvation();
-}
-
-void MediaCodecPlayer::OnTimeIntervalUpdate(DemuxerStream::Type type,
-                                            base::TimeDelta now_playing,
-                                            base::TimeDelta last_buffered,
-                                            bool postpone) {
-  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
-
-  DVLOG(2) << __FUNCTION__ << ": stream type:" << type << " [" << now_playing
-           << "," << last_buffered << "]" << (postpone ? " postpone" : "");
-
-  // For testing only: report time interval as we receive it from decoders
-  // as an indication of what is being rendered. Do not post this callback
-  // for postponed frames: although the PTS is correct, the tests also care
-  // about the wall clock time this callback arrives and deduce the rendering
-  // moment from it.
-  if (!decoders_time_cb_.is_null() && !postpone) {
-    ui_task_runner_->PostTask(
-        FROM_HERE,
-        base::Bind(decoders_time_cb_, type, now_playing, last_buffered));
-  }
-
-  // I assume that audio stream cannot be added after we get configs by
-  // OnDemuxerConfigsAvailable(), but that audio can finish early.
-
-  if (type == DemuxerStream::VIDEO) {
-    // Ignore video PTS if there is audio stream or if it's behind current
-    // time as set by audio stream.
-    if (!AudioFinished() ||
-        (HasAudio() && now_playing < interpolator_.GetInterpolatedTime()))
-      return;
-  }
-
-  interpolator_.SetBounds(now_playing, last_buffered);
-
-  // Post to UI thread
-  if (!postpone) {
-    ui_task_runner_->PostTask(FROM_HERE,
-                              base::Bind(time_update_cb_, GetInterpolatedTime(),
-                                         base::TimeTicks::Now()));
-  }
-}
-
-void MediaCodecPlayer::OnVideoResolutionChanged(const gfx::Size& size) {
-  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
-
-  DVLOG(1) << __FUNCTION__ << " " << size.width() << "x" << size.height();
-
-  // Update cache and notify manager on UI thread
-  ui_task_runner_->PostTask(
-      FROM_HERE, base::Bind(metadata_changed_cb_, kNoTimestamp, size));
-}
-
-// Callbacks from MediaDrmBridge.
-
-void MediaCodecPlayer::OnMediaCryptoReady(
-    MediaDrmBridge::JavaObjectPtr media_crypto,
-    bool needs_protected_surface) {
-  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
-  DVLOG(1) << __FUNCTION__ << " protected surface is "
-           << (needs_protected_surface ? "required" : "not required");
-
-  // We use the parameters that come with this callback every time we call
-  // Configure(). This is possible only if the MediaCrypto object remains valid
-  // and the surface requirement does not change until new SetCdm() is called.
-
-  DCHECK(media_crypto);
-
-  if (media_crypto->is_null()) {
-    // TODO(timav): Fail playback nicely here if needed. Note that we could get
-    // here even though the stream to play is unencrypted and therefore
-    // MediaCrypto is not needed. In that case, we may ignore this error and
-    // continue playback, or fail the playback.
-    LOG(ERROR) << "MediaCrypto creation failed.";
-    return;
-  }
-
-  media_crypto_ = std::move(media_crypto);
-
-  if (audio_decoder_) {
-    audio_decoder_->SetNeedsReconfigure();
-  }
-
-  if (video_decoder_) {
-    video_decoder_->SetNeedsReconfigure();
-    video_decoder_->SetProtectedSurfaceRequired(needs_protected_surface);
-  }
-
-  if (state_ == kStateWaitingForMediaCrypto) {
-    // Resume start sequence (configure, etc.)
-    SetState(kStatePlaying);
-    StartPlaybackOrBrowserSeek();
-  }
-
-  DVLOG(1) << __FUNCTION__ << " end";
-}
-
-void MediaCodecPlayer::OnKeyAdded() {
-  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
-  DVLOG(1) << __FUNCTION__;
-
-  key_is_added_ = true;
-
-  if (state_ == kStateWaitingForKey) {
-    SetState(kStatePlaying);
-    StartPlaybackOrBrowserSeek();
-  }
-}
-
-// State machine operations, called on Media thread
-
-void MediaCodecPlayer::SetState(PlayerState new_state) {
-  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
-
-  DVLOG(1) << "SetState:" << AsString(state_) << " -> " << AsString(new_state);
-  state_ = new_state;
-}
-
-void MediaCodecPlayer::SetPendingStart(bool need_to_start) {
-  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
-  DVLOG(1) << __FUNCTION__ << ": " << need_to_start;
-  pending_start_ = need_to_start;
-}
-
-bool MediaCodecPlayer::HasPendingStart() const {
-  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
-  return pending_start_;
-}
-
-void MediaCodecPlayer::SetPendingSeek(base::TimeDelta timestamp) {
-  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
-  DVLOG(1) << __FUNCTION__ << ": " << timestamp;
-  pending_seek_ = timestamp;
-}
-
-base::TimeDelta MediaCodecPlayer::GetPendingSeek() const {
-  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
-  return pending_seek_;
-}
-
-void MediaCodecPlayer::SetDemuxerConfigs(const DemuxerConfigs& configs) {
-  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
-  DVLOG(1) << __FUNCTION__ << " " << configs;
-
-  DCHECK(audio_decoder_);
-  DCHECK(video_decoder_);
-
-  // At least one valid codec must be present.
-  DCHECK(configs.audio_codec != kUnknownAudioCodec ||
-         configs.video_codec != kUnknownVideoCodec);
-
-  if (configs.audio_codec != kUnknownAudioCodec)
-    audio_decoder_->SetDemuxerConfigs(configs);
-
-  if (configs.video_codec != kUnknownVideoCodec)
-    video_decoder_->SetDemuxerConfigs(configs);
-
-  if (state_ == kStateWaitingForConfig) {
-    SetState(kStateWaitingForPermission);
-    RequestPlayPermission();
-  }
-}
-
-void MediaCodecPlayer::RequestPlayPermission() {
-  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
-  DVLOG(1) << __FUNCTION__;
-
-  // Check that we have received demuxer config hence we know the duration.
-  DCHECK(HasAudio() || HasVideo());
-
-  ui_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&MediaPlayerAndroid::RequestPermissionAndPostResult,
-                            WeakPtrForUIThread(), duration_, HasAudio()));
-}
-
-void MediaCodecPlayer::StartPrefetchDecoders() {
-  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
-  DVLOG(1) << __FUNCTION__;
-
-  bool do_audio = false;
-  bool do_video = false;
-  int count = 0;
-  if (!AudioFinished()) {
-    do_audio = true;
-    ++count;
-  }
-  if (!VideoFinished()) {
-    do_video = true;
-    ++count;
-  }
-
-  DCHECK_LT(0, count);  // at least one decoder should be active
-
-  base::Closure prefetch_cb = base::BarrierClosure(
-      count, base::Bind(&MediaCodecPlayer::OnPrefetchDone, media_weak_this_));
-
-  if (do_audio)
-    audio_decoder_->Prefetch(prefetch_cb);
-
-  if (do_video)
-    video_decoder_->Prefetch(prefetch_cb);
-}
-
-void MediaCodecPlayer::StartPlaybackOrBrowserSeek() {
-  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
-  DVLOG(1) << __FUNCTION__;
-
-  // TODO(timav): consider replacing this method with posting a
-  // browser seek task (i.e. generate an event) from StartPlaybackDecoders().
-
-  // Clear encryption key related flags.
-  key_is_required_ = false;
-  key_is_added_ = false;
-
-  StartStatus status = StartPlaybackDecoders();
-
-  switch (status) {
-    case kStartBrowserSeekRequired:
-      // Browser seek
-      SetState(kStateWaitingForSeek);
-      SetPendingStart(true);
-      StopDecoders();
-      RequestDemuxerSeek(GetInterpolatedTime(), true);
-      break;
-    case kStartCryptoRequired:
-      SetState(kStateWaitingForMediaCrypto);
-      break;
-    case kStartFailed:
-      GetMediaTaskRunner()->PostTask(FROM_HERE, internal_error_cb_);
-      break;
-    case kStartOk:
-      break;
-  }
-}
-
-MediaCodecPlayer::StartStatus MediaCodecPlayer::StartPlaybackDecoders() {
-  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
-  DVLOG(1) << __FUNCTION__;
-
-  // Configure all streams before the start since we may discover that browser
-  // seek is required.
-  MediaCodecPlayer::StartStatus status = ConfigureDecoders();
-  if (status != kStartOk)
-    return status;
-
-  bool preroll_required = false;
-  status = MaybePrerollDecoders(&preroll_required);
-  if (preroll_required)
-    return status;
-
-  return StartDecoders();
-}
-
-MediaCodecPlayer::StartStatus MediaCodecPlayer::ConfigureDecoders() {
-  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
-  DVLOG(1) << __FUNCTION__;
-
-  const bool do_audio = !AudioFinished();
-  const bool do_video = !VideoFinished();
-
-  // If there is nothing to play, the state machine should determine this at the
-  // prefetch state and never call this method.
-  DCHECK(do_audio || do_video);
-
-  const bool need_audio_crypto =
-      do_audio && audio_decoder_->IsContentEncrypted();
-  const bool need_video_crypto =
-      do_video && video_decoder_->IsContentEncrypted();
-
-  // Do we need to create a local ref from the global ref?
-  jobject media_crypto = media_crypto_ ? media_crypto_->obj() : nullptr;
-
-  if (need_audio_crypto || need_video_crypto) {
-    DVLOG(1) << (need_audio_crypto ? " audio" : "")
-             << (need_video_crypto ? " video" : "") << " need(s) encryption";
-    if (!media_crypto) {
-      DVLOG(1) << __FUNCTION__ << ": MediaCrypto is not found, returning";
-      return kStartCryptoRequired;
-    }
-  }
-
-  // Start with video: if browser seek is required it would not make sense to
-  // configure audio.
-
-  MediaCodecDecoder::ConfigStatus status = MediaCodecDecoder::kConfigOk;
-  if (do_video)
-    status = video_decoder_->Configure(media_crypto);
-
-  if (status == MediaCodecDecoder::kConfigOk && do_audio)
-    status = audio_decoder_->Configure(media_crypto);
-
-  switch (status) {
-    case MediaCodecDecoder::kConfigOk:
-      break;
-    case MediaCodecDecoder::kConfigKeyFrameRequired:
-      return kStartBrowserSeekRequired;
-    case MediaCodecDecoder::kConfigFailure:
-      return kStartFailed;
-  }
-  return kStartOk;
-}
-
-MediaCodecPlayer::StartStatus MediaCodecPlayer::MaybePrerollDecoders(
-    bool* preroll_required) {
-  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
-
-  DVLOG(1) << __FUNCTION__ << " current_time:" << GetInterpolatedTime();
-
-  // If requested, preroll is always done in the beginning of the playback,
-  // after prefetch. The request might not happen at all though, in which case
-  // we won't have prerolling phase. We need the prerolling when we (re)create
-  // the decoder, because its configuration and initialization (getting input,
-  // but not making output) can take time, and after the seek because there
-  // could be some data to be skipped and there is again initialization after
-  // the flush.
-
-  *preroll_required = false;
-
-  int count = 0;
-  const bool do_audio = audio_decoder_->NotCompletedAndNeedsPreroll();
-  if (do_audio)
-    ++count;
-
-  const bool do_video = video_decoder_->NotCompletedAndNeedsPreroll();
-  if (do_video)
-    ++count;
-
-  if (count == 0) {
-    DVLOG(1) << __FUNCTION__ << ": preroll is not required, skipping";
-    return kStartOk;
-  }
-
-  *preroll_required = true;
-
-  DCHECK(count > 0);
-  DCHECK(do_audio || do_video);
-
-  DVLOG(1) << __FUNCTION__ << ": preroll for " << count << " stream(s)";
-
-  base::Closure preroll_cb = base::BarrierClosure(
-      count, base::Bind(&MediaCodecPlayer::OnPrerollDone, media_weak_this_));
-
-  if (do_audio && !audio_decoder_->Preroll(preroll_cb))
-    return kStartFailed;
-
-  if (do_video && !video_decoder_->Preroll(preroll_cb))
-    return kStartFailed;
-
-  return kStartOk;
-}
-
-MediaCodecPlayer::StartStatus MediaCodecPlayer::StartDecoders() {
-  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
-
-  if (!interpolator_.interpolating())
-    interpolator_.StartInterpolating();
-
-  base::TimeDelta current_time = GetInterpolatedTime();
-
-  DVLOG(1) << __FUNCTION__ << " current_time:" << current_time;
-
-  // At this point decoder threads are either not running at all or their
-  // message pumps are in the idle state after the preroll is done.
-
-  if (!AudioFinished()) {
-    if (!audio_decoder_->Start(current_time))
-      return kStartFailed;
-
-    // Attach listener on UI thread
-    ui_task_runner_->PostTask(FROM_HERE, attach_listener_cb_);
-  }
-
-  if (!VideoFinished()) {
-    if (!video_decoder_->Start(current_time))
-      return kStartFailed;
-  }
-
-  media_stat_->Start(current_time);
-
-  return kStartOk;
-}
-
-void MediaCodecPlayer::StopDecoders() {
-  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
-  DVLOG(1) << __FUNCTION__;
-
-  video_decoder_->SyncStop();
-  audio_decoder_->SyncStop();
-}
-
-void MediaCodecPlayer::RequestToStopDecoders() {
-  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
-  DVLOG(1) << __FUNCTION__;
-
-  bool do_audio = false;
-  bool do_video = false;
-
-  if (audio_decoder_->IsPrefetchingOrPlaying())
-    do_audio = true;
-  if (video_decoder_->IsPrefetchingOrPlaying())
-    do_video = true;
-
-  if (!do_audio && !do_video) {
-    GetMediaTaskRunner()->PostTask(
-        FROM_HERE, base::Bind(&MediaCodecPlayer::OnStopDone, media_weak_this_,
-                              DemuxerStream::UNKNOWN));
-    return;
-  }
-
-  if (do_audio)
-    audio_decoder_->RequestToStop();
-  if (do_video)
-    video_decoder_->RequestToStop();
-}
-
-void MediaCodecPlayer::RequestDemuxerSeek(base::TimeDelta seek_time,
-                                          bool is_browser_seek) {
-  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
-  DVLOG(1) << __FUNCTION__ << " " << seek_time
-           << (is_browser_seek ? " BROWSER_SEEK" : "");
-
-  // Flush decoders before requesting demuxer.
-  audio_decoder_->Flush();
-  video_decoder_->Flush();
-
-  // Save active seek data. Logically it is attached to kStateWaitingForSeek.
-  DCHECK_EQ(kStateWaitingForSeek, state_);
-  seek_info_.reset(new SeekInfo(seek_time, is_browser_seek));
-
-  demuxer_->RequestDemuxerSeek(seek_time, is_browser_seek);
-}
-
-void MediaCodecPlayer::ReleaseDecoderResources() {
-  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
-  DVLOG(1) << __FUNCTION__;
-
-  if (audio_decoder_)
-    audio_decoder_->ReleaseDecoderResources();
-
-  if (video_decoder_)
-    video_decoder_->ReleaseDecoderResources();
-
-  // At this point decoder threads should not be running
-  if (interpolator_.interpolating())
-    interpolator_.StopInterpolating();
-}
-
-void MediaCodecPlayer::CreateDecoders() {
-  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
-  DVLOG(1) << __FUNCTION__;
-
-  internal_error_cb_ = base::Bind(&MediaCodecPlayer::OnError, media_weak_this_);
-
-  media_stat_.reset(new MediaStatistics());
-
-  audio_decoder_.reset(new AudioMediaCodecDecoder(
-      GetMediaTaskRunner(), &media_stat_->audio_frame_stats(),
-      base::Bind(&MediaCodecPlayer::RequestDemuxerData, media_weak_this_,
-                 DemuxerStream::AUDIO),
-      base::Bind(&MediaCodecPlayer::OnStarvation, media_weak_this_,
-                 DemuxerStream::AUDIO),
-      base::Bind(&MediaCodecPlayer::OnDecoderDrained, media_weak_this_,
-                 DemuxerStream::AUDIO),
-      base::Bind(&MediaCodecPlayer::OnStopDone, media_weak_this_,
-                 DemuxerStream::AUDIO),
-      base::Bind(&MediaCodecPlayer::OnMissingKeyReported, media_weak_this_,
-                 DemuxerStream::AUDIO),
-      internal_error_cb_, base::Bind(&MediaCodecPlayer::OnTimeIntervalUpdate,
-                                     media_weak_this_, DemuxerStream::AUDIO)));
-
-  video_decoder_.reset(new VideoMediaCodecDecoder(
-      GetMediaTaskRunner(), &media_stat_->video_frame_stats(),
-      base::Bind(&MediaCodecPlayer::RequestDemuxerData, media_weak_this_,
-                 DemuxerStream::VIDEO),
-      base::Bind(&MediaCodecPlayer::OnStarvation, media_weak_this_,
-                 DemuxerStream::VIDEO),
-      base::Bind(&MediaCodecPlayer::OnDecoderDrained, media_weak_this_,
-                 DemuxerStream::VIDEO),
-      base::Bind(&MediaCodecPlayer::OnStopDone, media_weak_this_,
-                 DemuxerStream::VIDEO),
-      base::Bind(&MediaCodecPlayer::OnMissingKeyReported, media_weak_this_,
-                 DemuxerStream::VIDEO),
-      internal_error_cb_, base::Bind(&MediaCodecPlayer::OnTimeIntervalUpdate,
-                                     media_weak_this_, DemuxerStream::VIDEO),
-      base::Bind(&MediaCodecPlayer::OnVideoResolutionChanged,
-                 media_weak_this_)));
-}
-
-bool MediaCodecPlayer::AudioFinished() const {
-  return audio_decoder_->IsCompleted() || !audio_decoder_->HasStream();
-}
-
-bool MediaCodecPlayer::VideoFinished() const {
-  return video_decoder_->IsCompleted() || !video_decoder_->HasStream();
-}
-
-base::TimeDelta MediaCodecPlayer::GetInterpolatedTime() {
-  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
-
-  base::TimeDelta interpolated_time = interpolator_.GetInterpolatedTime();
-  return std::min(interpolated_time, duration_);
-}
-
-#undef RETURN_STRING
-#define RETURN_STRING(x) \
-  case x:                \
-    return #x;
-
-const char* MediaCodecPlayer::AsString(PlayerState state) {
-  switch (state) {
-    RETURN_STRING(kStatePaused);
-    RETURN_STRING(kStateWaitingForConfig);
-    RETURN_STRING(kStateWaitingForPermission);
-    RETURN_STRING(kStatePrefetching);
-    RETURN_STRING(kStatePlaying);
-    RETURN_STRING(kStateStopping);
-    RETURN_STRING(kStateWaitingForSurface);
-    RETURN_STRING(kStateWaitingForKey);
-    RETURN_STRING(kStateWaitingForMediaCrypto);
-    RETURN_STRING(kStateWaitingForSeek);
-    RETURN_STRING(kStateError);
-  }
-  return nullptr;  // crash early
-}
-
-#undef RETURN_STRING
-
-}  // namespace media