WeakPtr destruction order cleanup: media edition.

content/renderer/media/crypto/ppapi_decryptor.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/crypto/ppapi_decryptor.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ skipping 55 matching lines @@
       session_error_cb_(session_error_cb),
       render_loop_proxy_(base::MessageLoopProxy::current()),
       weak_ptr_factory_(this) {
   DCHECK(pepper_cdm_wrapper_.get());
   DCHECK(!session_created_cb_.is_null());
   DCHECK(!session_message_cb_.is_null());
   DCHECK(!session_ready_cb_.is_null());
   DCHECK(!session_closed_cb_.is_null());
   DCHECK(!session_error_cb_.is_null());
 
-  weak_this_ = weak_ptr_factory_.GetWeakPtr();
-
+  base::WeakPtr<PpapiDecryptor> weak_this = weak_ptr_factory_.GetWeakPtr();
   CdmDelegate()->Initialize(
       key_system,
-      base::Bind(&PpapiDecryptor::OnSessionCreated, weak_this_),
-      base::Bind(&PpapiDecryptor::OnSessionMessage, weak_this_),
-      base::Bind(&PpapiDecryptor::OnSessionReady, weak_this_),
-      base::Bind(&PpapiDecryptor::OnSessionClosed, weak_this_),
-      base::Bind(&PpapiDecryptor::OnSessionError, weak_this_),
-      base::Bind(&PpapiDecryptor::OnFatalPluginError, weak_this_));
+      base::Bind(&PpapiDecryptor::OnSessionCreated, weak_this),
+      base::Bind(&PpapiDecryptor::OnSessionMessage, weak_this),
+      base::Bind(&PpapiDecryptor::OnSessionReady, weak_this),
+      base::Bind(&PpapiDecryptor::OnSessionClosed, weak_this),
+      base::Bind(&PpapiDecryptor::OnSessionError, weak_this),
+      base::Bind(&PpapiDecryptor::OnFatalPluginError, weak_this));
 }
 
 PpapiDecryptor::~PpapiDecryptor() {
   pepper_cdm_wrapper_.reset();
 }
 
 bool PpapiDecryptor::CreateSession(uint32 session_id,
                                    const std::string& content_type,
                                    const uint8* init_data,
                                    int init_data_length) {
@@ skipping 46 matching lines @@
   }
 }
 
 media::Decryptor* PpapiDecryptor::GetDecryptor() {
   return this;
 }
 
 void PpapiDecryptor::RegisterNewKeyCB(StreamType stream_type,
                                       const NewKeyCB& new_key_cb) {
   if (!render_loop_proxy_->BelongsToCurrentThread()) {
-    render_loop_proxy_->PostTask(FROM_HERE, base::Bind(
-        &PpapiDecryptor::RegisterNewKeyCB, weak_this_, stream_type,
-        new_key_cb));
+    render_loop_proxy_->PostTask(FROM_HERE,
+                                 base::Bind(&PpapiDecryptor::RegisterNewKeyCB,
+                                            weak_ptr_factory_.GetWeakPtr(),
+                                            stream_type,
+                                            new_key_cb));
     return;
   }
 
   DVLOG(3) << __FUNCTION__ << " - stream_type: " << stream_type;
   switch (stream_type) {
     case kAudio:
       new_audio_key_cb_ = new_key_cb;
       break;
     case kVideo:
       new_video_key_cb_ = new_key_cb;
       break;
     default:
       NOTREACHED();
   }
 }
 
 void PpapiDecryptor::Decrypt(
     StreamType stream_type,
     const scoped_refptr<media::DecoderBuffer>& encrypted,
     const DecryptCB& decrypt_cb) {
   if (!render_loop_proxy_->BelongsToCurrentThread()) {
-    render_loop_proxy_->PostTask(FROM_HERE, base::Bind(
-        &PpapiDecryptor::Decrypt, weak_this_,
-        stream_type, encrypted, decrypt_cb));
+    render_loop_proxy_->PostTask(FROM_HERE,
+                                 base::Bind(&PpapiDecryptor::Decrypt,
+                                            weak_ptr_factory_.GetWeakPtr(),
+                                            stream_type,
+                                            encrypted,
+                                            decrypt_cb));
     return;
   }
 
   DVLOG(3) << __FUNCTION__ << " - stream_type: " << stream_type;
   if (!CdmDelegate() ||
       !CdmDelegate()->Decrypt(stream_type, encrypted, decrypt_cb)) {
     decrypt_cb.Run(kError, NULL);
   }
 }
 
 void PpapiDecryptor::CancelDecrypt(StreamType stream_type) {
   if (!render_loop_proxy_->BelongsToCurrentThread()) {
-    render_loop_proxy_->PostTask(FROM_HERE, base::Bind(
-        &PpapiDecryptor::CancelDecrypt, weak_this_, stream_type));
+    render_loop_proxy_->PostTask(FROM_HERE,
+                                 base::Bind(&PpapiDecryptor::CancelDecrypt,
+                                            weak_ptr_factory_.GetWeakPtr(),
+                                            stream_type));
     return;
   }
 
   DVLOG(1) << __FUNCTION__ << " - stream_type: " << stream_type;
   if (CdmDelegate())
     CdmDelegate()->CancelDecrypt(stream_type);
 }
 
 void PpapiDecryptor::InitializeAudioDecoder(
       const media::AudioDecoderConfig& config,
       const DecoderInitCB& init_cb) {
   if (!render_loop_proxy_->BelongsToCurrentThread()) {
-    render_loop_proxy_->PostTask(FROM_HERE, base::Bind(
-        &PpapiDecryptor::InitializeAudioDecoder, weak_this_, config, init_cb));
+    render_loop_proxy_->PostTask(
+        FROM_HERE,
+        base::Bind(&PpapiDecryptor::InitializeAudioDecoder,
+                   weak_ptr_factory_.GetWeakPtr(),
+                   config,
+                   init_cb));
     return;
   }
 
   DVLOG(2) << __FUNCTION__;
   DCHECK(config.is_encrypted());
   DCHECK(config.IsValidConfig());
 
   audio_decoder_init_cb_ = init_cb;
-  if (!CdmDelegate() ||
-      !CdmDelegate()->InitializeAudioDecoder(
-          config,
-          base::Bind(
-              &PpapiDecryptor::OnDecoderInitialized, weak_this_, kAudio))) {
+  if (!CdmDelegate() || !CdmDelegate()->InitializeAudioDecoder(
+                            config,
+                            base::Bind(&PpapiDecryptor::OnDecoderInitialized,
+                                       weak_ptr_factory_.GetWeakPtr(),
+                                       kAudio))) {
     base::ResetAndReturn(&audio_decoder_init_cb_).Run(false);
     return;
   }
 }
 
 void PpapiDecryptor::InitializeVideoDecoder(
     const media::VideoDecoderConfig& config,
     const DecoderInitCB& init_cb) {
   if (!render_loop_proxy_->BelongsToCurrentThread()) {
-    render_loop_proxy_->PostTask(FROM_HERE, base::Bind(
-        &PpapiDecryptor::InitializeVideoDecoder, weak_this_, config, init_cb));
+    render_loop_proxy_->PostTask(
+        FROM_HERE,
+        base::Bind(&PpapiDecryptor::InitializeVideoDecoder,
+                   weak_ptr_factory_.GetWeakPtr(),
+                   config,
+                   init_cb));
     return;
   }
 
   DVLOG(2) << __FUNCTION__;
   DCHECK(config.is_encrypted());
   DCHECK(config.IsValidConfig());
 
   video_decoder_init_cb_ = init_cb;
-  if (!CdmDelegate() ||
-      !CdmDelegate()->InitializeVideoDecoder(
-          config,
-          base::Bind(
-              &PpapiDecryptor::OnDecoderInitialized, weak_this_, kVideo))) {
+  if (!CdmDelegate() || !CdmDelegate()->InitializeVideoDecoder(
+                            config,
+                            base::Bind(&PpapiDecryptor::OnDecoderInitialized,
+                                       weak_ptr_factory_.GetWeakPtr(),
+                                       kVideo))) {
     base::ResetAndReturn(&video_decoder_init_cb_).Run(false);
     return;
   }
 }
 
 void PpapiDecryptor::DecryptAndDecodeAudio(
     const scoped_refptr<media::DecoderBuffer>& encrypted,
     const AudioDecodeCB& audio_decode_cb) {
   if (!render_loop_proxy_->BelongsToCurrentThread()) {
-    render_loop_proxy_->PostTask(FROM_HERE, base::Bind(
-        &PpapiDecryptor::DecryptAndDecodeAudio, weak_this_,
-        encrypted, audio_decode_cb));
+    render_loop_proxy_->PostTask(
+        FROM_HERE,
+        base::Bind(&PpapiDecryptor::DecryptAndDecodeAudio,
+                   weak_ptr_factory_.GetWeakPtr(),
+                   encrypted,
+                   audio_decode_cb));
     return;
   }
 
   DVLOG(3) << __FUNCTION__;
   if (!CdmDelegate() ||
       !CdmDelegate()->DecryptAndDecodeAudio(encrypted, audio_decode_cb)) {
     audio_decode_cb.Run(kError, AudioBuffers());
   }
 }
 
 void PpapiDecryptor::DecryptAndDecodeVideo(
     const scoped_refptr<media::DecoderBuffer>& encrypted,
     const VideoDecodeCB& video_decode_cb) {
   if (!render_loop_proxy_->BelongsToCurrentThread()) {
-    render_loop_proxy_->PostTask(FROM_HERE, base::Bind(
-        &PpapiDecryptor::DecryptAndDecodeVideo, weak_this_,
-        encrypted, video_decode_cb));
+    render_loop_proxy_->PostTask(
+        FROM_HERE,
+        base::Bind(&PpapiDecryptor::DecryptAndDecodeVideo,
+                   weak_ptr_factory_.GetWeakPtr(),
+                   encrypted,
+                   video_decode_cb));
     return;
   }
 
   DVLOG(3) << __FUNCTION__;
   if (!CdmDelegate() ||
       !CdmDelegate()->DecryptAndDecodeVideo(encrypted, video_decode_cb)) {
     video_decode_cb.Run(kError, NULL);
   }
 }
 
 void PpapiDecryptor::ResetDecoder(StreamType stream_type) {
   if (!render_loop_proxy_->BelongsToCurrentThread()) {
-    render_loop_proxy_->PostTask(FROM_HERE, base::Bind(
-        &PpapiDecryptor::ResetDecoder, weak_this_, stream_type));
+    render_loop_proxy_->PostTask(FROM_HERE,
+                                 base::Bind(&PpapiDecryptor::ResetDecoder,
+                                            weak_ptr_factory_.GetWeakPtr(),
+                                            stream_type));
     return;
   }
 
   DVLOG(2) << __FUNCTION__ << " - stream_type: " << stream_type;
   if (CdmDelegate())
     CdmDelegate()->ResetDecoder(stream_type);
 }
 
 void PpapiDecryptor::DeinitializeDecoder(StreamType stream_type) {
   if (!render_loop_proxy_->BelongsToCurrentThread()) {
-    render_loop_proxy_->PostTask(FROM_HERE, base::Bind(
-        &PpapiDecryptor::DeinitializeDecoder, weak_this_, stream_type));
+    render_loop_proxy_->PostTask(
+        FROM_HERE,
+        base::Bind(&PpapiDecryptor::DeinitializeDecoder,
+                   weak_ptr_factory_.GetWeakPtr(),
+                   stream_type));
     return;
   }
 
   DVLOG(2) << __FUNCTION__ << " - stream_type: " << stream_type;
   if (CdmDelegate())
     CdmDelegate()->DeinitializeDecoder(stream_type);
 }
 
 void PpapiDecryptor::ReportFailureToCallPlugin(uint32 session_id) {
   DCHECK(render_loop_proxy_->BelongsToCurrentThread());
@@ skipping 65 matching lines @@
   DCHECK(render_loop_proxy_->BelongsToCurrentThread());
   pepper_cdm_wrapper_.reset();
 }
 
 ContentDecryptorDelegate* PpapiDecryptor::CdmDelegate() {
   DCHECK(render_loop_proxy_->BelongsToCurrentThread());
   return (pepper_cdm_wrapper_) ? pepper_cdm_wrapper_->GetCdmDelegate() : NULL;
 }
 
 }  // namespace content