blob: 8323ad04f21d4cdc5498bf9afaa19c3ecd252c80 [file] [log] [blame]
// 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