WeakPtr destruction order cleanup: media edition.

content/renderer/media/buffered_data_source.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/renderer/media/buffered_data_source.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "media/base/media_log.h"
@@ skipping 81 matching lines @@
       render_loop_(render_loop),
       stop_signal_received_(false),
       media_has_played_(false),
       preload_(AUTO),
       bitrate_(0),
       playback_rate_(0.0),
       media_log_(media_log),
       downloading_cb_(downloading_cb),
       weak_factory_(this) {
   DCHECK(!downloading_cb_.is_null());
-  weak_this_ = weak_factory_.GetWeakPtr();
 }
 
 BufferedDataSource::~BufferedDataSource() {}
 
 // A factory method to create BufferedResourceLoader using the read parameters.
 // This method can be overridden to inject mock BufferedResourceLoader object
 // for testing purpose.
 BufferedResourceLoader* BufferedDataSource::CreateResourceLoader(
     int64 first_byte_position, int64 last_byte_position) {
   DCHECK(render_loop_->BelongsToCurrentThread());
@@ skipping 39 matching lines @@
     loader_.reset(CreateResourceLoader(0, kPositionNotSpecified));
   } else {
     // For all other protocols, assume they support range request. We fetch
     // the full range of the resource to obtain the instance size because
     // we won't be served HTTP headers.
     loader_.reset(CreateResourceLoader(kPositionNotSpecified,
                                        kPositionNotSpecified));
     assume_fully_buffered_ = true;
   }
 
+  base::WeakPtr<BufferedDataSource> weak_this = weak_factory_.GetWeakPtr();
   loader_->Start(
-      base::Bind(&BufferedDataSource::StartCallback, weak_this_),
-      base::Bind(&BufferedDataSource::LoadingStateChangedCallback, weak_this_),
-      base::Bind(&BufferedDataSource::ProgressCallback, weak_this_),
+      base::Bind(&BufferedDataSource::StartCallback, weak_this),
+      base::Bind(&BufferedDataSource::LoadingStateChangedCallback, weak_this),
+      base::Bind(&BufferedDataSource::ProgressCallback, weak_this),
       frame_);
 }
 
 void BufferedDataSource::SetPreload(Preload preload) {
   DCHECK(render_loop_->BelongsToCurrentThread());
   preload_ = preload;
 }
 
 bool BufferedDataSource::HasSingleOrigin() {
   DCHECK(render_loop_->BelongsToCurrentThread());
@@ skipping 40 matching lines @@
 
 /////////////////////////////////////////////////////////////////////////////
 // media::DataSource implementation.
 void BufferedDataSource::Stop(const base::Closure& closure) {
   {
     base::AutoLock auto_lock(lock_);
     StopInternal_Locked();
   }
   closure.Run();
 
-  render_loop_->PostTask(FROM_HERE,
-      base::Bind(&BufferedDataSource::StopLoader, weak_this_));
+  render_loop_->PostTask(
+      FROM_HERE,
+      base::Bind(&BufferedDataSource::StopLoader, weak_factory_.GetWeakPtr()));
 }
 
 void BufferedDataSource::SetBitrate(int bitrate) {
-  render_loop_->PostTask(FROM_HERE, base::Bind(
-      &BufferedDataSource::SetBitrateTask, weak_this_, bitrate));
+  render_loop_->PostTask(FROM_HERE,
+                         base::Bind(&BufferedDataSource::SetBitrateTask,
+                                    weak_factory_.GetWeakPtr(),
+                                    bitrate));
 }
 
 void BufferedDataSource::Read(
     int64 position, int size, uint8* data,
     const media::DataSource::ReadCB& read_cb) {
   DVLOG(1) << "Read: " << position << " offset, " << size << " bytes";
   DCHECK(!read_cb.is_null());
 
   {
     base::AutoLock auto_lock(lock_);
     DCHECK(!read_op_);
 
     if (stop_signal_received_) {
       read_cb.Run(kReadError);
       return;
     }
 
     read_op_.reset(new ReadOperation(position, size, data, read_cb));
   }
 
-  render_loop_->PostTask(FROM_HERE, base::Bind(
-      &BufferedDataSource::ReadTask, weak_this_));
+  render_loop_->PostTask(
+      FROM_HERE,
+      base::Bind(&BufferedDataSource::ReadTask, weak_factory_.GetWeakPtr()));
 }
 
 bool BufferedDataSource::GetSize(int64* size_out) {
   if (total_bytes_ != kPositionNotSpecified) {
     *size_out = total_bytes_;
     return true;
   }
   *size_out = 0;
   return false;
 }
@@ skipping 54 matching lines @@
     size = read_op_->size();
   }
 
   // First we prepare the intermediate read buffer for BufferedResourceLoader
   // to write to.
   if (size > intermediate_read_buffer_size_) {
     intermediate_read_buffer_.reset(new uint8[size]);
   }
 
   // Perform the actual read with BufferedResourceLoader.
-  loader_->Read(
-      position, size, intermediate_read_buffer_.get(),
-      base::Bind(&BufferedDataSource::ReadCallback, weak_this_));
+  loader_->Read(position,
+                size,
+                intermediate_read_buffer_.get(),
+                base::Bind(&BufferedDataSource::ReadCallback,
+                           weak_factory_.GetWeakPtr()));
 }
 
 
 /////////////////////////////////////////////////////////////////////////////
 // BufferedResourceLoader callback methods.
 void BufferedDataSource::StartCallback(
     BufferedResourceLoader::Status status) {
   DCHECK(render_loop_->BelongsToCurrentThread());
   DCHECK(loader_.get());
 
@@ skipping 82 matching lines @@
     loader_->Stop();
 
     if (status == BufferedResourceLoader::kCacheMiss &&
         read_op_->retries() < kNumCacheMissRetries) {
       read_op_->IncrementRetries();
 
       // Recreate a loader starting from where we last left off until the
       // end of the resource.
       loader_.reset(CreateResourceLoader(
           read_op_->position(), kPositionNotSpecified));
+
+      base::WeakPtr<BufferedDataSource> weak_this = weak_factory_.GetWeakPtr();
       loader_->Start(
-          base::Bind(&BufferedDataSource::PartialReadStartCallback, weak_this_),
+          base::Bind(&BufferedDataSource::PartialReadStartCallback, weak_this),
           base::Bind(&BufferedDataSource::LoadingStateChangedCallback,
-                     weak_this_),
-          base::Bind(&BufferedDataSource::ProgressCallback, weak_this_),
+                     weak_this),
+          base::Bind(&BufferedDataSource::ProgressCallback, weak_this),
           frame_);
       return;
     }
 
     ReadOperation::Run(read_op_.Pass(), kReadError);
     return;
   }
 
   if (bytes_read > 0) {
     memcpy(read_op_->data(), intermediate_read_buffer_.get(), bytes_read);
@@ skipping 102 matching lines @@
     return;
   }
 
   // If media is currently playing or the page indicated preload=auto,
   // use threshold strategy to enable/disable deferring when the buffer
   // is full/depleted.
   loader_->UpdateDeferStrategy(BufferedResourceLoader::kCapacityDefer);
 }
 
 }  // namespace content