Throttle media decoding after excessive Android media server crashes

media/base/android/media_player_bridge.cc

 // Copyright (c) 2012 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_player_bridge.h"
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
 #include "base/basictypes.h"
 #include "base/logging.h"
@@ skipping 10 matching lines @@
 
 namespace media {
 
 MediaPlayerBridge::MediaPlayerBridge(
     int player_id,
     const GURL& url,
     const GURL& first_party_for_cookies,
     const std::string& user_agent,
     bool hide_url_log,
     MediaPlayerManager* manager,
-    const RequestMediaResourcesCB& request_media_resources_cb,
+    const OnDecoderResourcesReleasedCB& on_decoder_resources_released_cb,
     const GURL& frame_url,
     bool allow_credentials)
     : MediaPlayerAndroid(player_id,
                          manager,
-                         request_media_resources_cb,
+                         on_decoder_resources_released_cb,
                          frame_url),
       prepared_(false),
       pending_play_(false),
       should_seek_on_prepare_(false),
       url_(url),
       first_party_for_cookies_(first_party_for_cookies),
       user_agent_(user_agent),
       hide_url_log_(hide_url_log),
       width_(0),
       height_(0),
@@ skipping 56 matching lines @@
 
   AttachListener(j_media_player_bridge_.obj());
 }
 
 void MediaPlayerBridge::SetDuration(base::TimeDelta duration) {
   duration_ = duration;
 }
 
 void MediaPlayerBridge::SetVideoSurface(gfx::ScopedJavaSurface surface) {
   if (j_media_player_bridge_.is_null()) {
-    if (surface.IsEmpty())
-      return;
-    Prepare();
+    if (!surface.IsEmpty())
+      surface_ =  surface.Pass();
+    return;
   }
 
   JNIEnv* env = base::android::AttachCurrentThread();
   CHECK(env);
+
   Java_MediaPlayerBridge_setSurface(
       env, j_media_player_bridge_.obj(), surface.j_surface().obj());
 }
 
 void MediaPlayerBridge::Prepare() {
   DCHECK(j_media_player_bridge_.is_null());
   CreateJavaMediaPlayerBridge();
   if (url_.SchemeIsFileSystem() || url_.SchemeIsBlob()) {
     manager()->GetMediaResourceGetter()->GetPlatformPathFromURL(
         url_,
@@ skipping 44 matching lines @@
         env, user_agent_);
 
     if (!Java_MediaPlayerBridge_setDataSource(
         env, j_media_player_bridge_.obj(), j_context, j_url_string.obj(),
         j_cookies.obj(), j_user_agent.obj(), hide_url_log_)) {
       OnMediaError(MEDIA_ERROR_FORMAT);
       return;
     }
   }
 
-  request_media_resources_cb_.Run(player_id());
   if (!Java_MediaPlayerBridge_prepareAsync(env, j_media_player_bridge_.obj()))
     OnMediaError(MEDIA_ERROR_FORMAT);
 }
 
 bool MediaPlayerBridge::InterceptMediaUrl(
     const std::string& url, int* fd, int64* offset, int64* size) {
   // Sentinel value to check whether the output arguments have been set.
   const int kUnsetValue = -1;
 
   *fd = kUnsetValue;
@@ skipping 10 matching lines @@
   return false;
 }
 
 void MediaPlayerBridge::OnDidSetDataUriDataSource(JNIEnv* env, jobject obj,
     jboolean success) {
   if (!success) {
     OnMediaError(MEDIA_ERROR_FORMAT);
     return;
   }
 
-  request_media_resources_cb_.Run(player_id());
   if (!Java_MediaPlayerBridge_prepareAsync(env, j_media_player_bridge_.obj()))
     OnMediaError(MEDIA_ERROR_FORMAT);
 }
 
 void MediaPlayerBridge::OnCookiesRetrieved(const std::string& cookies) {
   cookies_ = cookies;
   manager()->GetMediaResourceGetter()->GetAuthCredentials(
       url_,
       base::Bind(&MediaPlayerBridge::OnAuthCredentialsRetrieved,
                  weak_factory_.GetWeakPtr()));
 }
 
 void MediaPlayerBridge::OnAuthCredentialsRetrieved(
     const base::string16& username, const base::string16& password) {
   GURL::ReplacementsW replacements;
   if (!username.empty()) {
     replacements.SetUsernameStr(username);
     if (!password.empty())
       replacements.SetPasswordStr(password);
     url_ = url_.ReplaceComponents(replacements);
   }
   ExtractMediaMetadata(url_.spec());
 }
 
 void MediaPlayerBridge::ExtractMediaMetadata(const std::string& url) {
   if (url.empty()) {
     OnMediaError(MEDIA_ERROR_FORMAT);
+    on_decoder_resources_released_cb_.Run(player_id());
     return;
   }
 
   int fd;
   int64 offset;
   int64 size;
   if (InterceptMediaUrl(url, &fd, &offset, &size)) {
     manager()->GetMediaResourceGetter()->ExtractMediaMetadata(
         fd, offset, size,
         base::Bind(&MediaPlayerBridge::OnMediaMetadataExtracted,
                    weak_factory_.GetWeakPtr()));
   } else {
     manager()->GetMediaResourceGetter()->ExtractMediaMetadata(
         url, cookies_, user_agent_,
         base::Bind(&MediaPlayerBridge::OnMediaMetadataExtracted,
                    weak_factory_.GetWeakPtr()));
   }
 }
 
 void MediaPlayerBridge::OnMediaMetadataExtracted(
     base::TimeDelta duration, int width, int height, bool success) {
   if (success) {
     duration_ = duration;
     width_ = width;
     height_ = height;
   }
   manager()->OnMediaMetadataChanged(
       player_id(), duration_, width_, height_, success);
+  on_decoder_resources_released_cb_.Run(player_id());
 }
 
 void MediaPlayerBridge::Start() {
   if (j_media_player_bridge_.is_null()) {
     pending_play_ = true;
     Prepare();
   } else {
     if (prepared_)
       StartInternal();
     else
@@ skipping 37 matching lines @@
   JNIEnv* env = base::android::AttachCurrentThread();
   return Java_MediaPlayerBridge_getVideoHeight(
       env, j_media_player_bridge_.obj());
 }
 
 void MediaPlayerBridge::SeekTo(base::TimeDelta timestamp) {
   // Record the time to seek when OnMediaPrepared() is called.
   pending_seek_ = timestamp;
   should_seek_on_prepare_ = true;
 
-  if (j_media_player_bridge_.is_null())
-    Prepare();
-  else if (prepared_)
+  if (prepared_)
     SeekInternal(GetCurrentTime(), timestamp);
 }
 
 base::TimeDelta MediaPlayerBridge::GetCurrentTime() {
   if (!prepared_)
     return pending_seek_;
   JNIEnv* env = base::android::AttachCurrentThread();
   return base::TimeDelta::FromMilliseconds(
       Java_MediaPlayerBridge_getCurrentPosition(
           env, j_media_player_bridge_.obj()));
 }
 
 base::TimeDelta MediaPlayerBridge::GetDuration() {
   if (!prepared_)
     return duration_;
   JNIEnv* env = base::android::AttachCurrentThread();
   const int duration_ms =
       Java_MediaPlayerBridge_getDuration(env, j_media_player_bridge_.obj());
   return duration_ms < 0 ? media::kInfiniteDuration()
                          : base::TimeDelta::FromMilliseconds(duration_ms);
 }
 
 void MediaPlayerBridge::Release() {
+  on_decoder_resources_released_cb_.Run(player_id());
   if (j_media_player_bridge_.is_null())
     return;
 
   time_update_timer_.Stop();
   if (prepared_) {
     pending_seek_ = GetCurrentTime();
     should_seek_on_prepare_ = true;
   }
 
   prepared_ = false;
@@ skipping 42 matching lines @@
   duration_ = GetDuration();
 
   // If media player was recovered from a saved state, consume all the pending
   // events.
   if (should_seek_on_prepare_) {
     PendingSeekInternal(pending_seek_);
     pending_seek_ = base::TimeDelta::FromMilliseconds(0);
     should_seek_on_prepare_ = false;
   }
 
+  if (!surface_.IsEmpty())
+    SetVideoSurface(surface_.Pass());
+
   if (pending_play_) {
     StartInternal();
     pending_play_ = false;
   }
 
   UpdateAllowedOperations();
   manager()->OnMediaMetadataChanged(
       player_id(), duration_, width_, height_, true);
 }
 
@@ skipping 99 matching lines @@
 
 GURL MediaPlayerBridge::GetUrl() {
   return url_;
 }
 
 GURL MediaPlayerBridge::GetFirstPartyForCookies() {
   return first_party_for_cookies_;
 }
 
 }  // namespace media