blob: 4398bb16c1fc7a3ba9019b211b7e8e313c9b9af0 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
|
/*
* Copyright 2019 The WebRTC Project Authors. All rights reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include "rtc_base/operations_chain.h"
#include "api/make_ref_counted.h"
#include "rtc_base/checks.h"
namespace rtc {
OperationsChain::CallbackHandle::CallbackHandle(
scoped_refptr<OperationsChain> operations_chain)
: operations_chain_(std::move(operations_chain)) {}
OperationsChain::CallbackHandle::~CallbackHandle() {
#if RTC_DCHECK_IS_ON
RTC_DCHECK(has_run_);
#endif
}
void OperationsChain::CallbackHandle::OnOperationComplete() {
#if RTC_DCHECK_IS_ON
RTC_DCHECK(!has_run_);
has_run_ = true;
#endif // RTC_DCHECK_IS_ON
operations_chain_->OnOperationComplete();
// We have no reason to keep the `operations_chain_` alive through reference
// counting anymore.
operations_chain_ = nullptr;
}
// static
scoped_refptr<OperationsChain> OperationsChain::Create() {
// Explicit new, to access private constructor.
return rtc::scoped_refptr<OperationsChain>(new OperationsChain());
}
OperationsChain::OperationsChain() {
RTC_DCHECK_RUN_ON(&sequence_checker_);
}
OperationsChain::~OperationsChain() {
// Operations keep the chain alive through reference counting so this should
// not be possible. The fact that the chain is empty makes it safe to
// destroy the OperationsChain on any sequence.
RTC_DCHECK(chained_operations_.empty());
}
void OperationsChain::SetOnChainEmptyCallback(
std::function<void()> on_chain_empty_callback) {
RTC_DCHECK_RUN_ON(&sequence_checker_);
on_chain_empty_callback_ = std::move(on_chain_empty_callback);
}
bool OperationsChain::IsEmpty() const {
RTC_DCHECK_RUN_ON(&sequence_checker_);
return chained_operations_.empty();
}
std::function<void()> OperationsChain::CreateOperationsChainCallback() {
return [handle = rtc::make_ref_counted<CallbackHandle>(
rtc::scoped_refptr<OperationsChain>(this))]() {
handle->OnOperationComplete();
};
}
void OperationsChain::OnOperationComplete() {
RTC_DCHECK_RUN_ON(&sequence_checker_);
// The front element is the operation that just completed, remove it.
RTC_DCHECK(!chained_operations_.empty());
chained_operations_.pop();
// If there are any other operations chained, execute the next one. Otherwise,
// invoke the "on chain empty" callback if it has been set.
if (!chained_operations_.empty()) {
chained_operations_.front()->Run();
} else if (on_chain_empty_callback_.has_value()) {
on_chain_empty_callback_.value()();
}
}
} // namespace rtc
|
