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