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 31 matching lines @@
 
 scoped_refptr<base::SingleThreadTaskRunner> GetMediaTaskRunner() {
   return g_media_thread.Pointer()->task_runner();
 }
 
 // MediaCodecPlayer implementation.
 
 MediaCodecPlayer::MediaCodecPlayer(
     int player_id,
     base::WeakPtr<MediaPlayerManager> manager,
-    const RequestMediaResourcesCB& request_media_resources_cb,
+    const OnPlayerReleasedCB& on_player_released_cb,
     scoped_ptr<DemuxerAndroid> demuxer,
     const GURL& frame_url)
     : MediaPlayerAndroid(player_id,
                          manager.get(),
-                         request_media_resources_cb,
+                         on_player_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()),
       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);
   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,
@@ skipping 210 matching lines @@
       break;
     case kStateError:
       break;  // ignore
     default:
       NOTREACHED();
       break;
   }
 }
 
 void MediaCodecPlayer::Release() {
+  if (ui_task_runner_->BelongsToCurrentThread())
+    on_player_released_cb_.Run(player_id());

[Tima Vaisburd, 2015/09/28 22:09:12]

Did you consider posting this callback to UI thread? Is it important to run this
cb before the body of the Release()?

[Ted C, 2015/09/28 22:42:30]

And should we be doing something in the else?

[Tima Vaisburd, 2015/09/28 23:04:47]

In the 'else' we continue :-)

Each method with RUN_ON_MEDIA_THREAD is called twice. First on UI thread, on
which the macro re-posts the very same method onto the Media thread, and then on
the Media thread.

In this patch we report that the player is released on the first run, before the
resources are actually released (it will happen on the Media thread later).

[qinmin, 2015/09/29 23:16:23]

The problem to post the task is that the MediaPlayerManager can go away when the
task is posted on the UI thread. As a result, the callback will not be executed
and the singleton MediaThrottler will not know that the player has been
released.

An alternative is to pass MediaThrottler::OnDecodeRequestFinished() to
MediaPlayerAndroid. However, in that case, the MediaPlayerManager won't know
that the decoder resources are released.

Added a todo there.

+
   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 464 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 333 matching lines @@
                                        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),
       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 19 matching lines @@
     RETURN_STRING(kStateWaitingForSurface);
     RETURN_STRING(kStateWaitingForSeek);
     RETURN_STRING(kStateError);
   }
   return nullptr;  // crash early
 }
 
 #undef RETURN_STRING
 
 }  // namespace media