WeakPtr destruction order cleanup: media edition.

media/base/text_renderer.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 "media/base/text_renderer.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/demuxer.h"
 #include "media/base/demuxer_stream.h"
 #include "media/base/text_cue.h"
 
 namespace media {
 
 TextRenderer::TextRenderer(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     const AddTextTrackCB& add_text_track_cb)
     : task_runner_(task_runner),
-      weak_factory_(this),
       add_text_track_cb_(add_text_track_cb),
       state_(kUninitialized),
-      pending_read_count_(0) {
-}
+      pending_read_count_(0),
+      weak_factory_(this) {}
 
 TextRenderer::~TextRenderer() {
   DCHECK(state_ == kUninitialized ||
          state_ == kStopped) << "state_ " << state_;
   DCHECK_EQ(pending_read_count_, 0);
   STLDeleteValues(&text_track_state_map_);
 }
 
 void TextRenderer::Initialize(const base::Closure& ended_cb) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(!ended_cb.is_null());
   DCHECK_EQ(kUninitialized, state_)  << "state_ " << state_;
   DCHECK(text_track_state_map_.empty());
   DCHECK_EQ(pending_read_count_, 0);
   DCHECK(pending_eos_set_.empty());
   DCHECK(ended_cb_.is_null());
 
-  weak_this_ = weak_factory_.GetWeakPtr();
   ended_cb_ = ended_cb;
   state_ = kPaused;
 }
 
 void TextRenderer::Play(const base::Closure& callback) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, kPaused) << "state_ " << state_;
 
   for (TextTrackStateMap::iterator itr = text_track_state_map_.begin();
        itr != text_track_state_map_.end(); ++itr) {
@@ skipping 63 matching lines @@
                                  const TextTrackConfig& config) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(state_ != kUninitialized) << "state_ " << state_;
   DCHECK_NE(state_, kStopPending);
   DCHECK_NE(state_, kStopped);
   DCHECK(text_track_state_map_.find(text_stream) ==
          text_track_state_map_.end());
   DCHECK(pending_eos_set_.find(text_stream) ==
          pending_eos_set_.end());
 
-  AddTextTrackDoneCB done_cb = BindToCurrentLoop(
-      base::Bind(&TextRenderer::OnAddTextTrackDone, weak_this_, text_stream));
+  AddTextTrackDoneCB done_cb =
+      BindToCurrentLoop(base::Bind(&TextRenderer::OnAddTextTrackDone,
+                                   weak_factory_.GetWeakPtr(),
+                                   text_stream));
 
   add_text_track_cb_.Run(config, done_cb);
 }
 
 void TextRenderer::RemoveTextStream(DemuxerStream* text_stream) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   TextTrackStateMap::iterator itr = text_track_state_map_.find(text_stream);
   DCHECK(itr != text_track_state_map_.end());
 
@@ skipping 205 matching lines @@
 }
 
 void TextRenderer::Read(
     TextTrackState* state,
     DemuxerStream* text_stream) {
   DCHECK_NE(state->read_state, TextTrackState::kReadPending);
 
   state->read_state = TextTrackState::kReadPending;
   ++pending_read_count_;
 
-  text_stream->Read(base::Bind(&TextRenderer::BufferReady,
-                                weak_this_,
-                                text_stream));
+  text_stream->Read(base::Bind(
+      &TextRenderer::BufferReady, weak_factory_.GetWeakPtr(), text_stream));
 }
 
 TextRenderer::TextTrackState::TextTrackState(scoped_ptr<TextTrack> tt)
     : read_state(kReadIdle),
       text_track(tt.Pass()) {
 }
 
 TextRenderer::TextTrackState::~TextTrackState() {
 }
 
 }  // namespace media