Reduce and limit video poster memory usage

chrome/browser/media/android/remote/remote_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 "chrome/browser/media/android/remote/remote_media_player_manager.h"
 
 #include "chrome/browser/android/tab_android.h"
 #include "chrome/common/chrome_content_client.h"
 #include "content/common/media/media_player_messages_android.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/android/java_bitmap.h"
 
 using media::MediaPlayerAndroid;
 
+static const int MAX_POSTER_BITMAP_SIZE = 1024 * 1024;
+
 namespace remote_media {
 
 RemoteMediaPlayerManager::RemoteMediaPlayerManager(
     content::RenderFrameHost* render_frame_host)
     : BrowserMediaPlayerManager(render_frame_host),
       weak_ptr_factory_(this) {
 }
 
 RemoteMediaPlayerManager::~RemoteMediaPlayerManager() {
   for (MediaPlayerAndroid* player : alternative_players_)
@@ skipping 18 matching lines @@
   if (player) {
     RemoteMediaPlayerBridge* remote_player = CreateRemoteMediaPlayer(player);
     remote_player->OnPlayerCreated();
   }
 }
 
 void RemoteMediaPlayerManager::OnDestroyPlayer(int player_id) {
   RemoteMediaPlayerBridge* player = GetRemotePlayer(player_id);
   if (player)
     player->OnPlayerDestroyed();
+  poster_urls_.erase(player_id);
   BrowserMediaPlayerManager::OnDestroyPlayer(player_id);
 }
 
 void RemoteMediaPlayerManager::OnSuspendAndReleaseResources(int player_id) {
   // We only want to release resources of local players.
   if (!IsPlayingRemotely(player_id))
     BrowserMediaPlayerManager::OnSuspendAndReleaseResources(player_id);
 }
 
 void RemoteMediaPlayerManager::OnRequestRemotePlayback(int player_id) {
@@ skipping 16 matching lines @@
   if (!web_contents())
     return -1;
 
   TabAndroid* tab = TabAndroid::FromWebContents(web_contents());
   if (!tab)
     return -1;
 
   return tab->GetAndroidId();
 }
 
+void RemoteMediaPlayerManager::FetchPosterBitmap(int player_id) {
+  RemoteMediaPlayerBridge* player = GetRemotePlayer(player_id);
+  if (poster_urls_.count(player_id) == 0 ||
+      poster_urls_[player_id].is_empty()) {
+    if (player)
+      player->SetPosterBitmap(std::vector<SkBitmap>());
+    return;
+  }
+  content::WebContents::ImageDownloadCallback callback =
+      base::Bind(&RemoteMediaPlayerManager::DidDownloadPoster,
+                 weak_ptr_factory_.GetWeakPtr(), player_id);
+  web_contents()->DownloadImage(
+      poster_urls_[player_id],
+      false,  // is_favicon, false so that cookies will be used.
+      MAX_POSTER_BITMAP_SIZE,  // max_bitmap_size, 0 means no limit.
+      false,                   // normal cache policy.
+      callback);
+}
+
 void RemoteMediaPlayerManager::OnSetPoster(int player_id, const GURL& url) {
-  RemoteMediaPlayerBridge* player = GetRemotePlayer(player_id);
-
-  if (player && url.is_empty()) {
-    player->SetPosterBitmap(std::vector<SkBitmap>());
-  } else {
-    // TODO(aberent) OnSetPoster is called when the attributes of the video
-    // element are parsed, which may be before OnInitialize is called. We are
-    // here relying on the image fetch taking longer than the delay until
-    // OnInitialize is called, and hence the player is created. This is not
-    // guaranteed.
-    content::WebContents::ImageDownloadCallback callback = base::Bind(
-        &RemoteMediaPlayerManager::DidDownloadPoster,
-        weak_ptr_factory_.GetWeakPtr(), player_id);
-    web_contents()->DownloadImage(
-        url,
-        false,  // is_favicon, false so that cookies will be used.
-        0,  // max_bitmap_size, 0 means no limit.
-        false, // normal cache policy.
-        callback);
-  }
+  // OnSetPoster is called when the attibutes of the video element are parsed,
+  // which may be before OnInitialize is called, so we can't assume that the
+  // players wil exist.
+  poster_urls_[player_id] = url;
 }
 
 void RemoteMediaPlayerManager::ReleaseResources(int player_id) {
   if (IsPlayingRemotely(player_id))
     return;
   BrowserMediaPlayerManager::ReleaseResources(player_id);
 }
 
 void RemoteMediaPlayerManager::DidDownloadPoster(
     int player_id,
@@ skipping 44 matching lines @@
 
 void RemoteMediaPlayerManager::SwitchToRemotePlayer(
     int player_id,
     const std::string& casting_message) {
   DCHECK(!IsPlayingRemotely(player_id));
   SwapCurrentPlayer(player_id);
   players_playing_remotely_.insert(player_id);
   Send(new MediaPlayerMsg_DidMediaPlayerPlay(RoutingID(), player_id));
   Send(new MediaPlayerMsg_ConnectedToRemoteDevice(RoutingID(), player_id,
                                                   casting_message));
+  // The remote player will want the poster bitmap, however, to avoid wasting
+  // memory we don't fetch it until we are likely to need it.
+  FetchPosterBitmap(player_id);
 }
 
 void RemoteMediaPlayerManager::SwitchToLocalPlayer(int player_id) {
   DCHECK(IsPlayingRemotely(player_id));
   SwapCurrentPlayer(player_id);
   players_playing_remotely_.erase(player_id);
   Send(new MediaPlayerMsg_DisconnectedFromRemoteDevice(RoutingID(), player_id));
 }
 
 void RemoteMediaPlayerManager::ReplaceRemotePlayerWithLocal(int player_id) {
@@ skipping 83 matching lines @@
     MediaPlayerAndroid* local_player = GetLocalPlayer(player_id);
     Send(new MediaPlayerMsg_MediaMetadataChanged(
         RoutingID(), player_id, duration, local_player->GetVideoWidth(),
         local_player->GetVideoHeight(), success));
   } else {
     BrowserMediaPlayerManager::OnMediaMetadataChanged(player_id, duration,
                                                       width, height, success);
   }
 }
 } // namespace remote_media