| // Copyright 2016 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/base/media_resource_tracker.h" |
| |
| #include "base/callback_helpers.h" |
| #include "base/command_line.h" |
| #include "chromecast/base/bind_to_task_runner.h" |
| #include "chromecast/public/cast_media_shlib.h" |
| #include "chromecast/public/volume_control.h" |
| |
| namespace chromecast { |
| namespace media { |
| |
| MediaResourceTracker::ScopedUsage::ScopedUsage(MediaResourceTracker* tracker) |
| : tracker_(tracker) { |
| DCHECK(tracker_); |
| DCHECK(tracker_->media_task_runner_->BelongsToCurrentThread()); |
| tracker_->IncrementUsageCount(); |
| } |
| |
| MediaResourceTracker::ScopedUsage::~ScopedUsage() { |
| DCHECK(tracker_->media_task_runner_->BelongsToCurrentThread()); |
| tracker_->DecrementUsageCount(); |
| } |
| |
| MediaResourceTracker::MediaResourceTracker( |
| const scoped_refptr<base::SingleThreadTaskRunner>& ui_task_runner, |
| const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner) |
| : media_use_count_(0), |
| media_lib_initialized_(false), |
| delete_on_finalize_(false), |
| ui_task_runner_(ui_task_runner), |
| media_task_runner_(media_task_runner) { |
| DCHECK(ui_task_runner); |
| DCHECK(media_task_runner); |
| DCHECK(ui_task_runner_->BelongsToCurrentThread()); |
| } |
| |
| MediaResourceTracker::~MediaResourceTracker() {} |
| |
| void MediaResourceTracker::InitializeMediaLib() { |
| DCHECK(ui_task_runner_->BelongsToCurrentThread()); |
| media_task_runner_->PostTask( |
| FROM_HERE, |
| base::BindOnce(&MediaResourceTracker::CallInitializeOnMediaThread, |
| base::Unretained(this))); |
| } |
| |
| void MediaResourceTracker::FinalizeMediaLib(base::OnceClosure completion_cb) { |
| DCHECK(ui_task_runner_->BelongsToCurrentThread()); |
| DCHECK(!completion_cb.is_null()); |
| |
| media_task_runner_->PostTask( |
| FROM_HERE, |
| base::BindOnce(&MediaResourceTracker::MaybeCallFinalizeOnMediaThread, |
| base::Unretained(this), std::move(completion_cb))); |
| } |
| |
| void MediaResourceTracker::FinalizeAndDestroy() { |
| DCHECK(ui_task_runner_->BelongsToCurrentThread()); |
| |
| media_task_runner_->PostTask( |
| FROM_HERE, |
| base::BindOnce( |
| &MediaResourceTracker::MaybeCallFinalizeOnMediaThreadAndDeleteSelf, |
| base::Unretained(this))); |
| } |
| |
| void MediaResourceTracker::IncrementUsageCount() { |
| DCHECK(media_task_runner_->BelongsToCurrentThread()); |
| DCHECK(media_lib_initialized_); |
| DCHECK(!finalize_completion_cb_); |
| media_use_count_++; |
| } |
| |
| void MediaResourceTracker::DecrementUsageCount() { |
| DCHECK(media_task_runner_->BelongsToCurrentThread()); |
| media_use_count_--; |
| |
| if (media_use_count_ == 0 && |
| (delete_on_finalize_ || finalize_completion_cb_)) { |
| CallFinalizeOnMediaThread(); |
| } |
| } |
| |
| void MediaResourceTracker::CallInitializeOnMediaThread() { |
| DCHECK(media_task_runner_->BelongsToCurrentThread()); |
| if (media_lib_initialized_) |
| return; |
| |
| DoInitializeMediaLib(); |
| media_lib_initialized_ = true; |
| } |
| |
| void MediaResourceTracker::MaybeCallFinalizeOnMediaThread( |
| base::OnceClosure completion_cb) { |
| DCHECK(media_task_runner_->BelongsToCurrentThread()); |
| DCHECK(!finalize_completion_cb_); |
| |
| finalize_completion_cb_ = |
| BindToTaskRunner(ui_task_runner_, std::move(completion_cb)); |
| if (!media_lib_initialized_) { |
| if (finalize_completion_cb_) |
| std::move(finalize_completion_cb_).Run(); |
| return; |
| } |
| |
| // If there are things using media, we must wait for them to stop. |
| // CallFinalize will get called later from DecrementUsageCount when |
| // usage count drops to 0. |
| if (media_use_count_ == 0) |
| CallFinalizeOnMediaThread(); |
| } |
| |
| void MediaResourceTracker::MaybeCallFinalizeOnMediaThreadAndDeleteSelf() { |
| DCHECK(media_task_runner_->BelongsToCurrentThread()); |
| |
| if (!media_lib_initialized_) { |
| ui_task_runner_->DeleteSoon(FROM_HERE, this); |
| return; |
| } |
| |
| delete_on_finalize_ = true; |
| |
| // If there are things using media, we must wait for them to stop. |
| // CallFinalize will get called later from DecrementUsageCount when |
| // usage count drops to 0. |
| if (media_use_count_ == 0) |
| CallFinalizeOnMediaThread(); |
| } |
| |
| void MediaResourceTracker::CallFinalizeOnMediaThread() { |
| DCHECK(media_task_runner_->BelongsToCurrentThread()); |
| DCHECK_EQ(media_use_count_, 0ul); |
| DCHECK(media_lib_initialized_); |
| |
| DoFinalizeMediaLib(); |
| media_lib_initialized_ = false; |
| |
| if (finalize_completion_cb_) |
| std::move(finalize_completion_cb_).Run(); |
| |
| if (delete_on_finalize_) |
| ui_task_runner_->DeleteSoon(FROM_HERE, this); |
| } |
| |
| void MediaResourceTracker::DoInitializeMediaLib() { |
| base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess(); |
| media::CastMediaShlib::Initialize(cmd_line->argv()); |
| if (VolumeControl::Initialize) { |
| VolumeControl::Initialize(cmd_line->argv()); |
| } |
| } |
| |
| void MediaResourceTracker::DoFinalizeMediaLib() { |
| CastMediaShlib::Finalize(); |
| if (VolumeControl::Finalize) { |
| VolumeControl::Finalize(); |
| } |
| } |
| |
| } // namespace media |
| } // namespace chromecast |