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
|
// 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"
#include "url/gurl.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,
int max_upload_depth,
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,
int max_upload_depth,
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<DomainReliabilityConfig> MakeTestConfig();
scoped_ptr<DomainReliabilityConfig> MakeTestConfigWithOrigin(
const GURL& origin);
DomainReliabilityScheduler::Params MakeTestSchedulerParams();
} // namespace domain_reliability
#endif // COMPONENTS_DOMAIN_RELIABILITY_TEST_UTIL_H_
|
