Throttle media decoding after excessive Android media server crashes

content/browser/media/android/browser_media_player_manager.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/browser/media/android/browser_media_player_manager.h"
 
 #include "base/android/scoped_java_ref.h"
 #include "base/command_line.h"
 #include "content/browser/android/content_view_core_impl.h"
 #include "content/browser/media/android/browser_demuxer_android.h"
 #include "content/browser/media/android/media_resource_getter_impl.h"
 #include "content/browser/media/android/media_session.h"
+#include "content/browser/media/android/media_throttler.h"
 #include "content/browser/media/media_web_contents_observer.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/browser/web_contents/web_contents_view_android.h"
 #include "content/common/media/media_player_messages_android.h"
 #include "content/public/browser/android/content_view_core.h"
 #include "content/public/browser/android/external_video_surface_container.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/render_frame_host.h"
@@ skipping 114 matching lines @@
   switch (media_player_params.type) {
     case MEDIA_PLAYER_TYPE_URL: {
       const std::string user_agent = GetContentClient()->GetUserAgent();
       MediaPlayerBridge* media_player_bridge = new MediaPlayerBridge(
           media_player_params.player_id,
           media_player_params.url,
           media_player_params.first_party_for_cookies,
           user_agent,
           hide_url_log,
           this,
-          base::Bind(&BrowserMediaPlayerManager::OnMediaResourcesRequested,
+          base::Bind(&BrowserMediaPlayerManager::OnDecorderResourcesReleased,
                      weak_ptr_factory_.GetWeakPtr()),
           media_player_params.frame_url,
           media_player_params.allow_credentials);
       ContentViewCoreImpl* content_view_core_impl =
           static_cast<ContentViewCoreImpl*>(ContentViewCore::FromWebContents(
               web_contents_));
-      if (!content_view_core_impl) {
-        // May reach here due to prerendering. Don't extract the metadata
-        // since it is expensive.
+      if (!content_view_core_impl
+          // Initialize the player will cause MediaMetadataExtractor to decode
+          // small chunks of data.
+          || !RequestDecoderResources(media_player_params.player_id, true)) {
+        // May reach here due to prerendering or throttling. Don't extract the
+        // metadata since it is expensive.
         // TODO(qinmin): extract the metadata once the user decided to load
         // the page.
         OnMediaMetadataChanged(
             media_player_params.player_id, base::TimeDelta(), 0, 0, false);
       } else if (!content_view_core_impl->ShouldBlockMediaRequest(
             media_player_params.url)) {
         media_player_bridge->Initialize();
       }
       return media_player_bridge;
     }
 
     case MEDIA_PLAYER_TYPE_MEDIA_SOURCE: {
       if (base::CommandLine::ForCurrentProcess()->
           HasSwitch(switches::kEnableMediaThreadForMediaPlayback)) {
         return new MediaCodecPlayer(
             media_player_params.player_id,
             weak_ptr_factory_.GetWeakPtr(),
-            base::Bind(&BrowserMediaPlayerManager::OnMediaResourcesRequested,
+            base::Bind(&BrowserMediaPlayerManager::OnDecorderResourcesReleased,
                        weak_ptr_factory_.GetWeakPtr()),
             demuxer->CreateDemuxer(media_player_params.demuxer_client_id),
             media_player_params.frame_url);
       } else {
         return new MediaSourcePlayer(
             media_player_params.player_id,
             this,
-            base::Bind(&BrowserMediaPlayerManager::OnMediaResourcesRequested,
+            base::Bind(&BrowserMediaPlayerManager::OnDecorderResourcesReleased,
                        weak_ptr_factory_.GetWeakPtr()),
             demuxer->CreateDemuxer(media_player_params.demuxer_client_id),
             media_player_params.frame_url);
       }
     }
   }
 
   NOTREACHED();
   return NULL;
 }
@@ skipping 121 matching lines @@
 }
 
 void BrowserMediaPlayerManager::OnSeekComplete(
     int player_id,
     const base::TimeDelta& current_time) {
   Send(new MediaPlayerMsg_SeekCompleted(RoutingID(), player_id, current_time));
 }
 
 void BrowserMediaPlayerManager::OnError(int player_id, int error) {
   Send(new MediaPlayerMsg_MediaError(RoutingID(), player_id, error));
-  if (fullscreen_player_id_ == player_id)
+  if (fullscreen_player_id_ == player_id &&
+      error != MediaPlayerAndroid::MEDIA_ERROR_INVALID_CODE) {
     video_view_->OnMediaPlayerError(error);
+  }
 }
 
 void BrowserMediaPlayerManager::OnVideoSizeChanged(
     int player_id, int width, int height) {
   Send(new MediaPlayerMsg_MediaVideoSizeChanged(RoutingID(), player_id,
       width, height));
   if (fullscreen_player_id_ == player_id)
     video_view_->OnVideoSizeChanged(width, height);
 }
 
@@ skipping 135 matching lines @@
     // In case we're stealing the external surface from another player.
     ReleasePlayerOfExternalVideoSurfaceIfNeeded(player_id);
     external_video_surface_container_->RequestExternalVideoSurface(
         player_id,
         base::Bind(&BrowserMediaPlayerManager::AttachExternalVideoSurface,
                    base::Unretained(this)),
         base::Bind(&BrowserMediaPlayerManager::DetachExternalVideoSurface,
                    base::Unretained(this)));
   }
 }
+
+void BrowserMediaPlayerManager::ReleaseExternalSurface(int player_id) {
+  if (external_video_surface_container_)
+    external_video_surface_container_->ReleaseExternalVideoSurface(player_id);
+}
 #endif  // defined(VIDEO_HOLE)
 
 void BrowserMediaPlayerManager::OnEnterFullscreen(int player_id) {
   DCHECK_EQ(fullscreen_player_id_, kInvalidMediaPlayerId);
 #if defined(VIDEO_HOLE)
   // If this fullscreen player is started when another player
   // uses the external surface, release that other player.
   ReleasePlayerOfExternalVideoSurfaceIfNeeded(player_id);
   if (external_video_surface_container_)
     external_video_surface_container_->ReleaseExternalVideoSurface(player_id);
@@ skipping 38 matching lines @@
   if (!player)
     return;
 
   AddPlayer(player);
 }
 
 void BrowserMediaPlayerManager::OnStart(int player_id) {
   MediaPlayerAndroid* player = GetPlayer(player_id);
   if (!player)
     return;
-  player->Start();
-  if (fullscreen_player_id_ == player_id && fullscreen_player_is_released_) {
-    video_view_->OpenVideo();
-    fullscreen_player_is_released_ = false;
+
+  if (RequestDecoderResources(player_id, false)) {
+    StartInternal(player_id);
+  } else if (WebContentsDelegate* delegate = web_contents_->GetDelegate()){
+    delegate->RequestMediaDecodePermission(
+        web_contents_,
+        base::Bind(&BrowserMediaPlayerManager::OnPlaybackPermissionGranted,
+                   weak_ptr_factory_.GetWeakPtr(), player_id));
   }
 }
 
 void BrowserMediaPlayerManager::OnSeek(
     int player_id,
     const base::TimeDelta& time) {
   MediaPlayerAndroid* player = GetPlayer(player_id);
   if (player)
     player->SeekTo(time);
 }
@@ skipping 50 matching lines @@
 
 void BrowserMediaPlayerManager::AddPlayer(MediaPlayerAndroid* player) {
   DCHECK(!GetPlayer(player->player_id()));
   players_.push_back(player);
 }
 
 void BrowserMediaPlayerManager::RemovePlayer(int player_id) {
   for (ScopedVector<MediaPlayerAndroid>::iterator it = players_.begin();
       it != players_.end(); ++it) {
     if ((*it)->player_id() == player_id) {
-      ReleaseMediaResources(player_id);
+#if defined(VIDEO_HOLE)
+      ReleaseExternalSurface(player_id);
+#endif
       (*it)->DeleteOnCorrectThread();
       players_.weak_erase(it);
       MediaSession::Get(web_contents())->RemovePlayer(this, player_id);
       break;
     }
   }
+  active_players_.erase(player_id);
 }
 
 scoped_ptr<media::MediaPlayerAndroid> BrowserMediaPlayerManager::SwapPlayer(
       int player_id, media::MediaPlayerAndroid* player) {
   media::MediaPlayerAndroid* previous_player = NULL;
   for (ScopedVector<MediaPlayerAndroid>::iterator it = players_.begin();
       it != players_.end(); ++it) {
     if ((*it)->player_id() == player_id) {
       previous_player = *it;
-      ReleaseMediaResources(player_id);
+#if defined(VIDEO_HOLE)
+      ReleaseExternalSurface(player_id);
+#endif
       players_.weak_erase(it);
       players_.push_back(player);
       break;
     }
   }
   return scoped_ptr<media::MediaPlayerAndroid>(previous_player);
 }
 
 int BrowserMediaPlayerManager::RoutingID() {
   return render_frame_host_->GetRoutingID();
 }
 
 bool BrowserMediaPlayerManager::Send(IPC::Message* msg) {
   return render_frame_host_->Send(msg);
 }
 
 void BrowserMediaPlayerManager::ReleaseFullscreenPlayer(
     MediaPlayerAndroid* player) {
   ReleasePlayer(player);
 }
 
-void BrowserMediaPlayerManager::OnMediaResourcesRequested(int player_id) {
-  int num_active_player = 0;
-  ScopedVector<MediaPlayerAndroid>::iterator it;
-  for (it = players_.begin(); it != players_.end(); ++it) {
-    if (!(*it)->IsPlayerReady())
-      continue;
+bool BrowserMediaPlayerManager::RequestDecoderResources(
+    int player_id, bool temporary) {
+  if (!MediaThrottler::GetInstance()->RequestDecoderResources())
+    return false;
 
-    // The player is already active, ignore it.
-    if ((*it)->player_id() == player_id)
-      return;
-    else
-      num_active_player++;
+  ActivePlayerMap::iterator it;
+  // The player is already active, ignore it. A long running player should not
+  // request temporary permissions.
+  if ((it = active_players_.find(player_id)) != active_players_.end()) {
+    DCHECK(!temporary || it->second);
+    return true;
   }
 
-  // Number of active players are less than the threshold, do nothing.
-  if (num_active_player < kMediaPlayerThreshold)
+  if (!temporary) {
+    int long_running_player = 0;
+    for (it = active_players_.begin(); it != active_players_.end(); ++it) {
+      if (!it->second)
+        long_running_player++;
+    }
+
+    // Number of active players are less than the threshold, do nothing.
+    if (long_running_player < kMediaPlayerThreshold)
+      return true;
+
+    for (it = active_players_.begin(); it != active_players_.end(); ++it) {
+      if (!it->second && !GetPlayer(it->first)->IsPlaying() &&
+          fullscreen_player_id_ != it->first) {
+        ReleasePlayer(GetPlayer(it->first));
+        Send(new MediaPlayerMsg_MediaPlayerReleased(RoutingID(),
+                                                    (it->first)));
+      }
+    }
+  }
+
+  active_players_[player_id] = temporary;
+  return true;
+}
+
+void BrowserMediaPlayerManager::OnDecorderResourcesReleased(int player_id) {
+  if (active_players_.find(player_id) == active_players_.end())
     return;
 
-  for (it = players_.begin(); it != players_.end(); ++it) {
-    if ((*it)->IsPlayerReady() && !(*it)->IsPlaying() &&
-        fullscreen_player_id_ != (*it)->player_id()) {
-      ReleasePlayer(*it);
-      Send(new MediaPlayerMsg_MediaPlayerReleased(RoutingID(),
-                                                  (*it)->player_id()));
-    }
-  }
-}
-
-void BrowserMediaPlayerManager::ReleaseMediaResources(int player_id) {
-#if defined(VIDEO_HOLE)
-  if (external_video_surface_container_)
-    external_video_surface_container_->ReleaseExternalVideoSurface(player_id);
-#endif  // defined(VIDEO_HOLE)
+  active_players_.erase(player_id);
+  MediaThrottler::GetInstance()->OnDecodeRequestFinished();
 }
 
 void BrowserMediaPlayerManager::ReleasePlayer(MediaPlayerAndroid* player) {
   player->Release();
-  ReleaseMediaResources(player->player_id());
+#if defined(VIDEO_HOLE)
+  ReleaseExternalSurface(player->player_id());
+#endif
+}
+
+void BrowserMediaPlayerManager::OnPlaybackPermissionGranted(
+    int player_id, bool granted) {
+  if (!granted)
+    return;
+
+  MediaThrottler::GetInstance()->Reset();
+  StartInternal(player_id);
+}
+
+void BrowserMediaPlayerManager::StartInternal(int player_id) {
+  MediaPlayerAndroid* player = GetPlayer(player_id);
+  if (!player)
+    return;
+  player->Start();
+  if (fullscreen_player_id_ == player_id && fullscreen_player_is_released_) {
+    video_view_->OpenVideo();
+    fullscreen_player_is_released_ = false;
+  }
 }
 
 }  // namespace content