OLD | NEW |
1 // Copyright 2017 The Chromium Authors. All rights reserved. | 1 // Copyright 2017 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "content/browser/loader/upload_progress_tracker.h" | 5 #include "content/browser/loader/upload_progress_tracker.h" |
6 | 6 |
7 #include "base/bind.h" | 7 #include "base/bind.h" |
8 #include "base/location.h" | 8 #include "base/location.h" |
9 #include "base/macros.h" | 9 #include "base/macros.h" |
10 #include "base/memory/ref_counted.h" | 10 #include "base/memory/ref_counted.h" |
11 #include "base/single_thread_task_runner.h" | 11 #include "base/single_thread_task_runner.h" |
12 #include "base/test/test_simple_task_runner.h" | 12 #include "base/test/test_mock_time_task_runner.h" |
| 13 #include "base/threading/thread_task_runner_handle.h" |
13 #include "net/base/upload_progress.h" | 14 #include "net/base/upload_progress.h" |
14 #include "testing/gtest/include/gtest/gtest.h" | 15 #include "testing/gtest/include/gtest/gtest.h" |
15 | 16 |
16 namespace content { | 17 namespace content { |
17 namespace { | 18 namespace { |
18 | 19 |
19 class TestingUploadProgressTracker : public UploadProgressTracker { | 20 class TestingUploadProgressTracker : public UploadProgressTracker { |
20 public: | 21 public: |
21 TestingUploadProgressTracker( | 22 TestingUploadProgressTracker( |
22 const tracked_objects::Location& location, | 23 const tracked_objects::Location& location, |
(...skipping 24 matching lines...) Expand all Loading... |
47 net::UploadProgress upload_progress_; | 48 net::UploadProgress upload_progress_; |
48 | 49 |
49 DISALLOW_COPY_AND_ASSIGN(TestingUploadProgressTracker); | 50 DISALLOW_COPY_AND_ASSIGN(TestingUploadProgressTracker); |
50 }; | 51 }; |
51 | 52 |
52 } // namespace | 53 } // namespace |
53 | 54 |
54 class UploadProgressTrackerTest : public ::testing::Test { | 55 class UploadProgressTrackerTest : public ::testing::Test { |
55 public: | 56 public: |
56 UploadProgressTrackerTest() | 57 UploadProgressTrackerTest() |
57 : task_runner_(new base::TestSimpleTaskRunner), | 58 : task_runner_handle_(mock_task_runner_), |
58 upload_progress_tracker_( | 59 upload_progress_tracker_( |
59 FROM_HERE, | 60 FROM_HERE, |
60 base::BindRepeating( | 61 base::BindRepeating( |
61 &UploadProgressTrackerTest::OnUploadProgressReported, | 62 &UploadProgressTrackerTest::OnUploadProgressReported, |
62 base::Unretained(this)), | 63 base::Unretained(this)), |
63 task_runner_) {} | 64 mock_task_runner_) {} |
64 | 65 |
65 private: | 66 private: |
66 void OnUploadProgressReported(const net::UploadProgress& progress) { | 67 void OnUploadProgressReported(const net::UploadProgress& progress) { |
67 ++report_count_; | 68 ++report_count_; |
68 reported_position_ = progress.position(); | 69 reported_position_ = progress.position(); |
69 reported_total_size_ = progress.size(); | 70 reported_total_size_ = progress.size(); |
70 } | 71 } |
71 | 72 |
72 protected: | 73 protected: |
73 int report_count_ = 0; | 74 int report_count_ = 0; |
74 int64_t reported_position_ = 0; | 75 int64_t reported_position_ = 0; |
75 int64_t reported_total_size_ = 0; | 76 int64_t reported_total_size_ = 0; |
76 | 77 |
77 scoped_refptr<base::TestSimpleTaskRunner> task_runner_; | 78 // Mocks the current thread's task runner which will also be used as the |
| 79 // UploadProgressTracker's task runner. |
| 80 scoped_refptr<base::TestMockTimeTaskRunner> mock_task_runner_ = |
| 81 new base::TestMockTimeTaskRunner; |
| 82 base::ThreadTaskRunnerHandle task_runner_handle_; |
| 83 |
78 TestingUploadProgressTracker upload_progress_tracker_; | 84 TestingUploadProgressTracker upload_progress_tracker_; |
79 | 85 |
80 DISALLOW_COPY_AND_ASSIGN(UploadProgressTrackerTest); | 86 DISALLOW_COPY_AND_ASSIGN(UploadProgressTrackerTest); |
81 }; | 87 }; |
82 | 88 |
83 TEST_F(UploadProgressTrackerTest, NoACK) { | 89 TEST_F(UploadProgressTrackerTest, NoACK) { |
84 upload_progress_tracker_.set_upload_progress(net::UploadProgress(500, 1000)); | 90 upload_progress_tracker_.set_upload_progress(net::UploadProgress(500, 1000)); |
85 | 91 |
86 // The first timer task calls ReportUploadProgress. | 92 // The first timer task calls ReportUploadProgress. |
87 EXPECT_EQ(0, report_count_); | 93 EXPECT_EQ(0, report_count_); |
88 task_runner_->RunPendingTasks(); | 94 mock_task_runner_->FastForwardBy( |
| 95 UploadProgressTracker::GetUploadProgressIntervalForTesting()); |
89 EXPECT_EQ(1, report_count_); | 96 EXPECT_EQ(1, report_count_); |
90 EXPECT_EQ(500, reported_position_); | 97 EXPECT_EQ(500, reported_position_); |
91 EXPECT_EQ(1000, reported_total_size_); | 98 EXPECT_EQ(1000, reported_total_size_); |
92 | 99 |
93 upload_progress_tracker_.set_upload_progress(net::UploadProgress(750, 1000)); | 100 upload_progress_tracker_.set_upload_progress(net::UploadProgress(750, 1000)); |
94 | 101 |
95 // The second timer task does nothing, since the first report didn't send the | 102 // The second timer task does nothing, since the first report didn't send the |
96 // ACK. | 103 // ACK. |
97 task_runner_->RunPendingTasks(); | 104 mock_task_runner_->FastForwardBy( |
| 105 UploadProgressTracker::GetUploadProgressIntervalForTesting()); |
98 EXPECT_EQ(1, report_count_); | 106 EXPECT_EQ(1, report_count_); |
99 } | 107 } |
100 | 108 |
101 TEST_F(UploadProgressTrackerTest, NoUpload) { | 109 TEST_F(UploadProgressTrackerTest, NoUpload) { |
102 upload_progress_tracker_.set_upload_progress(net::UploadProgress(0, 0)); | 110 upload_progress_tracker_.set_upload_progress(net::UploadProgress(0, 0)); |
103 | 111 |
104 // UploadProgressTracker does nothing on the empty upload content. | 112 // UploadProgressTracker does nothing on the empty upload content. |
105 EXPECT_EQ(0, report_count_); | 113 EXPECT_EQ(0, report_count_); |
106 task_runner_->RunPendingTasks(); | 114 mock_task_runner_->FastForwardBy( |
| 115 UploadProgressTracker::GetUploadProgressIntervalForTesting()); |
107 EXPECT_EQ(0, report_count_); | 116 EXPECT_EQ(0, report_count_); |
108 } | 117 } |
109 | 118 |
110 TEST_F(UploadProgressTrackerTest, NoProgress) { | 119 TEST_F(UploadProgressTrackerTest, NoProgress) { |
111 upload_progress_tracker_.set_upload_progress(net::UploadProgress(500, 1000)); | 120 upload_progress_tracker_.set_upload_progress(net::UploadProgress(500, 1000)); |
112 | 121 |
113 // The first timer task calls ReportUploadProgress. | 122 // The first timer task calls ReportUploadProgress. |
114 EXPECT_EQ(0, report_count_); | 123 EXPECT_EQ(0, report_count_); |
115 task_runner_->RunPendingTasks(); | 124 mock_task_runner_->FastForwardBy( |
| 125 UploadProgressTracker::GetUploadProgressIntervalForTesting()); |
116 EXPECT_EQ(1, report_count_); | 126 EXPECT_EQ(1, report_count_); |
117 EXPECT_EQ(500, reported_position_); | 127 EXPECT_EQ(500, reported_position_); |
118 EXPECT_EQ(1000, reported_total_size_); | 128 EXPECT_EQ(1000, reported_total_size_); |
119 | 129 |
120 upload_progress_tracker_.OnAckReceived(); | 130 upload_progress_tracker_.OnAckReceived(); |
121 | 131 |
122 // The second time doesn't call ReportUploadProgress since there's no | 132 // The second time doesn't call ReportUploadProgress since there's no |
123 // progress. | 133 // progress. |
124 EXPECT_EQ(1, report_count_); | 134 EXPECT_EQ(1, report_count_); |
125 task_runner_->RunPendingTasks(); | 135 mock_task_runner_->FastForwardBy( |
| 136 UploadProgressTracker::GetUploadProgressIntervalForTesting()); |
126 EXPECT_EQ(1, report_count_); | 137 EXPECT_EQ(1, report_count_); |
127 } | 138 } |
128 | 139 |
129 TEST_F(UploadProgressTrackerTest, Finished) { | 140 TEST_F(UploadProgressTrackerTest, Finished) { |
130 upload_progress_tracker_.set_upload_progress(net::UploadProgress(999, 1000)); | 141 upload_progress_tracker_.set_upload_progress(net::UploadProgress(999, 1000)); |
131 | 142 |
132 // The first timer task calls ReportUploadProgress. | 143 // The first timer task calls ReportUploadProgress. |
133 EXPECT_EQ(0, report_count_); | 144 EXPECT_EQ(0, report_count_); |
134 task_runner_->RunPendingTasks(); | 145 mock_task_runner_->FastForwardBy( |
| 146 UploadProgressTracker::GetUploadProgressIntervalForTesting()); |
135 EXPECT_EQ(1, report_count_); | 147 EXPECT_EQ(1, report_count_); |
136 EXPECT_EQ(999, reported_position_); | 148 EXPECT_EQ(999, reported_position_); |
137 EXPECT_EQ(1000, reported_total_size_); | 149 EXPECT_EQ(1000, reported_total_size_); |
138 | 150 |
139 upload_progress_tracker_.OnAckReceived(); | 151 upload_progress_tracker_.OnAckReceived(); |
140 upload_progress_tracker_.set_upload_progress(net::UploadProgress(1000, 1000)); | 152 upload_progress_tracker_.set_upload_progress(net::UploadProgress(1000, 1000)); |
141 | 153 |
142 // The second timer task calls ReportUploadProgress for reporting the | 154 // The second timer task calls ReportUploadProgress for reporting the |
143 // completion. | 155 // completion. |
144 EXPECT_EQ(1, report_count_); | 156 EXPECT_EQ(1, report_count_); |
145 task_runner_->RunPendingTasks(); | 157 mock_task_runner_->FastForwardBy( |
| 158 UploadProgressTracker::GetUploadProgressIntervalForTesting()); |
146 EXPECT_EQ(2, report_count_); | 159 EXPECT_EQ(2, report_count_); |
147 EXPECT_EQ(1000, reported_position_); | 160 EXPECT_EQ(1000, reported_position_); |
148 EXPECT_EQ(1000, reported_total_size_); | 161 EXPECT_EQ(1000, reported_total_size_); |
149 } | 162 } |
150 | 163 |
151 TEST_F(UploadProgressTrackerTest, Progress) { | 164 TEST_F(UploadProgressTrackerTest, Progress) { |
152 upload_progress_tracker_.set_upload_progress(net::UploadProgress(500, 1000)); | 165 upload_progress_tracker_.set_upload_progress(net::UploadProgress(500, 1000)); |
153 | 166 |
154 // The first timer task calls ReportUploadProgress. | 167 // The first timer task calls ReportUploadProgress. |
155 EXPECT_EQ(0, report_count_); | 168 EXPECT_EQ(0, report_count_); |
156 task_runner_->RunPendingTasks(); | 169 mock_task_runner_->FastForwardBy( |
| 170 UploadProgressTracker::GetUploadProgressIntervalForTesting()); |
157 EXPECT_EQ(1, report_count_); | 171 EXPECT_EQ(1, report_count_); |
158 EXPECT_EQ(500, reported_position_); | 172 EXPECT_EQ(500, reported_position_); |
159 EXPECT_EQ(1000, reported_total_size_); | 173 EXPECT_EQ(1000, reported_total_size_); |
160 | 174 |
161 upload_progress_tracker_.OnAckReceived(); | 175 upload_progress_tracker_.OnAckReceived(); |
162 upload_progress_tracker_.set_upload_progress(net::UploadProgress(750, 1000)); | 176 upload_progress_tracker_.set_upload_progress(net::UploadProgress(750, 1000)); |
163 | 177 |
164 // The second timer task calls ReportUploadProgress since the progress is | 178 // The second timer task calls ReportUploadProgress since the progress is |
165 // big enough to report. | 179 // big enough to report. |
166 EXPECT_EQ(1, report_count_); | 180 EXPECT_EQ(1, report_count_); |
167 task_runner_->RunPendingTasks(); | 181 mock_task_runner_->FastForwardBy( |
| 182 UploadProgressTracker::GetUploadProgressIntervalForTesting()); |
168 EXPECT_EQ(2, report_count_); | 183 EXPECT_EQ(2, report_count_); |
169 EXPECT_EQ(750, reported_position_); | 184 EXPECT_EQ(750, reported_position_); |
170 EXPECT_EQ(1000, reported_total_size_); | 185 EXPECT_EQ(1000, reported_total_size_); |
171 } | 186 } |
172 | 187 |
173 TEST_F(UploadProgressTrackerTest, TimePassed) { | 188 TEST_F(UploadProgressTrackerTest, TimePassed) { |
174 upload_progress_tracker_.set_upload_progress(net::UploadProgress(500, 1000)); | 189 upload_progress_tracker_.set_upload_progress(net::UploadProgress(500, 1000)); |
175 | 190 |
176 // The first timer task calls ReportUploadProgress. | 191 // The first timer task calls ReportUploadProgress. |
177 EXPECT_EQ(0, report_count_); | 192 EXPECT_EQ(0, report_count_); |
178 task_runner_->RunPendingTasks(); | 193 mock_task_runner_->FastForwardBy( |
| 194 UploadProgressTracker::GetUploadProgressIntervalForTesting()); |
179 EXPECT_EQ(1, report_count_); | 195 EXPECT_EQ(1, report_count_); |
180 EXPECT_EQ(500, reported_position_); | 196 EXPECT_EQ(500, reported_position_); |
181 EXPECT_EQ(1000, reported_total_size_); | 197 EXPECT_EQ(1000, reported_total_size_); |
182 | 198 |
183 upload_progress_tracker_.OnAckReceived(); | 199 upload_progress_tracker_.OnAckReceived(); |
184 upload_progress_tracker_.set_upload_progress(net::UploadProgress(501, 1000)); | 200 upload_progress_tracker_.set_upload_progress(net::UploadProgress(501, 1000)); |
185 | 201 |
186 // The second timer task doesn't call ReportUploadProgress since the progress | 202 // The second timer task doesn't call ReportUploadProgress since the progress |
187 // is too small to report it. | 203 // is too small to report it. |
188 EXPECT_EQ(1, report_count_); | 204 EXPECT_EQ(1, report_count_); |
189 task_runner_->RunPendingTasks(); | 205 mock_task_runner_->FastForwardBy( |
| 206 UploadProgressTracker::GetUploadProgressIntervalForTesting()); |
190 EXPECT_EQ(1, report_count_); | 207 EXPECT_EQ(1, report_count_); |
191 | 208 |
192 upload_progress_tracker_.set_current_time(base::TimeTicks::Now() + | 209 upload_progress_tracker_.set_current_time(base::TimeTicks::Now() + |
193 base::TimeDelta::FromSeconds(5)); | 210 base::TimeDelta::FromSeconds(5)); |
194 | 211 |
195 // The third timer task calls ReportUploadProgress since it's been long time | 212 // The third timer task calls ReportUploadProgress since it's been long time |
196 // from the last report. | 213 // from the last report. |
197 EXPECT_EQ(1, report_count_); | 214 EXPECT_EQ(1, report_count_); |
198 task_runner_->RunPendingTasks(); | 215 mock_task_runner_->FastForwardBy( |
| 216 UploadProgressTracker::GetUploadProgressIntervalForTesting()); |
199 EXPECT_EQ(2, report_count_); | 217 EXPECT_EQ(2, report_count_); |
200 EXPECT_EQ(501, reported_position_); | 218 EXPECT_EQ(501, reported_position_); |
201 EXPECT_EQ(1000, reported_total_size_); | 219 EXPECT_EQ(1000, reported_total_size_); |
202 } | 220 } |
203 | 221 |
204 TEST_F(UploadProgressTrackerTest, Rewound) { | 222 TEST_F(UploadProgressTrackerTest, Rewound) { |
205 upload_progress_tracker_.set_upload_progress(net::UploadProgress(500, 1000)); | 223 upload_progress_tracker_.set_upload_progress(net::UploadProgress(500, 1000)); |
206 | 224 |
207 // The first timer task calls ReportUploadProgress. | 225 // The first timer task calls ReportUploadProgress. |
208 EXPECT_EQ(0, report_count_); | 226 EXPECT_EQ(0, report_count_); |
209 task_runner_->RunPendingTasks(); | 227 mock_task_runner_->FastForwardBy( |
| 228 UploadProgressTracker::GetUploadProgressIntervalForTesting()); |
210 EXPECT_EQ(1, report_count_); | 229 EXPECT_EQ(1, report_count_); |
211 EXPECT_EQ(500, reported_position_); | 230 EXPECT_EQ(500, reported_position_); |
212 EXPECT_EQ(1000, reported_total_size_); | 231 EXPECT_EQ(1000, reported_total_size_); |
213 | 232 |
214 upload_progress_tracker_.OnAckReceived(); | 233 upload_progress_tracker_.OnAckReceived(); |
215 upload_progress_tracker_.set_upload_progress(net::UploadProgress(250, 1000)); | 234 upload_progress_tracker_.set_upload_progress(net::UploadProgress(250, 1000)); |
216 | 235 |
217 // The second timer task doesn't call ReportUploadProgress since the progress | 236 // The second timer task doesn't call ReportUploadProgress since the progress |
218 // was rewound. | 237 // was rewound. |
219 EXPECT_EQ(1, report_count_); | 238 EXPECT_EQ(1, report_count_); |
220 task_runner_->RunPendingTasks(); | 239 mock_task_runner_->FastForwardBy( |
| 240 UploadProgressTracker::GetUploadProgressIntervalForTesting()); |
221 EXPECT_EQ(1, report_count_); | 241 EXPECT_EQ(1, report_count_); |
222 | 242 |
223 upload_progress_tracker_.set_current_time(base::TimeTicks::Now() + | 243 upload_progress_tracker_.set_current_time(base::TimeTicks::Now() + |
224 base::TimeDelta::FromSeconds(5)); | 244 base::TimeDelta::FromSeconds(5)); |
225 | 245 |
226 // Even after a good amount of time passed, the rewound progress should not be | 246 // Even after a good amount of time passed, the rewound progress should not be |
227 // reported. | 247 // reported. |
228 EXPECT_EQ(1, report_count_); | 248 EXPECT_EQ(1, report_count_); |
229 task_runner_->RunPendingTasks(); | 249 mock_task_runner_->FastForwardBy( |
| 250 UploadProgressTracker::GetUploadProgressIntervalForTesting()); |
230 EXPECT_EQ(1, report_count_); | 251 EXPECT_EQ(1, report_count_); |
231 } | 252 } |
232 | 253 |
233 TEST_F(UploadProgressTrackerTest, Completed) { | 254 TEST_F(UploadProgressTrackerTest, Completed) { |
234 upload_progress_tracker_.set_upload_progress(net::UploadProgress(500, 1000)); | 255 upload_progress_tracker_.set_upload_progress(net::UploadProgress(500, 1000)); |
235 | 256 |
236 // The first timer task calls ReportUploadProgress. | 257 // The first timer task calls ReportUploadProgress. |
237 EXPECT_EQ(0, report_count_); | 258 EXPECT_EQ(0, report_count_); |
238 task_runner_->RunPendingTasks(); | 259 mock_task_runner_->FastForwardBy( |
| 260 UploadProgressTracker::GetUploadProgressIntervalForTesting()); |
239 EXPECT_EQ(1, report_count_); | 261 EXPECT_EQ(1, report_count_); |
240 EXPECT_EQ(500, reported_position_); | 262 EXPECT_EQ(500, reported_position_); |
241 EXPECT_EQ(1000, reported_total_size_); | 263 EXPECT_EQ(1000, reported_total_size_); |
242 | 264 |
243 upload_progress_tracker_.set_upload_progress(net::UploadProgress(1000, 1000)); | 265 upload_progress_tracker_.set_upload_progress(net::UploadProgress(1000, 1000)); |
244 | 266 |
245 // OnUploadCompleted runs ReportUploadProgress even without Ack nor timer. | 267 // OnUploadCompleted runs ReportUploadProgress even without Ack nor timer. |
246 upload_progress_tracker_.OnUploadCompleted(); | 268 upload_progress_tracker_.OnUploadCompleted(); |
247 EXPECT_EQ(2, report_count_); | 269 EXPECT_EQ(2, report_count_); |
248 EXPECT_EQ(1000, reported_position_); | 270 EXPECT_EQ(1000, reported_position_); |
249 EXPECT_EQ(1000, reported_total_size_); | 271 EXPECT_EQ(1000, reported_total_size_); |
250 | 272 |
251 task_runner_->RunPendingTasks(); | 273 mock_task_runner_->FastForwardBy( |
| 274 UploadProgressTracker::GetUploadProgressIntervalForTesting()); |
252 EXPECT_EQ(2, report_count_); | 275 EXPECT_EQ(2, report_count_); |
253 EXPECT_FALSE(task_runner_->HasPendingTask()); | 276 EXPECT_FALSE(mock_task_runner_->HasPendingTask()); |
254 } | 277 } |
255 | 278 |
256 } // namespace context | 279 } // namespace context |
OLD | NEW |