Remove OnMediaResourcesReleased callback passed to MediaPlayerAndroid

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"
@@ skipping 65 matching lines @@
       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,
           manager,
           base::Bind(&BrowserMediaPlayerManager::OnMediaResourcesRequested,
                      weak_ptr_factory_.GetWeakPtr()),
-          base::Bind(&BrowserMediaPlayerManager::OnMediaResourcesReleased,
-                     weak_ptr_factory_.GetWeakPtr()),
           media_player_params.frame_url,
           media_player_params.allow_credentials);
       BrowserMediaPlayerManager* browser_media_player_manager =
           static_cast<BrowserMediaPlayerManager*>(manager);
       ContentViewCoreImpl* content_view_core_impl =
           static_cast<ContentViewCoreImpl*>(ContentViewCore::FromWebContents(
               browser_media_player_manager->web_contents_));
       if (!content_view_core_impl) {
         // May reach here due to prerendering. Don't extract the metadata
         // since it is expensive.
         // TODO(qinmin): extract the metadata once the user decided to load
         // the page.
         browser_media_player_manager->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: {
       return new MediaSourcePlayer(
           media_player_params.player_id,
           manager,
           base::Bind(&BrowserMediaPlayerManager::OnMediaResourcesRequested,
                      weak_ptr_factory_.GetWeakPtr()),
-          base::Bind(&BrowserMediaPlayerManager::OnMediaResourcesReleased,
-                     weak_ptr_factory_.GetWeakPtr()),
           demuxer->CreateDemuxer(media_player_params.demuxer_client_id),
           media_player_params.frame_url);
     }
   }
 
   NOTREACHED();
   return NULL;
 }
 
 BrowserMediaPlayerManager::BrowserMediaPlayerManager(
@@ skipping 364 matching lines @@
   if (player)
     player->SetVolume(volume);
 }
 
 void BrowserMediaPlayerManager::OnSetPoster(int player_id, const GURL& url) {
   // To be overridden by subclasses.
 }
 
 void BrowserMediaPlayerManager::OnReleaseResources(int player_id) {
   MediaPlayerAndroid* player = GetPlayer(player_id);
-  if (player)
+  if (player) {
     player->Release();
+    OnMediaResourcesReleased(player_id);
+  }
   if (player_id == fullscreen_player_id_)
     fullscreen_player_is_released_ = true;
 }
 
 void BrowserMediaPlayerManager::OnDestroyPlayer(int player_id) {
   RemovePlayer(player_id);
   if (fullscreen_player_id_ == player_id)
     fullscreen_player_id_ = -1;
 }
 
@@ skipping 31 matching lines @@
 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) {
-    player->Release();
+  player->Release();
+  OnMediaResourcesReleased(player->player_id());
 }
 
 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;
 
     // The player is already active, ignore it.
     if ((*it)->player_id() == player_id)
       return;
     else
       num_active_player++;
   }
 
   // Number of active players are less than the threshold, do nothing.
   if (num_active_player < kMediaPlayerThreshold)
     return;
 
   for (it = players_.begin(); it != players_.end(); ++it) {
     if ((*it)->IsPlayerReady() && !(*it)->IsPlaying() &&
         fullscreen_player_id_ != (*it)->player_id()) {
       (*it)->Release();
+      OnMediaResourcesReleased(player_id);

[xhwang, 2014/09/03 16:36:58]

This pattern appeared 3 times:

player->Release();
OnMediaResourcesReleased(player->player_id());

How about add a helper function like ReleasePlayer()?

[qinmin, 2014/09/03 18:27:52]

Done.

       Send(new MediaPlayerMsg_MediaPlayerReleased(RoutingID(),
                                                   (*it)->player_id()));
     }
   }
 }
 
 void BrowserMediaPlayerManager::OnMediaResourcesReleased(int player_id) {
 #if defined(VIDEO_HOLE)
   MediaPlayerAndroid* player = GetPlayer(player_id);
   if (player && player->IsSurfaceInUse())
     return;
   if (external_video_surface_container_)
     external_video_surface_container_->ReleaseExternalVideoSurface(player_id);
 #endif  // defined(VIDEO_HOLE)
 }
 
 }  // namespace content