OLD | NEW |
---|---|
(Empty) | |
1 // Copyright (c) 2016 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #include "pdf/document_loader.h" | |
6 | |
7 #include <memory> | |
8 #include <string> | |
9 | |
10 #include "pdf/url_loader_wrapper.h" | |
11 #include "testing/gmock/include/gmock/gmock.h" | |
12 #include "testing/gtest/include/gtest/gtest.h" | |
13 #include "ui/gfx/range/range.h" | |
14 | |
15 using ::testing::_; | |
16 using ::testing::Mock; | |
17 using ::testing::Sequence; | |
18 using ::testing::NiceMock; | |
19 using ::testing::Return; | |
20 | |
21 namespace chrome_pdf { | |
22 | |
23 namespace { | |
24 class TestURLLoader : public URLLoaderWrapper { | |
25 public: | |
26 struct LoaderData { | |
27 int content_length = -1; | |
28 bool accept_ranges_bytes = false; | |
29 bool content_encoded = false; | |
30 std::string content_type; | |
31 std::string content_disposition; | |
32 std::string multipart_boundary; | |
33 gfx::Range byte_range = gfx::Range::InvalidRange(); | |
34 bool is_multipart = false; | |
35 int status_code = 0; | |
36 bool closed = true; | |
37 gfx::Range open_byte_range = gfx::Range::InvalidRange(); | |
38 | |
39 bool IsWaitRead() const { return wait_read_; } | |
40 bool IsWaitOpen() const { return wait_open_; } | |
41 char* buffer() const { return buffer_; } | |
42 int buffer_size() const { return buffer_size_; } | |
43 | |
44 void SetReadCallback(const pp::CompletionCallback& read_callback, | |
45 char* buffer, | |
46 int buffer_size) { | |
47 wait_read_ = true; | |
48 did_read_callback_ = read_callback; | |
49 buffer_ = buffer; | |
50 buffer_size_ = buffer_size; | |
51 } | |
52 | |
53 void SetOpenCallback(const pp::CompletionCallback& open_callback, | |
54 gfx::Range req_byte_range) { | |
55 wait_open_ = true; | |
56 did_open_callback_ = open_callback; | |
57 open_byte_range = req_byte_range; | |
58 } | |
59 | |
60 void CallOpenCallback(int result) { | |
61 PP_DCHECK(wait_open_); | |
62 wait_open_ = false; | |
63 did_open_callback_.Run(result); | |
64 } | |
65 | |
66 void CallReadCallback(int result) { | |
67 PP_DCHECK(wait_read_); | |
68 wait_read_ = false; | |
69 did_read_callback_.Run(result); | |
70 } | |
71 | |
72 private: | |
73 bool wait_open_ = false; | |
74 pp::CompletionCallback did_open_callback_; | |
75 bool wait_read_ = false; | |
76 pp::CompletionCallback did_read_callback_; | |
77 char* buffer_ = nullptr; | |
78 int buffer_size_ = 0; | |
79 }; | |
80 | |
81 explicit TestURLLoader(LoaderData* data) : data_(data) { | |
82 data_->closed = false; | |
83 } | |
84 | |
85 ~TestURLLoader() override { Close(); } | |
86 | |
87 int GetContentLength() const override { return data_->content_length; } | |
88 | |
89 bool IsAcceptRangesBytes() const override { | |
90 return data_->accept_ranges_bytes; | |
91 } | |
92 | |
93 bool IsContentEncoded() const override { return data_->content_encoded; } | |
94 | |
95 std::string GetContentType() const override { return data_->content_type; } | |
96 | |
97 std::string GetContentDisposition() const override { | |
98 return data_->content_disposition; | |
99 } | |
100 | |
101 int GetStatusCode() const override { return data_->status_code; } | |
102 | |
103 bool IsMultipart() const override { return data_->is_multipart; } | |
104 | |
105 bool GetByteRange(int* start, int* end) const override { | |
106 *start = data_->byte_range.start(); | |
107 *end = data_->byte_range.end(); | |
108 return data_->byte_range.IsValid(); | |
109 } | |
110 | |
111 void Close() override { data_->closed = true; } | |
112 | |
113 void OpenRange(const std::string& url, | |
114 const std::string& referrer_url, | |
115 uint32_t position, | |
116 uint32_t size, | |
117 const pp::CompletionCallback& cc) override { | |
118 data_->SetOpenCallback(cc, gfx::Range(position, position + size)); | |
119 } | |
120 | |
121 void ReadResponseBody(char* buffer, | |
122 int buffer_size, | |
123 const pp::CompletionCallback& cc) override { | |
124 data_->SetReadCallback(cc, buffer, buffer_size); | |
125 } | |
126 | |
127 bool GetDownloadProgress(int64_t* bytes_received, | |
128 int64_t* total_bytes_to_be_received) const override { | |
129 return false; | |
130 } | |
131 | |
132 private: | |
133 LoaderData* data_; | |
134 }; | |
135 | |
136 class TestClient : public DocumentLoader::Client { | |
137 public: | |
138 TestClient() { full_page_loader_data()->content_type = "application/pdf"; } | |
139 ~TestClient() override {} | |
140 // DocumentLoader::Client overrides: | |
141 pp::Instance* GetPluginInstance() override { return nullptr; } | |
142 std::unique_ptr<URLLoaderWrapper> CreateURLLoader() override { | |
143 return std::unique_ptr<URLLoaderWrapper>( | |
144 new TestURLLoader(partial_loader_data())); | |
145 } | |
146 void OnPendingRequestComplete() override {} | |
147 void OnNewDataAvailable() override {} | |
148 void OnDocumentComplete() override {} | |
149 void OnDocumentCanceled() override {} | |
150 void CancelBrowserDownload() override {} | |
151 | |
152 std::unique_ptr<URLLoaderWrapper> CreateFullPageLoader() { | |
153 return std::unique_ptr<URLLoaderWrapper>( | |
154 new TestURLLoader(full_page_loader_data())); | |
155 } | |
156 | |
157 TestURLLoader::LoaderData* full_page_loader_data() { | |
158 return &full_page_loader_data_; | |
159 } | |
160 TestURLLoader::LoaderData* partial_loader_data() { | |
161 return &partial_loader_data_; | |
162 } | |
163 | |
164 void SetCanUsePartialLoading() { | |
165 full_page_loader_data()->content_length = 10 * 1024 * 1024; | |
166 full_page_loader_data()->content_encoded = false; | |
167 full_page_loader_data()->accept_ranges_bytes = true; | |
168 } | |
169 | |
170 void SendAllPartialData() { | |
171 partial_loader_data_.byte_range = partial_loader_data_.open_byte_range; | |
172 partial_loader_data_.CallOpenCallback(0); | |
173 uint32_t length = partial_loader_data_.byte_range.length(); | |
174 while (length > 0) { | |
175 const uint32_t part_len = std::min( | |
176 length, static_cast<uint32_t>(DocumentLoader::kDefaultRequestSize)); | |
177 partial_loader_data_.CallReadCallback(part_len); | |
178 length -= part_len; | |
179 } | |
180 if (partial_loader_data_.IsWaitRead()) { | |
181 partial_loader_data_.CallReadCallback(0); | |
182 } | |
183 } | |
184 | |
185 private: | |
186 TestURLLoader::LoaderData full_page_loader_data_; | |
187 TestURLLoader::LoaderData partial_loader_data_; | |
188 }; | |
189 | |
190 class MockClient : public TestClient { | |
191 public: | |
192 MOCK_METHOD0(OnPendingRequestComplete, void()); | |
193 MOCK_METHOD0(OnNewDataAvailable, void()); | |
194 MOCK_METHOD0(OnDocumentComplete, void()); | |
195 MOCK_METHOD0(OnDocumentCanceled, void()); | |
196 }; | |
197 } // namespace | |
198 | |
199 class DocumentLoaderTest : public ::testing::Test { | |
200 public: | |
201 DocumentLoaderTest() {} | |
202 ~DocumentLoaderTest() override {} | |
203 void SetUp() override {} | |
204 void TearDown() override {} | |
205 }; | |
206 | |
207 TEST_F(DocumentLoaderTest, CanStartPartialLoading) { | |
208 TestClient client; | |
209 client.full_page_loader_data()->content_length = 1 * 1024 * 1024; | |
210 client.full_page_loader_data()->content_encoded = false; | |
211 client.full_page_loader_data()->accept_ranges_bytes = true; | |
212 { | |
213 DocumentLoader loader(&client); | |
214 loader.Init(client.CreateFullPageLoader(), "http://url.com"); | |
215 loader.RequestData(1000000, 1); | |
216 EXPECT_FALSE(loader.is_partial_loader_active()); | |
217 // Always send initial data from FullPageLoader. | |
218 client.full_page_loader_data()->CallReadCallback( | |
219 DocumentLoader::kDefaultRequestSize); | |
220 EXPECT_TRUE(loader.is_partial_loader_active()); | |
221 } | |
222 { | |
223 client.full_page_loader_data()->content_length = | |
224 DocumentLoader::kDefaultRequestSize * 2; | |
225 DocumentLoader loader(&client); | |
226 loader.Init(client.CreateFullPageLoader(), "http://url.com"); | |
227 loader.RequestData(1000000, 1); | |
228 EXPECT_FALSE(loader.is_partial_loader_active()); | |
229 // Always send initial data from FullPageLoader. | |
230 client.full_page_loader_data()->CallReadCallback( | |
231 DocumentLoader::kDefaultRequestSize); | |
232 EXPECT_FALSE(loader.is_partial_loader_active()); | |
233 client.full_page_loader_data()->content_length = 1 * 1024 * 1024; | |
234 } | |
spelchat
2016/10/14 23:43:37
This code desperately needed tests, thanks for tha
snake
2016/10/18 12:37:18
Done.
| |
235 { | |
236 client.full_page_loader_data()->content_encoded = true; | |
237 DocumentLoader loader(&client); | |
238 loader.Init(client.CreateFullPageLoader(), "http://url.com"); | |
239 loader.RequestData(1000000, 1); | |
240 EXPECT_FALSE(loader.is_partial_loader_active()); | |
241 // Always send initial data from FullPageLoader. | |
242 client.full_page_loader_data()->CallReadCallback( | |
243 DocumentLoader::kDefaultRequestSize); | |
244 EXPECT_FALSE(loader.is_partial_loader_active()); | |
245 client.full_page_loader_data()->content_encoded = false; | |
246 } | |
247 { | |
248 client.full_page_loader_data()->accept_ranges_bytes = false; | |
249 DocumentLoader loader(&client); | |
250 loader.Init(client.CreateFullPageLoader(), "http://url.com"); | |
251 loader.RequestData(1000000, 1); | |
252 EXPECT_FALSE(loader.is_partial_loader_active()); | |
253 // Always send initial data from FullPageLoader. | |
254 client.full_page_loader_data()->CallReadCallback( | |
255 DocumentLoader::kDefaultRequestSize); | |
256 EXPECT_FALSE(loader.is_partial_loader_active()); | |
257 client.full_page_loader_data()->accept_ranges_bytes = true; | |
258 } | |
259 { | |
260 DocumentLoader loader(&client); | |
261 loader.SetPartialLoadingEnabled(false); | |
262 loader.Init(client.CreateFullPageLoader(), "http://url.com"); | |
263 // We should not start partial loading if requested data is beside full page | |
264 // loading position. | |
265 loader.RequestData(DocumentLoader::kDefaultRequestSize, 1); | |
266 EXPECT_FALSE(loader.is_partial_loader_active()); | |
267 // Always send initial data from FullPageLoader. | |
268 client.full_page_loader_data()->CallReadCallback( | |
269 DocumentLoader::kDefaultRequestSize); | |
270 EXPECT_FALSE(loader.is_partial_loader_active()); | |
271 } | |
272 { | |
273 DocumentLoader loader(&client); | |
274 loader.SetPartialLoadingEnabled(false); | |
275 loader.Init(client.CreateFullPageLoader(), "http://url.com"); | |
276 loader.RequestData(1000000, 1); | |
277 EXPECT_FALSE(loader.is_partial_loader_active()); | |
278 // Always send initial data from FullPageLoader. | |
279 client.full_page_loader_data()->CallReadCallback( | |
280 DocumentLoader::kDefaultRequestSize); | |
281 EXPECT_FALSE(loader.is_partial_loader_active()); | |
282 } | |
283 } | |
284 | |
285 TEST_F(DocumentLoaderTest, PartialLoadingSimple) { | |
286 TestClient client; | |
287 client.SetCanUsePartialLoading(); | |
288 | |
289 DocumentLoader loader(&client); | |
290 loader.Init(client.CreateFullPageLoader(), "http://url.com"); | |
291 | |
292 // While we have not requests, we shold not start partial loading. | |
spelchat
2016/10/14 23:43:37
not requests -> no requests
shold -> should
snake
2016/10/18 12:37:18
Done.
| |
293 EXPECT_FALSE(loader.is_partial_loader_active()); | |
294 | |
295 loader.RequestData(5000000, 1); | |
296 | |
297 EXPECT_FALSE(client.partial_loader_data()->IsWaitOpen()); | |
298 EXPECT_FALSE(loader.is_partial_loader_active()); | |
299 | |
300 // Always send initial data from FullPageLoader. | |
301 client.full_page_loader_data()->CallReadCallback( | |
302 DocumentLoader::kDefaultRequestSize); | |
303 | |
304 // Partial loader should request headers. | |
305 EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen()); | |
306 EXPECT_TRUE(loader.is_partial_loader_active()); | |
307 // Loader should be stopped. | |
308 EXPECT_TRUE(client.full_page_loader_data()->closed); | |
309 | |
310 EXPECT_EQ("{4980736,10485760}", | |
311 client.partial_loader_data()->open_byte_range.ToString()); | |
312 } | |
313 | |
314 TEST_F(DocumentLoaderTest, PartialLoadingBackOrder) { | |
315 TestClient client; | |
316 client.SetCanUsePartialLoading(); | |
317 | |
318 DocumentLoader loader(&client); | |
319 loader.Init(client.CreateFullPageLoader(), "http://url.com"); | |
320 | |
321 // While we have not requests, we shold not start partial loading. | |
spelchat
2016/10/14 23:43:37
not requests -> no requests
shold -> should
snake
2016/10/18 12:37:18
Done.
| |
322 EXPECT_FALSE(loader.is_partial_loader_active()); | |
323 | |
324 loader.RequestData(client.full_page_loader_data()->content_length - 1, 1); | |
325 | |
326 EXPECT_FALSE(client.partial_loader_data()->IsWaitOpen()); | |
327 EXPECT_FALSE(loader.is_partial_loader_active()); | |
328 | |
329 // Always send initial data from FullPageLoader. | |
330 client.full_page_loader_data()->CallReadCallback( | |
331 DocumentLoader::kDefaultRequestSize); | |
332 | |
333 // Partial loader should request headers. | |
334 EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen()); | |
335 EXPECT_TRUE(loader.is_partial_loader_active()); | |
336 // Loader should be stopped. | |
337 EXPECT_TRUE(client.full_page_loader_data()->closed); | |
338 | |
339 // Requested range should be enlarged. | |
340 EXPECT_GT(client.partial_loader_data()->open_byte_range.length(), 1u); | |
341 EXPECT_EQ("{9830400,10485760}", | |
342 client.partial_loader_data()->open_byte_range.ToString()); | |
343 } | |
344 | |
345 TEST_F(DocumentLoaderTest, CompleteWithoutPartial) { | |
346 TestClient client; | |
347 client.SetCanUsePartialLoading(); | |
348 DocumentLoader loader(&client); | |
349 loader.Init(client.CreateFullPageLoader(), "http://url.com"); | |
350 EXPECT_FALSE(client.full_page_loader_data()->closed); | |
351 while (client.full_page_loader_data()->IsWaitRead()) { | |
352 client.full_page_loader_data()->CallReadCallback(1000); | |
353 } | |
354 EXPECT_TRUE(loader.IsDocumentComplete()); | |
355 EXPECT_TRUE(client.full_page_loader_data()->closed); | |
356 } | |
357 | |
358 TEST_F(DocumentLoaderTest, ErrorDownloadFullDocument) { | |
359 TestClient client; | |
360 client.SetCanUsePartialLoading(); | |
361 DocumentLoader loader(&client); | |
362 loader.Init(client.CreateFullPageLoader(), "http://url.com"); | |
363 EXPECT_TRUE(client.full_page_loader_data()->IsWaitRead()); | |
364 EXPECT_FALSE(client.full_page_loader_data()->closed); | |
365 client.full_page_loader_data()->CallReadCallback(-3); | |
366 EXPECT_TRUE(client.full_page_loader_data()->closed); | |
367 EXPECT_FALSE(loader.IsDocumentComplete()); | |
368 } | |
369 | |
370 TEST_F(DocumentLoaderTest, CompleteNoContentLength) { | |
371 TestClient client; | |
372 DocumentLoader loader(&client); | |
373 loader.Init(client.CreateFullPageLoader(), "http://url.com"); | |
374 EXPECT_FALSE(client.full_page_loader_data()->closed); | |
375 for (int i = 0; i < 10; ++i) { | |
376 EXPECT_TRUE(client.full_page_loader_data()->IsWaitRead()); | |
377 client.full_page_loader_data()->CallReadCallback(1000); | |
378 } | |
379 EXPECT_TRUE(client.full_page_loader_data()->IsWaitRead()); | |
380 client.full_page_loader_data()->CallReadCallback(0); | |
381 EXPECT_EQ(10000ul, loader.GetDocumentSize()); | |
382 EXPECT_TRUE(loader.IsDocumentComplete()); | |
383 EXPECT_TRUE(client.full_page_loader_data()->closed); | |
384 } | |
385 | |
386 TEST_F(DocumentLoaderTest, CompleteWithPartial) { | |
387 TestClient client; | |
388 client.SetCanUsePartialLoading(); | |
389 client.full_page_loader_data()->content_length = | |
390 DocumentLoader::kDefaultRequestSize * 20; | |
391 DocumentLoader loader(&client); | |
392 loader.Init(client.CreateFullPageLoader(), "http://url.com"); | |
393 loader.RequestData(19 * DocumentLoader::kDefaultRequestSize, | |
394 DocumentLoader::kDefaultRequestSize); | |
395 EXPECT_FALSE(client.full_page_loader_data()->closed); | |
396 EXPECT_FALSE(client.partial_loader_data()->IsWaitRead()); | |
397 EXPECT_FALSE(client.partial_loader_data()->IsWaitOpen()); | |
398 | |
399 // Always send initial data from FullPageLoader. | |
400 client.full_page_loader_data()->CallReadCallback( | |
401 DocumentLoader::kDefaultRequestSize); | |
402 EXPECT_TRUE(client.full_page_loader_data()->closed); | |
403 EXPECT_FALSE(client.partial_loader_data()->closed); | |
404 | |
405 client.SendAllPartialData(); | |
406 // Now we should send other document data. | |
407 client.SendAllPartialData(); | |
408 EXPECT_TRUE(client.full_page_loader_data()->closed); | |
409 EXPECT_TRUE(client.partial_loader_data()->closed); | |
410 } | |
411 | |
412 TEST_F(DocumentLoaderTest, PartialRequestLastChunk) { | |
413 const uint32_t kLastChunkSize = 300; | |
414 TestClient client; | |
415 client.SetCanUsePartialLoading(); | |
416 client.full_page_loader_data()->content_length = | |
417 DocumentLoader::kDefaultRequestSize * 20 + kLastChunkSize; | |
418 DocumentLoader loader(&client); | |
419 loader.Init(client.CreateFullPageLoader(), "http://url.com"); | |
420 loader.RequestData(20 * DocumentLoader::kDefaultRequestSize, 1); | |
421 | |
422 // Always send initial data from FullPageLoader. | |
423 client.full_page_loader_data()->CallReadCallback( | |
424 DocumentLoader::kDefaultRequestSize); | |
425 | |
426 EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen()); | |
427 EXPECT_EQ( | |
428 static_cast<int>(client.partial_loader_data()->open_byte_range.end()), | |
429 client.full_page_loader_data()->content_length); | |
430 client.partial_loader_data()->byte_range = | |
431 client.partial_loader_data()->open_byte_range; | |
432 client.partial_loader_data()->CallOpenCallback(0); | |
433 uint32_t data_length = client.partial_loader_data()->byte_range.length(); | |
434 while (data_length > DocumentLoader::kDefaultRequestSize) { | |
435 client.partial_loader_data()->CallReadCallback( | |
436 DocumentLoader::kDefaultRequestSize); | |
437 data_length -= DocumentLoader::kDefaultRequestSize; | |
438 } | |
439 EXPECT_EQ(kLastChunkSize, data_length); | |
440 client.partial_loader_data()->CallReadCallback(kLastChunkSize); | |
441 EXPECT_TRUE(loader.IsDataAvailable(DocumentLoader::kDefaultRequestSize * 20, | |
442 kLastChunkSize)); | |
443 } | |
444 | |
445 TEST_F(DocumentLoaderTest, DocumentSize) { | |
446 TestClient client; | |
447 client.SetCanUsePartialLoading(); | |
448 client.full_page_loader_data()->content_length = 123456789; | |
449 DocumentLoader loader(&client); | |
450 loader.Init(client.CreateFullPageLoader(), "http://url.com"); | |
451 EXPECT_EQ(static_cast<int>(loader.GetDocumentSize()), | |
452 client.full_page_loader_data()->content_length); | |
453 } | |
454 | |
455 TEST_F(DocumentLoaderTest, DocumentSizeNoContentLength) { | |
456 TestClient client; | |
457 DocumentLoader loader(&client); | |
458 loader.Init(client.CreateFullPageLoader(), "http://url.com"); | |
459 EXPECT_EQ(0ul, loader.GetDocumentSize()); | |
460 client.full_page_loader_data()->CallReadCallback( | |
461 DocumentLoader::kDefaultRequestSize); | |
462 client.full_page_loader_data()->CallReadCallback(1000); | |
463 client.full_page_loader_data()->CallReadCallback(500); | |
464 client.full_page_loader_data()->CallReadCallback(0); | |
465 EXPECT_EQ(DocumentLoader::kDefaultRequestSize + 1000 + 500, | |
466 static_cast<int>(loader.GetDocumentSize())); | |
467 EXPECT_TRUE(loader.IsDocumentComplete()); | |
468 } | |
469 | |
470 TEST_F(DocumentLoaderTest, ClearPendingRequests) { | |
471 TestClient client; | |
472 client.SetCanUsePartialLoading(); | |
473 client.full_page_loader_data()->content_length = | |
474 DocumentLoader::kDefaultRequestSize * 100 + 58383; | |
475 DocumentLoader loader(&client); | |
476 loader.Init(client.CreateFullPageLoader(), "http://url.com"); | |
477 loader.RequestData(17 * DocumentLoader::kDefaultRequestSize + 100, 10); | |
478 loader.ClearPendingRequests(); | |
479 loader.RequestData(15 * DocumentLoader::kDefaultRequestSize + 200, 20); | |
480 // pending requests are accumulating, and will be processed after initial data | |
481 // load. | |
482 EXPECT_FALSE(client.partial_loader_data()->IsWaitOpen()); | |
483 | |
484 // Send initial data from FullPageLoader. | |
485 client.full_page_loader_data()->CallReadCallback( | |
486 DocumentLoader::kDefaultRequestSize); | |
487 | |
488 { | |
489 EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen()); | |
490 const gfx::Range range_requested(15 * DocumentLoader::kDefaultRequestSize, | |
491 16 * DocumentLoader::kDefaultRequestSize); | |
492 EXPECT_EQ(range_requested.start(), | |
493 client.partial_loader_data()->open_byte_range.start()); | |
494 EXPECT_LE(range_requested.end(), | |
495 client.partial_loader_data()->open_byte_range.end()); | |
496 client.partial_loader_data()->byte_range = | |
497 client.partial_loader_data()->open_byte_range; | |
498 } | |
499 // clear requests before Open callback. | |
500 loader.ClearPendingRequests(); | |
501 // Current request should continue loading. | |
502 EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen()); | |
503 client.partial_loader_data()->CallOpenCallback(0); | |
504 client.partial_loader_data()->CallReadCallback( | |
505 DocumentLoader::kDefaultRequestSize); | |
506 EXPECT_FALSE(client.partial_loader_data()->closed); | |
507 // Current request should continue loading, because not other requests queued. | |
508 | |
509 loader.RequestData(18 * DocumentLoader::kDefaultRequestSize + 200, 20); | |
510 // Requests queue is processed only on data receving. | |
511 client.partial_loader_data()->CallReadCallback( | |
512 DocumentLoader::kDefaultRequestSize); | |
513 // new requset with in close distance from current loading. Loading do not | |
514 // restarted. | |
515 EXPECT_FALSE(client.partial_loader_data()->IsWaitOpen()); | |
516 | |
517 loader.ClearPendingRequests(); | |
518 // request again two. | |
519 loader.RequestData(60 * DocumentLoader::kDefaultRequestSize + 100, 10); | |
520 loader.RequestData(35 * DocumentLoader::kDefaultRequestSize + 200, 20); | |
521 // Requests queue is processed only on data receving. | |
522 client.partial_loader_data()->CallReadCallback( | |
523 DocumentLoader::kDefaultRequestSize); | |
524 { | |
525 // new requset not with in close distance from current loading. | |
526 // Loading should be restarted. | |
527 EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen()); | |
528 // The first requested chunk should be processed. | |
529 const gfx::Range range_requested(35 * DocumentLoader::kDefaultRequestSize, | |
530 36 * DocumentLoader::kDefaultRequestSize); | |
531 EXPECT_EQ(range_requested.start(), | |
532 client.partial_loader_data()->open_byte_range.start()); | |
533 EXPECT_LE(range_requested.end(), | |
534 client.partial_loader_data()->open_byte_range.end()); | |
535 client.partial_loader_data()->byte_range = | |
536 client.partial_loader_data()->open_byte_range; | |
537 } | |
538 EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen()); | |
539 client.partial_loader_data()->CallOpenCallback(0); | |
540 // Override pending requests. | |
541 loader.ClearPendingRequests(); | |
542 loader.RequestData(70 * DocumentLoader::kDefaultRequestSize + 100, 10); | |
543 | |
544 // Requests queue is processed only on data receving. | |
545 client.partial_loader_data()->CallReadCallback( | |
546 DocumentLoader::kDefaultRequestSize); | |
547 { | |
548 // New requset not with in close distance from current loading. | |
549 // Loading should be restarted . | |
550 EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen()); | |
551 // The first requested chunk should be processed. | |
552 const gfx::Range range_requested(70 * DocumentLoader::kDefaultRequestSize, | |
553 71 * DocumentLoader::kDefaultRequestSize); | |
554 EXPECT_EQ(range_requested.start(), | |
555 client.partial_loader_data()->open_byte_range.start()); | |
556 EXPECT_LE(range_requested.end(), | |
557 client.partial_loader_data()->open_byte_range.end()); | |
558 client.partial_loader_data()->byte_range = | |
559 client.partial_loader_data()->open_byte_range; | |
560 } | |
561 EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen()); | |
562 } | |
563 | |
564 TEST_F(DocumentLoaderTest, GetBlock) { | |
565 char buffer[DocumentLoader::kDefaultRequestSize]; | |
566 TestClient client; | |
567 client.SetCanUsePartialLoading(); | |
568 client.full_page_loader_data()->content_length = | |
569 DocumentLoader::kDefaultRequestSize * 20 + 58383; | |
570 DocumentLoader loader(&client); | |
571 loader.Init(client.CreateFullPageLoader(), "http://url.com"); | |
572 EXPECT_FALSE(loader.GetBlock(0, 1000, buffer)); | |
573 client.full_page_loader_data()->CallReadCallback( | |
574 DocumentLoader::kDefaultRequestSize); | |
575 EXPECT_TRUE(loader.GetBlock(0, 1000, buffer)); | |
576 EXPECT_FALSE( | |
577 loader.GetBlock(DocumentLoader::kDefaultRequestSize, 1500, buffer)); | |
578 client.full_page_loader_data()->CallReadCallback( | |
579 DocumentLoader::kDefaultRequestSize); | |
580 EXPECT_TRUE( | |
581 loader.GetBlock(DocumentLoader::kDefaultRequestSize, 1500, buffer)); | |
582 | |
583 EXPECT_FALSE( | |
584 loader.GetBlock(17 * DocumentLoader::kDefaultRequestSize, 3000, buffer)); | |
585 loader.RequestData(17 * DocumentLoader::kDefaultRequestSize + 100, 10); | |
586 EXPECT_FALSE( | |
587 loader.GetBlock(17 * DocumentLoader::kDefaultRequestSize, 3000, buffer)); | |
588 | |
589 // Requests queue is processed only on data receving. | |
590 client.full_page_loader_data()->CallReadCallback( | |
591 DocumentLoader::kDefaultRequestSize); | |
592 | |
593 client.SendAllPartialData(); | |
594 EXPECT_TRUE( | |
595 loader.GetBlock(17 * DocumentLoader::kDefaultRequestSize, 3000, buffer)); | |
596 } | |
597 | |
598 TEST_F(DocumentLoaderTest, IsDataAvailable) { | |
599 TestClient client; | |
600 client.SetCanUsePartialLoading(); | |
601 client.full_page_loader_data()->content_length = | |
602 DocumentLoader::kDefaultRequestSize * 20 + 58383; | |
603 DocumentLoader loader(&client); | |
604 loader.Init(client.CreateFullPageLoader(), "http://url.com"); | |
605 EXPECT_FALSE(loader.IsDataAvailable(0, 1000)); | |
606 client.full_page_loader_data()->CallReadCallback( | |
607 DocumentLoader::kDefaultRequestSize); | |
608 EXPECT_TRUE(loader.IsDataAvailable(0, 1000)); | |
609 EXPECT_FALSE( | |
610 loader.IsDataAvailable(DocumentLoader::kDefaultRequestSize, 1500)); | |
611 client.full_page_loader_data()->CallReadCallback( | |
612 DocumentLoader::kDefaultRequestSize); | |
613 EXPECT_TRUE( | |
614 loader.IsDataAvailable(DocumentLoader::kDefaultRequestSize, 1500)); | |
615 | |
616 EXPECT_FALSE( | |
617 loader.IsDataAvailable(17 * DocumentLoader::kDefaultRequestSize, 3000)); | |
618 loader.RequestData(17 * DocumentLoader::kDefaultRequestSize + 100, 10); | |
619 EXPECT_FALSE( | |
620 loader.IsDataAvailable(17 * DocumentLoader::kDefaultRequestSize, 3000)); | |
621 | |
622 // Requests queue is processed only on data receving. | |
623 client.full_page_loader_data()->CallReadCallback( | |
624 DocumentLoader::kDefaultRequestSize); | |
625 | |
626 client.SendAllPartialData(); | |
627 EXPECT_TRUE( | |
628 loader.IsDataAvailable(17 * DocumentLoader::kDefaultRequestSize, 3000)); | |
629 } | |
630 | |
631 TEST_F(DocumentLoaderTest, RequestData) { | |
632 TestClient client; | |
633 client.SetCanUsePartialLoading(); | |
634 client.full_page_loader_data()->content_length = | |
635 DocumentLoader::kDefaultRequestSize * 100 + 58383; | |
636 DocumentLoader loader(&client); | |
637 loader.Init(client.CreateFullPageLoader(), "http://url.com"); | |
638 loader.RequestData(37 * DocumentLoader::kDefaultRequestSize + 200, 10); | |
639 loader.RequestData(25 * DocumentLoader::kDefaultRequestSize + 600, 100); | |
640 loader.RequestData(13 * DocumentLoader::kDefaultRequestSize + 900, 500); | |
641 | |
642 // Send initial data from FullPageLoader. | |
643 client.full_page_loader_data()->CallReadCallback( | |
644 DocumentLoader::kDefaultRequestSize); | |
645 | |
646 { | |
647 EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen()); | |
648 const gfx::Range range_requested(13 * DocumentLoader::kDefaultRequestSize, | |
649 14 * DocumentLoader::kDefaultRequestSize); | |
650 EXPECT_EQ(range_requested.start(), | |
651 client.partial_loader_data()->open_byte_range.start()); | |
652 EXPECT_LE(range_requested.end(), | |
653 client.partial_loader_data()->open_byte_range.end()); | |
654 client.partial_loader_data()->byte_range = | |
655 client.partial_loader_data()->open_byte_range; | |
656 } | |
657 client.partial_loader_data()->CallOpenCallback(0); | |
658 // Override pending requests. | |
659 loader.ClearPendingRequests(); | |
660 loader.RequestData(38 * DocumentLoader::kDefaultRequestSize + 200, 10); | |
661 loader.RequestData(26 * DocumentLoader::kDefaultRequestSize + 600, 100); | |
662 // Requests queue is processed only on data receving. | |
663 client.partial_loader_data()->CallReadCallback( | |
664 DocumentLoader::kDefaultRequestSize); | |
665 { | |
666 EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen()); | |
667 const gfx::Range range_requested(26 * DocumentLoader::kDefaultRequestSize, | |
668 27 * DocumentLoader::kDefaultRequestSize); | |
669 EXPECT_EQ(range_requested.start(), | |
670 client.partial_loader_data()->open_byte_range.start()); | |
671 EXPECT_LE(range_requested.end(), | |
672 client.partial_loader_data()->open_byte_range.end()); | |
673 client.partial_loader_data()->byte_range = | |
674 client.partial_loader_data()->open_byte_range; | |
675 } | |
676 client.partial_loader_data()->CallOpenCallback(0); | |
677 // Override pending requests. | |
678 loader.ClearPendingRequests(); | |
679 loader.RequestData(39 * DocumentLoader::kDefaultRequestSize + 200, 10); | |
680 // Requests queue is processed only on data receving. | |
681 client.partial_loader_data()->CallReadCallback( | |
682 DocumentLoader::kDefaultRequestSize); | |
683 { | |
684 EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen()); | |
685 const gfx::Range range_requested(39 * DocumentLoader::kDefaultRequestSize, | |
686 40 * DocumentLoader::kDefaultRequestSize); | |
687 EXPECT_EQ(range_requested.start(), | |
688 client.partial_loader_data()->open_byte_range.start()); | |
689 EXPECT_LE(range_requested.end(), | |
690 client.partial_loader_data()->open_byte_range.end()); | |
691 client.partial_loader_data()->byte_range = | |
692 client.partial_loader_data()->open_byte_range; | |
693 } | |
694 // Fill all gaps. | |
695 while (!loader.IsDocumentComplete()) { | |
696 client.SendAllPartialData(); | |
697 } | |
698 EXPECT_TRUE(client.partial_loader_data()->closed); | |
699 } | |
700 | |
701 TEST_F(DocumentLoaderTest, DoNotLoadAvailablePartialData) { | |
702 TestClient client; | |
703 client.SetCanUsePartialLoading(); | |
704 client.full_page_loader_data()->content_length = | |
705 DocumentLoader::kDefaultRequestSize * 20 + 58383; | |
706 DocumentLoader loader(&client); | |
707 loader.Init(client.CreateFullPageLoader(), "http://url.com"); | |
708 // Send initial data from FullPageLoader. | |
709 client.full_page_loader_data()->CallReadCallback( | |
710 DocumentLoader::kDefaultRequestSize); | |
711 | |
712 // Send more data from FullPageLoader. | |
713 client.full_page_loader_data()->CallReadCallback( | |
714 DocumentLoader::kDefaultRequestSize); | |
715 | |
716 loader.RequestData(2 * DocumentLoader::kDefaultRequestSize + 200, 10); | |
717 | |
718 // Send more data from FullPageLoader. | |
719 client.full_page_loader_data()->CallReadCallback( | |
720 DocumentLoader::kDefaultRequestSize); | |
721 | |
722 // Partial loading should not started for already available data. | |
723 EXPECT_TRUE(client.partial_loader_data()->closed); | |
724 } | |
725 | |
726 TEST_F(DocumentLoaderTest, DoNotLoadDataAfterComplete) { | |
727 TestClient client; | |
728 client.SetCanUsePartialLoading(); | |
729 client.full_page_loader_data()->content_length = | |
730 DocumentLoader::kDefaultRequestSize * 20; | |
731 DocumentLoader loader(&client); | |
732 loader.Init(client.CreateFullPageLoader(), "http://url.com"); | |
733 | |
734 for (int i = 0; i < 20; ++i) { | |
735 client.full_page_loader_data()->CallReadCallback( | |
736 DocumentLoader::kDefaultRequestSize); | |
737 } | |
738 | |
739 EXPECT_TRUE(loader.IsDocumentComplete()); | |
740 | |
741 loader.RequestData(17 * DocumentLoader::kDefaultRequestSize + 200, 10); | |
742 | |
743 EXPECT_TRUE(client.partial_loader_data()->closed); | |
744 EXPECT_TRUE(client.full_page_loader_data()->closed); | |
745 } | |
746 | |
747 TEST_F(DocumentLoaderTest, DoNotLoadPartialDataAboveDocumentSize) { | |
748 TestClient client; | |
749 client.SetCanUsePartialLoading(); | |
750 client.full_page_loader_data()->content_length = | |
751 DocumentLoader::kDefaultRequestSize * 20; | |
752 DocumentLoader loader(&client); | |
753 loader.Init(client.CreateFullPageLoader(), "http://url.com"); | |
754 | |
755 loader.RequestData(20 * DocumentLoader::kDefaultRequestSize + 200, 10); | |
756 | |
757 // Send initial data from FullPageLoader. | |
758 client.full_page_loader_data()->CallReadCallback( | |
759 DocumentLoader::kDefaultRequestSize); | |
760 | |
761 EXPECT_TRUE(client.partial_loader_data()->closed); | |
762 } | |
763 | |
764 TEST_F(DocumentLoaderTest, MergePendingRequests) { | |
765 TestClient client; | |
766 client.SetCanUsePartialLoading(); | |
767 client.full_page_loader_data()->content_length = | |
768 DocumentLoader::kDefaultRequestSize * 50 + 58383; | |
769 DocumentLoader loader(&client); | |
770 loader.Init(client.CreateFullPageLoader(), "http://url.com"); | |
771 loader.RequestData(17 * DocumentLoader::kDefaultRequestSize + 200, 10); | |
772 loader.RequestData(16 * DocumentLoader::kDefaultRequestSize + 600, 100); | |
773 | |
774 // Send initial data from FullPageLoader. | |
775 client.full_page_loader_data()->CallReadCallback( | |
776 DocumentLoader::kDefaultRequestSize); | |
777 | |
778 const gfx::Range range_requested(16 * DocumentLoader::kDefaultRequestSize, | |
779 18 * DocumentLoader::kDefaultRequestSize); | |
780 EXPECT_EQ(range_requested.start(), | |
781 client.partial_loader_data()->open_byte_range.start()); | |
782 EXPECT_LE(range_requested.end(), | |
783 client.partial_loader_data()->open_byte_range.end()); | |
784 | |
785 EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen()); | |
786 | |
787 // Fill all gaps. | |
788 while (!loader.IsDocumentComplete()) { | |
789 client.SendAllPartialData(); | |
790 } | |
791 EXPECT_TRUE(client.partial_loader_data()->closed); | |
792 } | |
793 | |
794 TEST_F(DocumentLoaderTest, PartialStopOnStatusCodeError) { | |
795 TestClient client; | |
796 client.SetCanUsePartialLoading(); | |
797 client.full_page_loader_data()->content_length = | |
798 DocumentLoader::kDefaultRequestSize * 20; | |
799 DocumentLoader loader(&client); | |
800 loader.Init(client.CreateFullPageLoader(), "http://url.com"); | |
801 | |
802 loader.RequestData(17 * DocumentLoader::kDefaultRequestSize + 200, 10); | |
803 | |
804 // Send initial data from FullPageLoader. | |
805 client.full_page_loader_data()->CallReadCallback( | |
806 DocumentLoader::kDefaultRequestSize); | |
807 | |
808 EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen()); | |
809 client.partial_loader_data()->status_code = 404; | |
810 client.partial_loader_data()->CallOpenCallback(0); | |
811 EXPECT_TRUE(client.partial_loader_data()->closed); | |
812 } | |
813 | |
814 TEST_F(DocumentLoaderTest, | |
815 PartialAsFullDocumentLoadingRangeRequestNoRangeField) { | |
816 TestClient client; | |
817 client.SetCanUsePartialLoading(); | |
818 client.full_page_loader_data()->content_length = | |
819 DocumentLoader::kDefaultRequestSize * 20; | |
820 DocumentLoader loader(&client); | |
821 loader.Init(client.CreateFullPageLoader(), "http://url.com"); | |
822 | |
823 loader.RequestData(17 * DocumentLoader::kDefaultRequestSize + 200, 10); | |
824 | |
825 // Send initial data from FullPageLoader. | |
826 client.full_page_loader_data()->CallReadCallback( | |
827 DocumentLoader::kDefaultRequestSize); | |
828 | |
829 EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen()); | |
830 client.partial_loader_data()->byte_range = gfx::Range::InvalidRange(); | |
831 client.partial_loader_data()->CallOpenCallback(0); | |
832 EXPECT_FALSE(client.partial_loader_data()->closed); | |
833 // partial loader is used to load whole page, like full page loader. | |
834 EXPECT_FALSE(loader.is_partial_loader_active()); | |
835 } | |
836 | |
837 TEST_F(DocumentLoaderTest, PartialMultiPart) { | |
838 TestClient client; | |
839 client.SetCanUsePartialLoading(); | |
840 client.full_page_loader_data()->content_length = | |
841 DocumentLoader::kDefaultRequestSize * 20; | |
842 DocumentLoader loader(&client); | |
843 loader.Init(client.CreateFullPageLoader(), "http://url.com"); | |
844 | |
845 loader.RequestData(17 * DocumentLoader::kDefaultRequestSize + 200, 10); | |
846 | |
847 // Send initial data from FullPageLoader. | |
848 client.full_page_loader_data()->CallReadCallback( | |
849 DocumentLoader::kDefaultRequestSize); | |
850 | |
851 EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen()); | |
852 client.partial_loader_data()->is_multipart = true; | |
853 client.partial_loader_data()->CallOpenCallback(0); | |
854 client.partial_loader_data()->byte_range = | |
855 gfx::Range(17 * DocumentLoader::kDefaultRequestSize, | |
856 18 * DocumentLoader::kDefaultRequestSize); | |
857 client.partial_loader_data()->CallReadCallback( | |
858 DocumentLoader::kDefaultRequestSize); | |
859 EXPECT_TRUE(loader.IsDataAvailable(17 * DocumentLoader::kDefaultRequestSize, | |
860 DocumentLoader::kDefaultRequestSize)); | |
861 } | |
862 | |
863 TEST_F(DocumentLoaderTest, PartialMultiPartRangeError) { | |
864 TestClient client; | |
865 client.SetCanUsePartialLoading(); | |
866 client.full_page_loader_data()->content_length = | |
867 DocumentLoader::kDefaultRequestSize * 20; | |
868 DocumentLoader loader(&client); | |
869 loader.Init(client.CreateFullPageLoader(), "http://url.com"); | |
870 | |
871 loader.RequestData(17 * DocumentLoader::kDefaultRequestSize + 200, 10); | |
872 | |
873 // Send initial data from FullPageLoader. | |
874 client.full_page_loader_data()->CallReadCallback( | |
875 DocumentLoader::kDefaultRequestSize); | |
876 | |
877 EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen()); | |
878 client.partial_loader_data()->is_multipart = true; | |
879 client.partial_loader_data()->CallOpenCallback(0); | |
880 client.partial_loader_data()->byte_range = gfx::Range::InvalidRange(); | |
881 client.partial_loader_data()->CallReadCallback( | |
882 DocumentLoader::kDefaultRequestSize); | |
883 EXPECT_FALSE(loader.IsDataAvailable(17 * DocumentLoader::kDefaultRequestSize, | |
884 DocumentLoader::kDefaultRequestSize)); | |
885 EXPECT_TRUE(client.partial_loader_data()->closed); | |
886 } | |
887 | |
888 TEST_F(DocumentLoaderTest, PartialConnectionErrorOnOpen) { | |
889 TestClient client; | |
890 client.SetCanUsePartialLoading(); | |
891 client.full_page_loader_data()->content_length = | |
892 DocumentLoader::kDefaultRequestSize * 20; | |
893 DocumentLoader loader(&client); | |
894 loader.Init(client.CreateFullPageLoader(), "http://url.com"); | |
895 | |
896 loader.RequestData(17 * DocumentLoader::kDefaultRequestSize + 200, 10); | |
897 | |
898 // Send initial data from FullPageLoader. | |
899 client.full_page_loader_data()->CallReadCallback( | |
900 DocumentLoader::kDefaultRequestSize); | |
901 | |
902 EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen()); | |
903 client.partial_loader_data()->CallOpenCallback(-3); | |
904 EXPECT_TRUE(client.partial_loader_data()->closed); | |
905 | |
906 // Partial loading should not restart after any error. | |
907 loader.RequestData(18 * DocumentLoader::kDefaultRequestSize + 200, 10); | |
908 | |
909 EXPECT_FALSE(client.partial_loader_data()->IsWaitOpen()); | |
910 EXPECT_TRUE(client.partial_loader_data()->closed); | |
911 } | |
912 | |
913 TEST_F(DocumentLoaderTest, PartialConnectionErrorOnRead) { | |
914 TestClient client; | |
915 client.SetCanUsePartialLoading(); | |
916 client.full_page_loader_data()->content_length = | |
917 DocumentLoader::kDefaultRequestSize * 20; | |
918 DocumentLoader loader(&client); | |
919 loader.Init(client.CreateFullPageLoader(), "http://url.com"); | |
920 | |
921 loader.RequestData(17 * DocumentLoader::kDefaultRequestSize + 200, 10); | |
922 | |
923 // Send initial data from FullPageLoader. | |
924 client.full_page_loader_data()->CallReadCallback( | |
925 DocumentLoader::kDefaultRequestSize); | |
926 | |
927 EXPECT_TRUE(client.partial_loader_data()->IsWaitOpen()); | |
928 client.partial_loader_data()->byte_range = | |
929 gfx::Range(17 * DocumentLoader::kDefaultRequestSize, | |
930 18 * DocumentLoader::kDefaultRequestSize); | |
931 client.partial_loader_data()->CallOpenCallback(0); | |
932 EXPECT_TRUE(client.partial_loader_data()->IsWaitRead()); | |
933 client.partial_loader_data()->CallReadCallback(-3); | |
934 EXPECT_TRUE(client.partial_loader_data()->closed); | |
935 | |
936 // Partial loading should not restart after any error. | |
937 loader.RequestData(18 * DocumentLoader::kDefaultRequestSize + 200, 10); | |
938 | |
939 EXPECT_FALSE(client.partial_loader_data()->IsWaitOpen()); | |
940 EXPECT_TRUE(client.partial_loader_data()->closed); | |
941 } | |
942 | |
943 TEST_F(DocumentLoaderTest, GetProgress) { | |
944 TestClient client; | |
945 client.SetCanUsePartialLoading(); | |
946 client.full_page_loader_data()->content_length = | |
947 DocumentLoader::kDefaultRequestSize * 20; | |
948 DocumentLoader loader(&client); | |
949 loader.Init(client.CreateFullPageLoader(), "http://url.com"); | |
950 EXPECT_EQ(0., loader.GetProgress()); | |
951 | |
952 for (int i = 0; i < 20; ++i) { | |
953 EXPECT_EQ(i * 100 / 20, static_cast<int>(loader.GetProgress() * 100)); | |
954 client.full_page_loader_data()->CallReadCallback( | |
955 DocumentLoader::kDefaultRequestSize); | |
956 } | |
957 EXPECT_EQ(1., loader.GetProgress()); | |
958 } | |
959 | |
960 TEST_F(DocumentLoaderTest, GetProgressNoContentLength) { | |
961 TestClient client; | |
962 DocumentLoader loader(&client); | |
963 loader.Init(client.CreateFullPageLoader(), "http://url.com"); | |
964 EXPECT_EQ(-1., loader.GetProgress()); | |
965 | |
966 for (int i = 0; i < 20; ++i) { | |
967 EXPECT_EQ(-1., loader.GetProgress()); | |
968 client.full_page_loader_data()->CallReadCallback( | |
969 DocumentLoader::kDefaultRequestSize); | |
970 } | |
971 client.full_page_loader_data()->CallReadCallback(0); | |
972 EXPECT_EQ(1., loader.GetProgress()); | |
973 } | |
974 | |
975 TEST_F(DocumentLoaderTest, ClientCompleteCallbacks) { | |
976 MockClient client; | |
977 client.SetCanUsePartialLoading(); | |
978 client.full_page_loader_data()->content_length = | |
979 DocumentLoader::kDefaultRequestSize * 20; | |
980 DocumentLoader loader(&client); | |
981 loader.Init(client.CreateFullPageLoader(), "http://url.com"); | |
982 | |
983 EXPECT_CALL(client, OnDocumentComplete()).Times(0); | |
984 for (int i = 0; i < 19; ++i) { | |
985 client.full_page_loader_data()->CallReadCallback( | |
986 DocumentLoader::kDefaultRequestSize); | |
987 } | |
988 Mock::VerifyAndClear(&client); | |
989 | |
990 EXPECT_CALL(client, OnDocumentComplete()).Times(1); | |
991 client.full_page_loader_data()->CallReadCallback( | |
992 DocumentLoader::kDefaultRequestSize); | |
993 Mock::VerifyAndClear(&client); | |
994 } | |
995 | |
996 TEST_F(DocumentLoaderTest, ClientCompleteCallbacksNoContentLength) { | |
997 MockClient client; | |
998 DocumentLoader loader(&client); | |
999 loader.Init(client.CreateFullPageLoader(), "http://url.com"); | |
1000 | |
1001 EXPECT_CALL(client, OnDocumentCanceled()).Times(0); | |
1002 EXPECT_CALL(client, OnDocumentComplete()).Times(0); | |
1003 for (int i = 0; i < 20; ++i) { | |
1004 client.full_page_loader_data()->CallReadCallback( | |
1005 DocumentLoader::kDefaultRequestSize); | |
1006 } | |
1007 Mock::VerifyAndClear(&client); | |
1008 | |
1009 EXPECT_CALL(client, OnDocumentCanceled()).Times(0); | |
1010 EXPECT_CALL(client, OnDocumentComplete()).Times(1); | |
1011 client.full_page_loader_data()->CallReadCallback(0); | |
1012 Mock::VerifyAndClear(&client); | |
1013 } | |
1014 | |
1015 TEST_F(DocumentLoaderTest, ClientCancelCallback) { | |
1016 MockClient client; | |
1017 client.SetCanUsePartialLoading(); | |
1018 client.full_page_loader_data()->content_length = | |
1019 DocumentLoader::kDefaultRequestSize * 20; | |
1020 DocumentLoader loader(&client); | |
1021 loader.Init(client.CreateFullPageLoader(), "http://url.com"); | |
1022 | |
1023 EXPECT_CALL(client, OnDocumentCanceled()).Times(0); | |
1024 EXPECT_CALL(client, OnDocumentComplete()).Times(0); | |
1025 for (int i = 0; i < 10; ++i) { | |
1026 client.full_page_loader_data()->CallReadCallback( | |
1027 DocumentLoader::kDefaultRequestSize); | |
1028 } | |
1029 Mock::VerifyAndClear(&client); | |
1030 | |
1031 EXPECT_CALL(client, OnDocumentComplete()).Times(0); | |
1032 EXPECT_CALL(client, OnDocumentCanceled()).Times(1); | |
1033 client.full_page_loader_data()->CallReadCallback(-3); | |
1034 Mock::VerifyAndClear(&client); | |
1035 } | |
1036 | |
1037 TEST_F(DocumentLoaderTest, NewDataAvailable) { | |
1038 MockClient client; | |
1039 client.SetCanUsePartialLoading(); | |
1040 client.full_page_loader_data()->content_length = | |
1041 DocumentLoader::kDefaultRequestSize * 20; | |
1042 DocumentLoader loader(&client); | |
1043 loader.Init(client.CreateFullPageLoader(), "http://url.com"); | |
1044 | |
1045 EXPECT_CALL(client, OnNewDataAvailable()).Times(1); | |
1046 client.full_page_loader_data()->CallReadCallback( | |
1047 DocumentLoader::kDefaultRequestSize); | |
1048 Mock::VerifyAndClear(&client); | |
1049 | |
1050 EXPECT_CALL(client, OnNewDataAvailable()).Times(0); | |
1051 client.full_page_loader_data()->CallReadCallback( | |
1052 DocumentLoader::kDefaultRequestSize - 100); | |
1053 Mock::VerifyAndClear(&client); | |
1054 | |
1055 EXPECT_CALL(client, OnNewDataAvailable()).Times(1); | |
1056 client.full_page_loader_data()->CallReadCallback(100); | |
1057 Mock::VerifyAndClear(&client); | |
1058 } | |
1059 | |
1060 TEST_F(DocumentLoaderTest, ClientPendingRequestCompleteFullLoader) { | |
1061 MockClient client; | |
1062 client.SetCanUsePartialLoading(); | |
1063 DocumentLoader loader(&client); | |
1064 loader.Init(client.CreateFullPageLoader(), "http://url.com"); | |
1065 | |
1066 loader.RequestData(1000, 4000); | |
1067 | |
1068 EXPECT_CALL(client, OnPendingRequestComplete()).Times(1); | |
1069 client.full_page_loader_data()->CallReadCallback( | |
1070 DocumentLoader::kDefaultRequestSize); | |
1071 Mock::VerifyAndClear(&client); | |
1072 } | |
1073 | |
1074 TEST_F(DocumentLoaderTest, ClientPendingRequestCompletePartialLoader) { | |
1075 MockClient client; | |
1076 client.SetCanUsePartialLoading(); | |
1077 DocumentLoader loader(&client); | |
1078 loader.Init(client.CreateFullPageLoader(), "http://url.com"); | |
1079 | |
1080 EXPECT_CALL(client, OnPendingRequestComplete()).Times(1); | |
1081 loader.RequestData(15 * DocumentLoader::kDefaultRequestSize + 4000, 4000); | |
1082 | |
1083 // Always send initial data from FullPageLoader. | |
1084 client.full_page_loader_data()->CallReadCallback( | |
1085 DocumentLoader::kDefaultRequestSize); | |
1086 | |
1087 client.SendAllPartialData(); | |
1088 Mock::VerifyAndClear(&client); | |
1089 } | |
1090 | |
1091 TEST_F(DocumentLoaderTest, ClientPendingRequestCompletePartialAndFullLoader) { | |
1092 MockClient client; | |
1093 client.SetCanUsePartialLoading(); | |
1094 DocumentLoader loader(&client); | |
1095 loader.Init(client.CreateFullPageLoader(), "http://url.com"); | |
1096 | |
1097 EXPECT_CALL(client, OnPendingRequestComplete()).Times(1); | |
1098 loader.RequestData(16 * DocumentLoader::kDefaultRequestSize + 4000, 4000); | |
1099 loader.RequestData(4 * DocumentLoader::kDefaultRequestSize + 4000, 4000); | |
1100 | |
1101 for (int i = 0; i < 5; ++i) { | |
1102 client.full_page_loader_data()->CallReadCallback( | |
1103 DocumentLoader::kDefaultRequestSize); | |
1104 } | |
1105 | |
1106 Mock::VerifyAndClear(&client); | |
1107 | |
1108 EXPECT_CALL(client, OnPendingRequestComplete()).Times(1); | |
1109 client.SendAllPartialData(); | |
1110 Mock::VerifyAndClear(&client); | |
1111 } | |
1112 | |
1113 } // namespace chrome_pdf | |
OLD | NEW |