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
|
// Copyright 2014 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.
#ifndef COMPONENTS_DOMAIN_RELIABILITY_TEST_UTIL_H_
#define COMPONENTS_DOMAIN_RELIABILITY_TEST_UTIL_H_
#include "base/callback_forward.h"
#include "base/memory/scoped_ptr.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"
namespace net {
class URLRequestStatus;
} // 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::Closure& callback() const { return callback_; }
// Returns whether the callback returned by |callback()| has been called.
bool called() const { return called_; }
private:
void OnCalled();
base::Closure callback_;
bool called_;
};
class MockUploader : public DomainReliabilityUploader {
public:
typedef base::Callback<void(const std::string& report_json,
const GURL& upload_url,
const UploadCallback& upload_callback)>
UploadRequestCallback;
MockUploader(const UploadRequestCallback& callback);
~MockUploader() override;
virtual bool discard_uploads() const;
// DomainReliabilityUploader implementation:
void UploadReport(const std::string& report_json,
const GURL& upload_url,
const UploadCallback& callback) override;
void set_discard_uploads(bool discard_uploads) override;
private:
UploadRequestCallback callback_;
bool discard_uploads_;
};
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() override;
base::TimeTicks NowTicks() override;
scoped_ptr<MockableTime::Timer> CreateTimer() 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, const base::Closure& 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::Closure, 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_;
};
scoped_ptr<const DomainReliabilityConfig> MakeTestConfig();
scoped_ptr<const DomainReliabilityConfig> MakeTestConfigWithDomain(
const std::string& domain);
DomainReliabilityScheduler::Params MakeTestSchedulerParams();
} // namespace domain_reliability
#endif // COMPONENTS_DOMAIN_RELIABILITY_TEST_UTIL_H_
|
