WeakPtr destruction order cleanup: media edition.

media/base/android/media_source_player.cc

 // Copyright (c) 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 "media/base/android/media_source_player.h"
 
 #include <limits>
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
@@ skipping 19 matching lines @@
 }
 
 namespace media {
 
 MediaSourcePlayer::MediaSourcePlayer(
     int player_id,
     MediaPlayerManager* manager,
     const RequestMediaResourcesCB& request_media_resources_cb,
     const ReleaseMediaResourcesCB& release_media_resources_cb,
     scoped_ptr<DemuxerAndroid> demuxer)
-    : MediaPlayerAndroid(player_id, manager, request_media_resources_cb,
+    : MediaPlayerAndroid(player_id,
+                         manager,
+                         request_media_resources_cb,
                          release_media_resources_cb),
       demuxer_(demuxer.Pass()),
       pending_event_(NO_EVENT_PENDING),
       width_(0),
       height_(0),
       audio_codec_(kUnknownAudioCodec),
       video_codec_(kUnknownVideoCodec),
       num_channels_(0),
       sampling_rate_(0),
       reached_audio_eos_(false),
       reached_video_eos_(false),
       playing_(false),
       is_audio_encrypted_(false),
       is_video_encrypted_(false),
       volume_(-1.0),
       clock_(&default_tick_clock_),
       next_video_data_is_iframe_(true),
       doing_browser_seek_(false),
       pending_seek_(false),
       reconfig_audio_decoder_(false),
       reconfig_video_decoder_(false),
-      weak_this_(this),
       drm_bridge_(NULL),
-      is_waiting_for_key_(false) {
+      is_waiting_for_key_(false),
+      weak_factory_(this) {
   demuxer_->Initialize(this);
   clock_.SetMaxTime(base::TimeDelta());
 }
 
 MediaSourcePlayer::~MediaSourcePlayer() {
   Release();
 }
 
 void MediaSourcePlayer::SetVideoSurface(gfx::ScopedJavaSurface surface) {
   // For an empty surface, always pass it to the decoder job so that it
@@ skipping 306 matching lines @@
   // http://crbug.com/253792.
   if (GetCurrentTime() > base::TimeDelta()) {
     VLOG(0) << "Setting DRM bridge after playback has started. "
             << "This is not well supported!";
   }
 
   drm_bridge_ = drm_bridge;
 
   if (drm_bridge_->GetMediaCrypto().is_null()) {
     drm_bridge_->SetMediaCryptoReadyCB(base::Bind(
-        &MediaSourcePlayer::OnMediaCryptoReady, weak_this_.GetWeakPtr()));
+        &MediaSourcePlayer::OnMediaCryptoReady, weak_factory_.GetWeakPtr()));
     return;
   }
 
   if (playing_)
     StartInternal();
 }
 
 void MediaSourcePlayer::OnDemuxerSeekDone(
     const base::TimeDelta& actual_browser_seek_time) {
   DVLOG(1) << __FUNCTION__;
@@ skipping 114 matching lines @@
     int count = (AudioFinished() ? 0 : 1) + (VideoFinished() ? 0 : 1);
 
     // It is possible that all streams have finished decode, yet starvation
     // occurred during the last stream's EOS decode. In this case, prefetch is a
     // no-op.
     ClearPendingEvent(PREFETCH_REQUEST_EVENT_PENDING);
     if (count == 0)
       return;
 
     SetPendingEvent(PREFETCH_DONE_EVENT_PENDING);
-    base::Closure barrier = BarrierClosure(count, base::Bind(
-        &MediaSourcePlayer::OnPrefetchDone, weak_this_.GetWeakPtr()));
+    base::Closure barrier =
+        BarrierClosure(count,
+                       base::Bind(&MediaSourcePlayer::OnPrefetchDone,
+                                  weak_factory_.GetWeakPtr()));
 
     if (!AudioFinished())
       audio_decoder_job_->Prefetch(barrier);
 
     if (!VideoFinished())
       video_decoder_job_->Prefetch(barrier);
 
     return;
   }
 
@@ skipping 101 matching lines @@
 
   DecodeMoreVideo();
 }
 
 void MediaSourcePlayer::DecodeMoreAudio() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(!audio_decoder_job_->is_decoding());
   DCHECK(!AudioFinished());
 
   if (audio_decoder_job_->Decode(
-          start_time_ticks_, start_presentation_timestamp_, base::Bind(
-              &MediaSourcePlayer::MediaDecoderCallback,
-              weak_this_.GetWeakPtr(), true))) {
+          start_time_ticks_,
+          start_presentation_timestamp_,
+          base::Bind(&MediaSourcePlayer::MediaDecoderCallback,
+                     weak_factory_.GetWeakPtr(),
+                     true))) {
     TRACE_EVENT_ASYNC_BEGIN0("media", "MediaSourcePlayer::DecodeMoreAudio",
                              audio_decoder_job_.get());
     return;
   }
 
   // Failed to start the next decode.
   // Wait for demuxer ready message.
   DCHECK(!reconfig_audio_decoder_);
   reconfig_audio_decoder_ = true;
 
   // Config change may have just been detected on the other stream. If so,
   // don't send a duplicate demuxer config request.
   if (IsEventPending(CONFIG_CHANGE_EVENT_PENDING)) {
     DCHECK(reconfig_video_decoder_);
     return;
   }
 
   SetPendingEvent(CONFIG_CHANGE_EVENT_PENDING);
   ProcessPendingEvents();
 }
 
 void MediaSourcePlayer::DecodeMoreVideo() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(!video_decoder_job_->is_decoding());
   DCHECK(!VideoFinished());
 
   if (video_decoder_job_->Decode(
-          start_time_ticks_, start_presentation_timestamp_, base::Bind(
-              &MediaSourcePlayer::MediaDecoderCallback,
-              weak_this_.GetWeakPtr(), false))) {
+          start_time_ticks_,
+          start_presentation_timestamp_,
+          base::Bind(&MediaSourcePlayer::MediaDecoderCallback,
+                     weak_factory_.GetWeakPtr(),
+                     false))) {
     TRACE_EVENT_ASYNC_BEGIN0("media", "MediaSourcePlayer::DecodeMoreVideo",
                              video_decoder_job_.get());
     return;
   }
 
   // Failed to start the next decode.
   // Wait for demuxer ready message.
 
   // After this detection of video config change, next video data received
   // will begin with I-frame.
@@ skipping 185 matching lines @@
     // For video only streams, fps can be estimated from the difference
     // between the previous and current presentation timestamps. The
     // previous presentation timestamp is equal to current_timestamp.
     // TODO(qinmin): determine whether 2 is a good coefficient for estimating
     // video frame timeout.
     timeout = 2 * (presentation_timestamp - current_timestamp);
   }
 
   timeout = std::max(timeout, kMinStarvationTimeout);
 
-  decoder_starvation_callback_.Reset(
-      base::Bind(&MediaSourcePlayer::OnDecoderStarved,
-                 weak_this_.GetWeakPtr()));
+  decoder_starvation_callback_.Reset(base::Bind(
+      &MediaSourcePlayer::OnDecoderStarved, weak_factory_.GetWeakPtr()));
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE, decoder_starvation_callback_.callback(), timeout);
 }
 
 void MediaSourcePlayer::SetVolumeInternal() {
   if (audio_decoder_job_ && volume_ >= 0)
     audio_decoder_job_->SetVolume(volume_);
 }
 
 bool MediaSourcePlayer::IsProtectedSurfaceRequired() {
@@ skipping 68 matching lines @@
 
 void MediaSourcePlayer::ClearPendingEvent(PendingEventFlags event) {
   DVLOG(1) << __FUNCTION__ << "(" << GetEventName(event) << ")";
   DCHECK_NE(event, NO_EVENT_PENDING);
   DCHECK(IsEventPending(event)) << GetEventName(event);
 
   pending_event_ &= ~event;
 }
 
 }  // namespace media