Throttle media decoding after excessive Android media server crashes

media/base/android/media_codec_player.cc

 // 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 "base/barrier_closure.h"
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
@@ skipping 18 matching lines @@
     }                                                                        \
   } while (0)
 
 namespace media {
 
 // MediaCodecPlayer implementation.
 
 MediaCodecPlayer::MediaCodecPlayer(
     int player_id,
     base::WeakPtr<MediaPlayerManager> manager,
-    const RequestMediaResourcesCB& request_media_resources_cb,
+    const OnDecoderResourcesReleasedCB& on_decoder_resources_released_cb,
     scoped_ptr<DemuxerAndroid> demuxer,
     const GURL& frame_url)
     : MediaPlayerAndroid(player_id,
                          manager.get(),
-                         request_media_resources_cb,
+                         on_decoder_resources_released_cb,
                          frame_url),
       ui_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       demuxer_(demuxer.Pass()),
       state_(kStatePaused),
       interpolator_(&default_tick_clock_),
       pending_start_(false),
       pending_seek_(kNoTimestamp()),
       drm_bridge_(nullptr),
       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;
 
-  request_resources_cb_ = base::Bind(request_media_resources_cb_, 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);
@@ skipping 237 matching lines @@
       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__;
 
   // 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);
@@ skipping 563 matching lines @@
   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::OnVideoCodecCreated() {
-  DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
-
-  // This callback requests resources by releasing other players.
-  ui_task_runner_->PostTask(FROM_HERE, request_resources_cb_);
-}
-
 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));
 }
 
@@ skipping 453 matching lines @@
                  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_),
-      base::Bind(&MediaCodecPlayer::OnVideoCodecCreated, media_weak_this_)));
+      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();
 }
 
@@ skipping 22 matching lines @@
     RETURN_STRING(kStateWaitingForMediaCrypto);
     RETURN_STRING(kStateWaitingForSeek);
     RETURN_STRING(kStateError);
   }
   return nullptr;  // crash early
 }
 
 #undef RETURN_STRING
 
 }  // namespace media