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