[Chromecast] Make sure that Stop() stops buffer decryption

chromecast/media/cma/pipeline/av_pipeline_impl.cc

 // Copyright 2014 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 "chromecast/media/cma/pipeline/av_pipeline_impl.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ skipping 29 matching lines @@
     : bytes_decoded_since_last_update_(0),
       decoder_(decoder),
       client_(client),
       state_(kUninitialized),
       buffered_time_(::media::kNoTimestamp),
       playable_buffered_time_(::media::kNoTimestamp),
       enable_feeding_(false),
       pending_read_(false),
       cast_cdm_context_(NULL),
       player_tracker_callback_id_(kNoCallbackId),
-      weak_factory_(this) {
+      weak_factory_(this),
+      decrypt_weak_factory_(this) {
   DCHECK(decoder_);
   decoder_->SetDelegate(this);
   weak_this_ = weak_factory_.GetWeakPtr();
   thread_checker_.DetachFromThread();
 }
 
 AvPipelineImpl::~AvPipelineImpl() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (cast_cdm_context_ && player_tracker_callback_id_ != kNoCallbackId)
@@ skipping 79 matching lines @@
   DCHECK_EQ(state_, kFlushing);
   set_state(kFlushed);
   base::ResetAndReturn(&flush_cb_).Run();
 }
 
 void AvPipelineImpl::Stop() {
   DCHECK(thread_checker_.CalledOnValidThread());
   CMALOG(kLogControl) << __FUNCTION__;
   // Stop feeding the pipeline.
   enable_feeding_ = false;
+  // Drop any pending asynchronous decryption, so any pending
+  // OnBufferDecrypted() callback will not be called. StartPlayingFrom() sets
+  // enable_feeding_ back to true, so if a pending decryption callback from
+  // before Stop() is allowed to complete after StartPlayingFrom() is called
+  // again, it will think everything is fine and try to push a buffer, resulting
+  // in a double push.
+  decrypt_weak_factory_.InvalidateWeakPtrs();
   set_state(kStopped);
 }
 
 void AvPipelineImpl::SetCdm(CastCdmContext* cast_cdm_context) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(cast_cdm_context);
 
   if (cast_cdm_context_ && player_tracker_callback_id_ != kNoCallbackId)
     cast_cdm_context_->UnregisterPlayer(player_tracker_callback_id_);
 
@@ skipping 68 matching lines @@
         client_.wait_for_key_cb.Run();
       return;
     }
 
     DCHECK_NE(decrypt_context->GetKeySystem(), KEY_SYSTEM_NONE);
 
     // If we can get the clear content, decrypt the pending buffer
     if (decrypt_context->CanDecryptToBuffer()) {
       auto buffer = pending_buffer_;
       pending_buffer_ = nullptr;
-      DecryptDecoderBuffer(
-          buffer, decrypt_context.get(),
-          base::Bind(&AvPipelineImpl::OnBufferDecrypted, weak_this_,
-                     base::Passed(&decrypt_context)));
+      DecryptDecoderBuffer(buffer, decrypt_context.get(),
+                           base::Bind(&AvPipelineImpl::OnBufferDecrypted,
+                                      decrypt_weak_factory_.GetWeakPtr(),
+                                      base::Passed(&decrypt_context)));
 
       return;
     }
 
     pending_buffer_->set_decrypt_context(std::move(decrypt_context));
   }
 
   PushPendingBuffer();
 }
 
@@ skipping 145 matching lines @@
       }
     }
 
     // The frame is playable: remove it from the list of non playable frames.
     non_playable_frames_.pop_front();
   }
 }
 
 }  // namespace media
 }  // namespace chromecast