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
155
156
157
158
159
160
161
162
163
164
165
166
167
168
|
// Copyright 2015 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.
#include "net/base/backoff_entry.h"
#include "base/macros.h"
#include "base/time/tick_clock.h"
#include "base/values.h"
#include "net/base/backoff_entry_serializer.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace net {
namespace {
using base::Time;
using base::TimeDelta;
using base::TimeTicks;
BackoffEntry::Policy base_policy = {
0 /* num_errors_to_ignore */,
1000 /* initial_delay_ms */,
2.0 /* multiply_factor */,
0.0 /* jitter_factor */,
20000 /* maximum_backoff_ms */,
2000 /* entry_lifetime_ms */,
false /* always_use_initial_delay */
};
class TestTickClock : public base::TickClock {
public:
TestTickClock() = default;
~TestTickClock() override = default;
TimeTicks NowTicks() const override { return now_ticks_; }
void set_now(TimeTicks now) { now_ticks_ = now; }
private:
TimeTicks now_ticks_;
DISALLOW_COPY_AND_ASSIGN(TestTickClock);
};
TEST(BackoffEntrySerializerTest, SerializeNoFailures) {
Time original_time = Time::Now();
TestTickClock original_ticks;
original_ticks.set_now(TimeTicks::Now());
BackoffEntry original(&base_policy, &original_ticks);
std::unique_ptr<base::Value> serialized =
BackoffEntrySerializer::SerializeToValue(original, original_time);
std::unique_ptr<BackoffEntry> deserialized =
BackoffEntrySerializer::DeserializeFromValue(
*serialized, &base_policy, &original_ticks, original_time);
ASSERT_TRUE(deserialized.get());
EXPECT_EQ(original.failure_count(), deserialized->failure_count());
EXPECT_EQ(original.GetReleaseTime(), deserialized->GetReleaseTime());
}
TEST(BackoffEntrySerializerTest, SerializeTimeOffsets) {
Time original_time = Time::FromJsTime(1430907555111); // May 2015 for realism
TestTickClock original_ticks;
BackoffEntry original(&base_policy, &original_ticks);
// 2 errors.
original.InformOfRequest(false);
original.InformOfRequest(false);
std::unique_ptr<base::Value> serialized =
BackoffEntrySerializer::SerializeToValue(original, original_time);
{
// Test that immediate deserialization round-trips.
std::unique_ptr<BackoffEntry> deserialized =
BackoffEntrySerializer::DeserializeFromValue(
*serialized, &base_policy, &original_ticks, original_time);
ASSERT_TRUE(deserialized.get());
EXPECT_EQ(original.failure_count(), deserialized->failure_count());
EXPECT_EQ(original.GetReleaseTime(), deserialized->GetReleaseTime());
}
{
// Test deserialization when wall clock has advanced but TimeTicks::Now()
// hasn't (e.g. device was rebooted).
Time later_time = original_time + TimeDelta::FromDays(1);
std::unique_ptr<BackoffEntry> deserialized =
BackoffEntrySerializer::DeserializeFromValue(
*serialized, &base_policy, &original_ticks, later_time);
ASSERT_TRUE(deserialized.get());
EXPECT_EQ(original.failure_count(), deserialized->failure_count());
// Remaining backoff duration continues decreasing while device is off.
// Since TimeTicks::Now() has not advanced, the absolute release time ticks
// will decrease accordingly.
EXPECT_GT(original.GetTimeUntilRelease(),
deserialized->GetTimeUntilRelease());
EXPECT_EQ(original.GetReleaseTime() - TimeDelta::FromDays(1),
deserialized->GetReleaseTime());
}
{
// Test deserialization when TimeTicks::Now() has advanced but wall clock
// hasn't (e.g. it's an hour later, but a DST change cancelled that out).
TestTickClock later_ticks;
later_ticks.set_now(TimeTicks() + TimeDelta::FromDays(1));
std::unique_ptr<BackoffEntry> deserialized =
BackoffEntrySerializer::DeserializeFromValue(
*serialized, &base_policy, &later_ticks, original_time);
ASSERT_TRUE(deserialized.get());
EXPECT_EQ(original.failure_count(), deserialized->failure_count());
// According to the wall clock, no time has passed. So remaining backoff
// duration is preserved, hence the absolute release time ticks increases.
// This isn't ideal - by also serializing the current time and time ticks,
// it would be possible to detect that time has passed but the wall clock
// went backwards, and reduce the remaining backoff duration accordingly,
// however the current implementation does not do this as the benefit would
// be somewhat marginal.
EXPECT_EQ(original.GetTimeUntilRelease(),
deserialized->GetTimeUntilRelease());
EXPECT_EQ(original.GetReleaseTime() + TimeDelta::FromDays(1),
deserialized->GetReleaseTime());
}
{
// Test deserialization when both wall clock and TimeTicks::Now() have
// advanced (e.g. it's just later than it used to be).
TestTickClock later_ticks;
later_ticks.set_now(TimeTicks() + TimeDelta::FromDays(1));
Time later_time = original_time + TimeDelta::FromDays(1);
std::unique_ptr<BackoffEntry> deserialized =
BackoffEntrySerializer::DeserializeFromValue(*serialized, &base_policy,
&later_ticks, later_time);
ASSERT_TRUE(deserialized.get());
EXPECT_EQ(original.failure_count(), deserialized->failure_count());
// Since both have advanced by the same amount, the absolute release time
// ticks should be preserved; the remaining backoff duration will have
// decreased of course, since time has passed.
EXPECT_GT(original.GetTimeUntilRelease(),
deserialized->GetTimeUntilRelease());
EXPECT_EQ(original.GetReleaseTime(), deserialized->GetReleaseTime());
}
{
// Test deserialization when wall clock has gone backwards but TimeTicks
// haven't (e.g. the system clock was fast but they fixed it).
EXPECT_LT(TimeDelta::FromSeconds(1), original.GetTimeUntilRelease());
Time earlier_time = original_time - TimeDelta::FromSeconds(1);
std::unique_ptr<BackoffEntry> deserialized =
BackoffEntrySerializer::DeserializeFromValue(
*serialized, &base_policy, &original_ticks, earlier_time);
ASSERT_TRUE(deserialized.get());
EXPECT_EQ(original.failure_count(), deserialized->failure_count());
// If only the absolute wall clock time was serialized, subtracting the
// (decreased) current wall clock time from the serialized wall clock time
// could give very large (incorrect) values for remaining backoff duration.
// But instead the implementation also serializes the remaining backoff
// duration, and doesn't allow the duration to increase beyond it's previous
// value during deserialization. Hence when the wall clock goes backwards
// the remaining backoff duration will be preserved.
EXPECT_EQ(original.GetTimeUntilRelease(),
deserialized->GetTimeUntilRelease());
// Since TimeTicks::Now() hasn't changed, the absolute release time ticks
// will be equal too in this particular case.
EXPECT_EQ(original.GetReleaseTime(), deserialized->GetReleaseTime());
}
}
} // namespace
} // namespace net
|
