CmaMediaPipelineClient to watch media pipeline status

chromecast/media/cma/pipeline/media_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/media_pipeline_impl.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
@@ skipping 48 matching lines @@
       statistics_rolling_counter_(0),
       weak_factory_(this) {
   CMALOG(kLogControl) << __FUNCTION__;
   weak_this_ = weak_factory_.GetWeakPtr();
   thread_checker_.DetachFromThread();
 }
 
 MediaPipelineImpl::~MediaPipelineImpl() {
   CMALOG(kLogControl) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
+
+  weak_factory_.InvalidateWeakPtrs();
+
+  // Since av pipeline still need to access device components in their
+  // destructor, it's important to delete them first.
+  video_pipeline_.reset();
+  audio_pipeline_.reset();
+  media_pipeline_backend_.reset();
+  if (!client_.pipeline_backend_destroyed_cb.is_null())
+    client_.pipeline_backend_destroyed_cb.Run();
 }
 
 void MediaPipelineImpl::Initialize(
     LoadType load_type,
     scoped_ptr<MediaPipelineBackend> media_pipeline_backend) {
   CMALOG(kLogControl) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
   media_pipeline_backend_.reset(media_pipeline_backend.release());
   clock_device_ = media_pipeline_backend_->GetClock();
+  if (!client_.pipeline_backend_created_cb.is_null())
+    client_.pipeline_backend_created_cb.Run();
 
   if (load_type == kLoadTypeURL || load_type == kLoadTypeMediaSource) {
     base::TimeDelta low_threshold(kLowBufferThresholdURL);
     base::TimeDelta high_threshold(kHighBufferThresholdURL);
     if (load_type == kLoadTypeMediaSource) {
       low_threshold = kLowBufferThresholdMediaSource;
       high_threshold = kHighBufferThresholdMediaSource;
     }
     scoped_refptr<BufferingConfig> buffering_config(
         new BufferingConfig(low_threshold, high_threshold));
     buffering_controller_.reset(new BufferingController(
         buffering_config,
         base::Bind(&MediaPipelineImpl::OnBufferingNotification, weak_this_)));
   }
 
   audio_pipeline_.reset(
       new AudioPipelineImpl(media_pipeline_backend_->GetAudio()));
 
   video_pipeline_.reset(
       new VideoPipelineImpl(media_pipeline_backend_->GetVideo()));
 }
 
 void MediaPipelineImpl::SetClient(const MediaPipelineClient& client) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!client.error_cb.is_null());
   DCHECK(!client.time_update_cb.is_null());
   DCHECK(!client.buffering_state_cb.is_null());
+  DCHECK(!client.pipeline_backend_created_cb.is_null());
+  DCHECK(!client.pipeline_backend_destroyed_cb.is_null());
   client_ = client;
 }
 
 void MediaPipelineImpl::SetCdm(int cdm_id) {
   CMALOG(kLogControl) << __FUNCTION__ << " cdm_id=" << cdm_id;
   DCHECK(thread_checker_.CalledOnValidThread());
   NOTIMPLEMENTED();
   // TODO(gunsch): SetCdm(int) is not implemented.
   // One possibility would be a GetCdmByIdCB that's passed in.
 }
@@ skipping 253 matching lines @@
 
 void MediaPipelineImpl::OnError(::media::PipelineStatus error) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_NE(error, ::media::PIPELINE_OK) << "PIPELINE_OK is not an error!";
   if (!client_.error_cb.is_null())
     client_.error_cb.Run(error);
 }
 
 }  // namespace media
 }  // namespace chromecast