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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
|
// Copyright 2014 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef COMPONENTS_DOMAIN_RELIABILITY_TEST_UTIL_H_
#define COMPONENTS_DOMAIN_RELIABILITY_TEST_UTIL_H_
#include <memory>
#include "base/functional/callback_forward.h"
#include "base/memory/raw_ptr.h"
#include "base/time/tick_clock.h"
#include "base/time/time.h"
#include "components/domain_reliability/config.h"
#include "components/domain_reliability/scheduler.h"
#include "components/domain_reliability/uploader.h"
#include "components/domain_reliability/util.h"
#include "net/base/host_port_pair.h"
#include "url/gurl.h"
namespace net {
class IsolationInfo;
} // namespace net
namespace domain_reliability {
// A simple test callback that remembers whether it's been called.
class TestCallback {
public:
TestCallback();
~TestCallback();
// Returns a callback that can be called only once.
const base::RepeatingClosure& callback() { return callback_; }
// Returns whether the callback returned by |callback()| has been called.
bool called() const { return called_; }
private:
void OnCalled();
base::RepeatingClosure callback_;
bool called_;
};
class MockUploader : public DomainReliabilityUploader {
public:
typedef base::RepeatingCallback<void(const std::string& report_json,
int max_upload_depth,
const GURL& upload_url,
const net::IsolationInfo& isolation_info,
UploadCallback upload_callback)>
UploadRequestCallback;
explicit MockUploader(UploadRequestCallback callback);
~MockUploader() override;
virtual bool discard_uploads() const;
// DomainReliabilityUploader implementation:
void UploadReport(const std::string& report_json,
int max_upload_depth,
const GURL& upload_url,
const net::IsolationInfo& isolation_info,
UploadCallback callback) override;
void Shutdown() override;
void SetDiscardUploads(bool discard_uploads) override;
int GetDiscardedUploadCount() const override;
private:
UploadRequestCallback callback_;
bool discard_uploads_;
};
class MockTime;
class MockTickClock : public base::TickClock {
public:
explicit MockTickClock(MockTime* mock_time) : mock_time_(mock_time) {}
~MockTickClock() override = default;
// base::TickClock implementation
base::TimeTicks NowTicks() const override;
private:
raw_ptr<MockTime> mock_time_;
};
class MockTime : public MockableTime {
public:
MockTime();
// N.B.: Tasks (and therefore Timers) scheduled to run in the future will
// never be run if MockTime is destroyed before the mock time is advanced
// to their scheduled time.
~MockTime() override;
// MockableTime implementation:
base::Time Now() const override;
base::TimeTicks NowTicks() const override;
std::unique_ptr<MockableTime::Timer> CreateTimer() override;
const base::TickClock* AsTickClock() const override;
// Pretends that |delta| has passed, and runs tasks that would've happened
// during that interval (with |Now()| returning proper values while they
// execute!)
void Advance(base::TimeDelta delta);
// Queues |task| to be run after |delay|. (Lighter-weight than mocking an
// entire message pump.)
void AddTask(base::TimeDelta delay, base::OnceClosure task);
private:
// Key used to store tasks in the task map. Includes the time the task should
// run and a sequence number to disambiguate tasks with the same time.
struct TaskKey {
TaskKey(base::TimeTicks time, int sequence_number)
: time(time),
sequence_number(sequence_number) {}
base::TimeTicks time;
int sequence_number;
};
// Comparator for TaskKey; sorts by time, then by sequence number.
struct TaskKeyCompare {
bool operator() (const TaskKey& lhs, const TaskKey& rhs) const {
return lhs.time < rhs.time ||
(lhs.time == rhs.time &&
lhs.sequence_number < rhs.sequence_number);
}
};
typedef std::map<TaskKey, base::OnceClosure, TaskKeyCompare> TaskMap;
void AdvanceToInternal(base::TimeTicks target_ticks);
int elapsed_sec() { return (now_ticks_ - epoch_ticks_).InSeconds(); }
base::Time now_;
base::TimeTicks now_ticks_;
base::TimeTicks epoch_ticks_;
int task_sequence_number_;
TaskMap tasks_;
MockTickClock tick_clock_;
};
std::unique_ptr<DomainReliabilityConfig> MakeTestConfig();
std::unique_ptr<DomainReliabilityConfig> MakeTestConfigWithOrigin(
const url::Origin& origin);
DomainReliabilityScheduler::Params MakeTestSchedulerParams();
} // namespace domain_reliability
#endif // COMPONENTS_DOMAIN_RELIABILITY_TEST_UTIL_H_
|
