Adding the logic for releasing decoder resources in WebMediaPlayerManagerAndroid

webkit/media/android/webmediaplayer_android.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 "webkit/media/android/webmediaplayer_android.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 45 matching lines @@
 WebMediaPlayerAndroid::WebMediaPlayerAndroid(
     WebKit::WebFrame* frame,
     WebMediaPlayerClient* client,
     WebKit::WebCookieJar* cookie_jar,
     webkit_media::WebMediaPlayerManagerAndroid* manager,
     webkit_media::StreamTextureFactory* factory)
     : frame_(frame),
       client_(client),
       buffered_(1u),
       video_frame_(new WebVideoFrameImpl(VideoFrame::CreateEmptyFrame())),
-      proxy_(new WebMediaPlayerProxyAndroid(base::MessageLoopProxy::current(),
+      main_loop_(MessageLoop::current()),
+      proxy_(new WebMediaPlayerProxyAndroid(main_loop_->message_loop_proxy(),
                                             AsWeakPtr())),
       prepared_(false),
       duration_(0),
       pending_seek_(0),
       seeking_(false),
       playback_completed_(false),
       buffered_bytes_(0),
       did_loading_progress_(false),
       cookie_jar_(cookie_jar),
       manager_(manager),
       pending_play_event_(false),
       network_state_(WebMediaPlayer::NetworkStateEmpty),
       ready_state_(WebMediaPlayer::ReadyStateHaveNothing),
       texture_id_(0),
       stream_id_(0),
       needs_establish_peer_(true),
       stream_texture_factory_(factory) {
-  player_id_ = manager_->RegisterMediaPlayer(this);
+  main_loop_->AddDestructionObserver(this);
+  if (manager_)
+    player_id_ = manager_->RegisterMediaPlayer(this);
   if (stream_texture_factory_.get())
     stream_texture_proxy_.reset(stream_texture_factory_->CreateProxy());
 }
 
 WebMediaPlayerAndroid::~WebMediaPlayerAndroid() {
   if (media_player_.get()) {
     media_player_->Stop();

[scherkus (not reviewing), 2012/06/07 21:44:34]

how does Stop() differ from deleting the media_player_?

[qinmin, 2012/06/08 17:09:06]

After stop(), the player needs to call setDataSource() again. I think this call
is introduced long time ago when we have a crash if we delete a running
media_player_. The bug should have been fixed and we should no longer need this.

On 2012/06/07 21:44:34, scherkus wrote:

   }
 
-  manager_->UnregisterMediaPlayer(player_id_);
+  if (manager_)
+    manager_->UnregisterMediaPlayer(player_id_);
+
+  if (main_loop_)
+    main_loop_->RemoveDestructionObserver(this);
 }
 
 void WebMediaPlayerAndroid::InitIncognito(bool incognito_mode) {
   incognito_mode_ = incognito_mode;
 }
 
 void WebMediaPlayerAndroid::load(const WebURL& url) {
   url_ = url;
 
   UpdateNetworkState(WebMediaPlayer::NetworkStateLoading);
@@ skipping 361 matching lines @@
     // Save the current media player status.
     pending_seek_ = currentTime();
     duration_ = duration();
 
     media_player_.reset();
     needs_establish_peer_ = true;
   }
   prepared_ = false;
 }
 
+bool WebMediaPlayerAndroid::IsInitialized() const {
+  return (media_player_ != NULL);
+}
+
 void WebMediaPlayerAndroid::InitializeMediaPlayer() {
   CHECK(!media_player_.get());
   prepared_ = false;
   media_player_.reset(new MediaPlayerBridge());
   media_player_->SetStayAwakeWhilePlaying();
 
   std::string cookies;
   if (cookie_jar_ != NULL) {
     WebURL first_party_url(frame_->document().firstPartyForCookies());
     cookies = UTF16ToUTF8(cookie_jar_->cookies(url_, first_party_url));
   }
   media_player_->SetDataSource(url_.spec(), cookies, incognito_mode_);
 
+  if (manager_)
+    manager_->RequestMediaResources(player_id_);
+
   media_player_->Prepare(
       base::Bind(&WebMediaPlayerProxyAndroid::MediaInfoCallback, proxy_),
       base::Bind(&WebMediaPlayerProxyAndroid::MediaErrorCallback, proxy_),
       base::Bind(&WebMediaPlayerProxyAndroid::VideoSizeChangedCallback, proxy_),
       base::Bind(&WebMediaPlayerProxyAndroid::BufferingUpdateCallback, proxy_),
       base::Bind(&WebMediaPlayerProxyAndroid::MediaPreparedCallback, proxy_));
 }
 
 void WebMediaPlayerAndroid::PlayInternal() {
   CHECK(prepared_);
@@ skipping 42 matching lines @@
 }
 
 void WebMediaPlayerAndroid::DestroyStreamTexture() {
   DCHECK(stream_id_);
   DCHECK(texture_id_);
   stream_texture_factory_->DestroyStreamTexture(texture_id_);
   texture_id_ = 0;
   stream_id_ = 0;
 }
 
+void WebMediaPlayerAndroid::WillDestroyCurrentMessageLoop() {

[scherkus (not reviewing), 2012/06/07 21:44:34]

typically when the loop is going away the process we're going to get deleted
very soon -- what's the delta between this being called and the dtor being
called?

[qinmin, 2012/06/08 17:09:06]

I haven't see that happening myself, but i saw that in our crash reports. I
think that delta should be pretty small though, as I only saw 2 reports on this.

On 2012/06/07 21:44:34, scherkus wrote:

+  manager_ = NULL;
+  main_loop_ = NULL;
+}
+
 WebVideoFrame* WebMediaPlayerAndroid::getCurrentFrame() {
   if (!stream_texture_proxy_->IsInitialized() && stream_id_) {
     stream_texture_proxy_->Initialize(
         stream_id_, video_frame_->width(), video_frame_->height());
   }
 
   return video_frame_.get();
 }
 
 void WebMediaPlayerAndroid::putCurrentFrame(
     WebVideoFrame* web_video_frame) {
 }
 
 // This gets called both on compositor and main thread.
 void WebMediaPlayerAndroid::setStreamTextureClient(
     WebKit::WebStreamTextureClient* client) {
   if (stream_texture_proxy_.get())
     stream_texture_proxy_->SetClient(client);
 }
 
 }  // namespace webkit_media