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
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
|
// Copyright (c) 2016 The WebM 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 "test_utils/limited_reader.h"
namespace webm {
LimitedReader::LimitedReader(std::unique_ptr<Reader> impl)
: impl_(std::move(impl)) {}
Status LimitedReader::Read(std::size_t num_to_read, std::uint8_t* buffer,
std::uint64_t* num_actually_read) {
assert(num_to_read > 0);
assert(buffer != nullptr);
assert(num_actually_read != nullptr);
*num_actually_read = 0;
std::size_t expected = num_to_read;
num_to_read = std::min({num_to_read, single_read_limit_, total_read_limit_});
// Handle total_read_skip_limit_ separately since std::size_t can be
// smaller than std::uint64_t.
if (num_to_read > total_read_skip_limit_) {
num_to_read = static_cast<std::size_t>(total_read_skip_limit_);
}
if (num_to_read == 0) {
return return_status_when_blocked_;
}
Status status = impl_->Read(num_to_read, buffer, num_actually_read);
assert(*num_actually_read <= num_to_read);
if (status.code == Status::kOkCompleted && *num_actually_read < expected) {
status.code = Status::kOkPartial;
}
if (total_read_limit_ != std::numeric_limits<std::size_t>::max()) {
total_read_limit_ -= static_cast<std::size_t>(*num_actually_read);
}
if (total_read_skip_limit_ != std::numeric_limits<std::uint64_t>::max()) {
total_read_skip_limit_ -= *num_actually_read;
}
return status;
}
Status LimitedReader::Skip(std::uint64_t num_to_skip,
std::uint64_t* num_actually_skipped) {
assert(num_to_skip > 0);
assert(num_actually_skipped != nullptr);
*num_actually_skipped = 0;
std::uint64_t expected = num_to_skip;
num_to_skip = std::min({num_to_skip, single_skip_limit_, total_skip_limit_,
total_read_skip_limit_});
if (num_to_skip == 0) {
return return_status_when_blocked_;
}
Status status = impl_->Skip(num_to_skip, num_actually_skipped);
assert(*num_actually_skipped <= num_to_skip);
if (status.code == Status::kOkCompleted && *num_actually_skipped < expected) {
status.code = Status::kOkPartial;
}
if (total_skip_limit_ != std::numeric_limits<std::uint64_t>::max()) {
total_skip_limit_ -= *num_actually_skipped;
}
if (total_read_skip_limit_ != std::numeric_limits<std::uint64_t>::max()) {
total_read_skip_limit_ -= *num_actually_skipped;
}
return status;
}
std::uint64_t LimitedReader::Position() const { return impl_->Position(); }
void LimitedReader::set_return_status_when_blocked(Status status) {
return_status_when_blocked_ = status;
}
void LimitedReader::set_single_read_limit(std::size_t max_num_bytes) {
single_read_limit_ = max_num_bytes;
}
void LimitedReader::set_single_skip_limit(std::uint64_t max_num_bytes) {
single_skip_limit_ = max_num_bytes;
}
void LimitedReader::set_total_read_limit(std::size_t max_num_bytes) {
total_read_limit_ = max_num_bytes;
}
void LimitedReader::set_total_skip_limit(std::uint64_t max_num_bytes) {
total_skip_limit_ = max_num_bytes;
}
void LimitedReader::set_total_read_skip_limit(std::uint64_t max_num_bytes) {
total_read_skip_limit_ = max_num_bytes;
}
} // namespace webm
|
