OLD | NEW |
| (Empty) |
1 // Copyright 2013 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 <algorithm> | |
6 #include <string> | |
7 | |
8 #include "base/bind.h" | |
9 #include "base/format_macros.h" | |
10 #include "base/message_loop/message_loop.h" | |
11 #include "base/strings/stringprintf.h" | |
12 #include "content/renderer/media/buffered_resource_loader.h" | |
13 #include "content/test/mock_webframeclient.h" | |
14 #include "content/test/mock_weburlloader.h" | |
15 #include "media/base/media_log.h" | |
16 #include "media/base/seekable_buffer.h" | |
17 #include "net/base/net_errors.h" | |
18 #include "net/http/http_request_headers.h" | |
19 #include "net/http/http_util.h" | |
20 #include "third_party/WebKit/public/platform/WebString.h" | |
21 #include "third_party/WebKit/public/platform/WebURLError.h" | |
22 #include "third_party/WebKit/public/platform/WebURLRequest.h" | |
23 #include "third_party/WebKit/public/platform/WebURLResponse.h" | |
24 #include "third_party/WebKit/public/web/WebLocalFrame.h" | |
25 #include "third_party/WebKit/public/web/WebView.h" | |
26 | |
27 using ::testing::_; | |
28 using ::testing::InSequence; | |
29 using ::testing::Return; | |
30 using ::testing::Truly; | |
31 using ::testing::NiceMock; | |
32 | |
33 using blink::WebLocalFrame; | |
34 using blink::WebString; | |
35 using blink::WebURLError; | |
36 using blink::WebURLResponse; | |
37 using blink::WebView; | |
38 | |
39 namespace content { | |
40 | |
41 static const char* kHttpUrl = "http://test"; | |
42 static const char kHttpRedirectToSameDomainUrl1[] = "http://test/ing"; | |
43 static const char kHttpRedirectToSameDomainUrl2[] = "http://test/ing2"; | |
44 static const char kHttpRedirectToDifferentDomainUrl1[] = "http://test2"; | |
45 | |
46 static const int kDataSize = 1024; | |
47 static const int kHttpOK = 200; | |
48 static const int kHttpPartialContent = 206; | |
49 | |
50 enum NetworkState { | |
51 NONE, | |
52 LOADED, | |
53 LOADING | |
54 }; | |
55 | |
56 // Predicate that tests that request disallows compressed data. | |
57 static bool CorrectAcceptEncoding(const blink::WebURLRequest &request) { | |
58 std::string value = request.httpHeaderField( | |
59 WebString::fromUTF8(net::HttpRequestHeaders::kAcceptEncoding)).utf8(); | |
60 return (value.find("identity;q=1") != std::string::npos) && | |
61 (value.find("*;q=0") != std::string::npos); | |
62 } | |
63 | |
64 class BufferedResourceLoaderTest : public testing::Test { | |
65 public: | |
66 BufferedResourceLoaderTest() | |
67 : view_(WebView::create(NULL)), frame_(WebLocalFrame::create(&client_)) { | |
68 view_->setMainFrame(frame_); | |
69 | |
70 for (int i = 0; i < kDataSize; ++i) { | |
71 data_[i] = i; | |
72 } | |
73 } | |
74 | |
75 virtual ~BufferedResourceLoaderTest() { | |
76 view_->close(); | |
77 frame_->close(); | |
78 } | |
79 | |
80 void Initialize(const char* url, int first_position, int last_position) { | |
81 gurl_ = GURL(url); | |
82 first_position_ = first_position; | |
83 last_position_ = last_position; | |
84 | |
85 loader_.reset(new BufferedResourceLoader( | |
86 gurl_, BufferedResourceLoader::kUnspecified, | |
87 first_position_, last_position_, | |
88 BufferedResourceLoader::kCapacityDefer, 0, 0, | |
89 new media::MediaLog())); | |
90 | |
91 // |test_loader_| will be used when Start() is called. | |
92 url_loader_ = new NiceMock<MockWebURLLoader>(); | |
93 loader_->test_loader_ = scoped_ptr<blink::WebURLLoader>(url_loader_); | |
94 } | |
95 | |
96 void SetLoaderBuffer(int forward_capacity, int backward_capacity) { | |
97 loader_->buffer_.set_forward_capacity(forward_capacity); | |
98 loader_->buffer_.set_backward_capacity(backward_capacity); | |
99 loader_->buffer_.Clear(); | |
100 } | |
101 | |
102 void Start() { | |
103 InSequence s; | |
104 EXPECT_CALL(*url_loader_, loadAsynchronously(Truly(CorrectAcceptEncoding), | |
105 loader_.get())); | |
106 | |
107 EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoading)); | |
108 loader_->Start( | |
109 base::Bind(&BufferedResourceLoaderTest::StartCallback, | |
110 base::Unretained(this)), | |
111 base::Bind(&BufferedResourceLoaderTest::LoadingCallback, | |
112 base::Unretained(this)), | |
113 base::Bind(&BufferedResourceLoaderTest::ProgressCallback, | |
114 base::Unretained(this)), | |
115 view_->mainFrame()); | |
116 } | |
117 | |
118 void FullResponse(int64 instance_size) { | |
119 FullResponse(instance_size, BufferedResourceLoader::kOk); | |
120 } | |
121 | |
122 void FullResponse(int64 instance_size, | |
123 BufferedResourceLoader::Status status) { | |
124 EXPECT_CALL(*this, StartCallback(status)); | |
125 | |
126 WebURLResponse response(gurl_); | |
127 response.setHTTPHeaderField(WebString::fromUTF8("Content-Length"), | |
128 WebString::fromUTF8(base::StringPrintf("%" | |
129 PRId64, instance_size))); | |
130 response.setExpectedContentLength(instance_size); | |
131 response.setHTTPStatusCode(kHttpOK); | |
132 loader_->didReceiveResponse(url_loader_, response); | |
133 | |
134 if (status == BufferedResourceLoader::kOk) { | |
135 EXPECT_EQ(instance_size, loader_->content_length()); | |
136 EXPECT_EQ(instance_size, loader_->instance_size()); | |
137 } | |
138 | |
139 EXPECT_FALSE(loader_->range_supported()); | |
140 } | |
141 | |
142 void PartialResponse(int64 first_position, int64 last_position, | |
143 int64 instance_size) { | |
144 PartialResponse(first_position, last_position, instance_size, false, true); | |
145 } | |
146 | |
147 void PartialResponse(int64 first_position, int64 last_position, | |
148 int64 instance_size, bool chunked, bool accept_ranges) { | |
149 EXPECT_CALL(*this, StartCallback(BufferedResourceLoader::kOk)); | |
150 | |
151 WebURLResponse response(gurl_); | |
152 response.setHTTPHeaderField(WebString::fromUTF8("Content-Range"), | |
153 WebString::fromUTF8(base::StringPrintf("bytes " | |
154 "%" PRId64 "-%" PRId64 "/%" PRId64, | |
155 first_position, | |
156 last_position, | |
157 instance_size))); | |
158 | |
159 // HTTP 1.1 doesn't permit Content-Length with Transfer-Encoding: chunked. | |
160 int64 content_length = -1; | |
161 if (chunked) { | |
162 response.setHTTPHeaderField(WebString::fromUTF8("Transfer-Encoding"), | |
163 WebString::fromUTF8("chunked")); | |
164 } else { | |
165 content_length = last_position - first_position + 1; | |
166 } | |
167 response.setExpectedContentLength(content_length); | |
168 | |
169 // A server isn't required to return Accept-Ranges even though it might. | |
170 if (accept_ranges) { | |
171 response.setHTTPHeaderField(WebString::fromUTF8("Accept-Ranges"), | |
172 WebString::fromUTF8("bytes")); | |
173 } | |
174 | |
175 response.setHTTPStatusCode(kHttpPartialContent); | |
176 loader_->didReceiveResponse(url_loader_, response); | |
177 | |
178 // XXX: what's the difference between these two? For example in the chunked | |
179 // range request case, Content-Length is unspecified (because it's chunked) | |
180 // but Content-Range: a-b/c can be returned, where c == Content-Length | |
181 // | |
182 // Can we eliminate one? | |
183 EXPECT_EQ(content_length, loader_->content_length()); | |
184 EXPECT_EQ(instance_size, loader_->instance_size()); | |
185 | |
186 // A valid partial response should always result in this being true. | |
187 EXPECT_TRUE(loader_->range_supported()); | |
188 } | |
189 | |
190 void Redirect(const char* url) { | |
191 GURL redirectUrl(url); | |
192 blink::WebURLRequest newRequest(redirectUrl); | |
193 blink::WebURLResponse redirectResponse(gurl_); | |
194 | |
195 loader_->willSendRequest(url_loader_, newRequest, redirectResponse); | |
196 | |
197 base::MessageLoop::current()->RunUntilIdle(); | |
198 } | |
199 | |
200 void StopWhenLoad() { | |
201 InSequence s; | |
202 EXPECT_CALL(*url_loader_, cancel()); | |
203 loader_->Stop(); | |
204 loader_.reset(); | |
205 } | |
206 | |
207 // Helper method to write to |loader_| from |data_|. | |
208 void WriteLoader(int position, int size) { | |
209 EXPECT_CALL(*this, ProgressCallback(position + size - 1)); | |
210 loader_->didReceiveData(url_loader_, | |
211 reinterpret_cast<char*>(data_ + position), | |
212 size, | |
213 size); | |
214 } | |
215 | |
216 void WriteData(int size) { | |
217 EXPECT_CALL(*this, ProgressCallback(_)); | |
218 | |
219 scoped_ptr<char[]> data(new char[size]); | |
220 loader_->didReceiveData(url_loader_, data.get(), size, size); | |
221 } | |
222 | |
223 void WriteUntilThreshold() { | |
224 int buffered = loader_->buffer_.forward_bytes(); | |
225 int capacity = loader_->buffer_.forward_capacity(); | |
226 CHECK_LT(buffered, capacity); | |
227 | |
228 EXPECT_CALL(*this, LoadingCallback( | |
229 BufferedResourceLoader::kLoadingDeferred)); | |
230 WriteData(capacity - buffered); | |
231 } | |
232 | |
233 // Helper method to read from |loader_|. | |
234 void ReadLoader(int64 position, int size, uint8* buffer) { | |
235 loader_->Read(position, size, buffer, | |
236 base::Bind(&BufferedResourceLoaderTest::ReadCallback, | |
237 base::Unretained(this))); | |
238 } | |
239 | |
240 // Verifies that data in buffer[0...size] is equal to data_[pos...pos+size]. | |
241 void VerifyBuffer(uint8* buffer, int pos, int size) { | |
242 EXPECT_EQ(0, memcmp(buffer, data_ + pos, size)); | |
243 } | |
244 | |
245 void ConfirmLoaderOffsets(int64 expected_offset, | |
246 int expected_first_offset, | |
247 int expected_last_offset) { | |
248 EXPECT_EQ(loader_->offset_, expected_offset); | |
249 EXPECT_EQ(loader_->first_offset_, expected_first_offset); | |
250 EXPECT_EQ(loader_->last_offset_, expected_last_offset); | |
251 } | |
252 | |
253 void ConfirmBufferState(int backward_bytes, | |
254 int backward_capacity, | |
255 int forward_bytes, | |
256 int forward_capacity) { | |
257 EXPECT_EQ(backward_bytes, loader_->buffer_.backward_bytes()); | |
258 EXPECT_EQ(backward_capacity, loader_->buffer_.backward_capacity()); | |
259 EXPECT_EQ(forward_bytes, loader_->buffer_.forward_bytes()); | |
260 EXPECT_EQ(forward_capacity, loader_->buffer_.forward_capacity()); | |
261 } | |
262 | |
263 void ConfirmLoaderBufferBackwardCapacity(int expected_backward_capacity) { | |
264 EXPECT_EQ(loader_->buffer_.backward_capacity(), | |
265 expected_backward_capacity); | |
266 } | |
267 | |
268 void ConfirmLoaderBufferForwardCapacity(int expected_forward_capacity) { | |
269 EXPECT_EQ(loader_->buffer_.forward_capacity(), expected_forward_capacity); | |
270 } | |
271 | |
272 // Makes sure the |loader_| buffer window is in a reasonable range. | |
273 void CheckBufferWindowBounds() { | |
274 // Corresponds to value defined in buffered_resource_loader.cc. | |
275 static const int kMinBufferCapacity = 2 * 1024 * 1024; | |
276 EXPECT_GE(loader_->buffer_.forward_capacity(), kMinBufferCapacity); | |
277 EXPECT_GE(loader_->buffer_.backward_capacity(), kMinBufferCapacity); | |
278 | |
279 // Corresponds to value defined in buffered_resource_loader.cc. | |
280 static const int kMaxBufferCapacity = 20 * 1024 * 1024; | |
281 EXPECT_LE(loader_->buffer_.forward_capacity(), kMaxBufferCapacity); | |
282 EXPECT_LE(loader_->buffer_.backward_capacity(), kMaxBufferCapacity); | |
283 } | |
284 | |
285 MOCK_METHOD1(StartCallback, void(BufferedResourceLoader::Status)); | |
286 MOCK_METHOD2(ReadCallback, void(BufferedResourceLoader::Status, int)); | |
287 MOCK_METHOD1(LoadingCallback, void(BufferedResourceLoader::LoadingState)); | |
288 MOCK_METHOD1(ProgressCallback, void(int64)); | |
289 | |
290 protected: | |
291 GURL gurl_; | |
292 int64 first_position_; | |
293 int64 last_position_; | |
294 | |
295 scoped_ptr<BufferedResourceLoader> loader_; | |
296 NiceMock<MockWebURLLoader>* url_loader_; | |
297 | |
298 MockWebFrameClient client_; | |
299 WebView* view_; | |
300 WebLocalFrame* frame_; | |
301 | |
302 base::MessageLoop message_loop_; | |
303 | |
304 uint8 data_[kDataSize]; | |
305 | |
306 private: | |
307 DISALLOW_COPY_AND_ASSIGN(BufferedResourceLoaderTest); | |
308 }; | |
309 | |
310 TEST_F(BufferedResourceLoaderTest, StartStop) { | |
311 Initialize(kHttpUrl, -1, -1); | |
312 Start(); | |
313 StopWhenLoad(); | |
314 } | |
315 | |
316 // Tests that a bad HTTP response is recived, e.g. file not found. | |
317 TEST_F(BufferedResourceLoaderTest, BadHttpResponse) { | |
318 Initialize(kHttpUrl, -1, -1); | |
319 Start(); | |
320 | |
321 EXPECT_CALL(*this, StartCallback(BufferedResourceLoader::kFailed)); | |
322 | |
323 WebURLResponse response(gurl_); | |
324 response.setHTTPStatusCode(404); | |
325 response.setHTTPStatusText("Not Found\n"); | |
326 loader_->didReceiveResponse(url_loader_, response); | |
327 StopWhenLoad(); | |
328 } | |
329 | |
330 // Tests that partial content is requested but not fulfilled. | |
331 TEST_F(BufferedResourceLoaderTest, NotPartialResponse) { | |
332 Initialize(kHttpUrl, 100, -1); | |
333 Start(); | |
334 FullResponse(1024, BufferedResourceLoader::kFailed); | |
335 StopWhenLoad(); | |
336 } | |
337 | |
338 // Tests that a 200 response is received. | |
339 TEST_F(BufferedResourceLoaderTest, FullResponse) { | |
340 Initialize(kHttpUrl, -1, -1); | |
341 Start(); | |
342 FullResponse(1024); | |
343 StopWhenLoad(); | |
344 } | |
345 | |
346 // Tests that a partial content response is received. | |
347 TEST_F(BufferedResourceLoaderTest, PartialResponse) { | |
348 Initialize(kHttpUrl, 100, 200); | |
349 Start(); | |
350 PartialResponse(100, 200, 1024); | |
351 StopWhenLoad(); | |
352 } | |
353 | |
354 TEST_F(BufferedResourceLoaderTest, PartialResponse_Chunked) { | |
355 Initialize(kHttpUrl, 100, 200); | |
356 Start(); | |
357 PartialResponse(100, 200, 1024, true, true); | |
358 StopWhenLoad(); | |
359 } | |
360 | |
361 TEST_F(BufferedResourceLoaderTest, PartialResponse_NoAcceptRanges) { | |
362 Initialize(kHttpUrl, 100, 200); | |
363 Start(); | |
364 PartialResponse(100, 200, 1024, false, false); | |
365 StopWhenLoad(); | |
366 } | |
367 | |
368 TEST_F(BufferedResourceLoaderTest, PartialResponse_ChunkedNoAcceptRanges) { | |
369 Initialize(kHttpUrl, 100, 200); | |
370 Start(); | |
371 PartialResponse(100, 200, 1024, true, false); | |
372 StopWhenLoad(); | |
373 } | |
374 | |
375 // Tests that an invalid partial response is received. | |
376 TEST_F(BufferedResourceLoaderTest, InvalidPartialResponse) { | |
377 Initialize(kHttpUrl, 0, 10); | |
378 Start(); | |
379 | |
380 EXPECT_CALL(*this, StartCallback(BufferedResourceLoader::kFailed)); | |
381 | |
382 WebURLResponse response(gurl_); | |
383 response.setHTTPHeaderField(WebString::fromUTF8("Content-Range"), | |
384 WebString::fromUTF8(base::StringPrintf("bytes " | |
385 "%d-%d/%d", 1, 10, 1024))); | |
386 response.setExpectedContentLength(10); | |
387 response.setHTTPStatusCode(kHttpPartialContent); | |
388 loader_->didReceiveResponse(url_loader_, response); | |
389 StopWhenLoad(); | |
390 } | |
391 | |
392 // Tests the logic of sliding window for data buffering and reading. | |
393 TEST_F(BufferedResourceLoaderTest, BufferAndRead) { | |
394 Initialize(kHttpUrl, 10, 29); | |
395 loader_->UpdateDeferStrategy(BufferedResourceLoader::kCapacityDefer); | |
396 Start(); | |
397 PartialResponse(10, 29, 30); | |
398 | |
399 uint8 buffer[10]; | |
400 InSequence s; | |
401 | |
402 // Writes 10 bytes and read them back. | |
403 WriteLoader(10, 10); | |
404 EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 10)); | |
405 ReadLoader(10, 10, buffer); | |
406 VerifyBuffer(buffer, 10, 10); | |
407 | |
408 // Writes 10 bytes and read 2 times. | |
409 WriteLoader(20, 10); | |
410 EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 5)); | |
411 ReadLoader(20, 5, buffer); | |
412 VerifyBuffer(buffer, 20, 5); | |
413 EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 5)); | |
414 ReadLoader(25, 5, buffer); | |
415 VerifyBuffer(buffer, 25, 5); | |
416 | |
417 // Read backward within buffer. | |
418 EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 10)); | |
419 ReadLoader(10, 10, buffer); | |
420 VerifyBuffer(buffer, 10, 10); | |
421 | |
422 // Read backward outside buffer. | |
423 EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kCacheMiss, 0)); | |
424 ReadLoader(9, 10, buffer); | |
425 | |
426 // Response has completed. | |
427 EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoadingFinished)); | |
428 loader_->didFinishLoading(url_loader_, 0, -1); | |
429 | |
430 // Try to read 10 from position 25 will just return with 5 bytes. | |
431 EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 5)); | |
432 ReadLoader(25, 10, buffer); | |
433 VerifyBuffer(buffer, 25, 5); | |
434 | |
435 // Try to read outside buffered range after request has completed. | |
436 EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kCacheMiss, 0)); | |
437 ReadLoader(5, 10, buffer); | |
438 | |
439 // Try to read beyond the instance size. | |
440 EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 0)); | |
441 ReadLoader(30, 10, buffer); | |
442 } | |
443 | |
444 // Tests the logic of expanding the data buffer for large reads. | |
445 TEST_F(BufferedResourceLoaderTest, ReadExtendBuffer) { | |
446 Initialize(kHttpUrl, 10, 0x014FFFFFF); | |
447 SetLoaderBuffer(10, 20); | |
448 Start(); | |
449 PartialResponse(10, 0x014FFFFFF, 0x015000000); | |
450 | |
451 uint8 buffer[20]; | |
452 InSequence s; | |
453 | |
454 // Write more than forward capacity and read it back. Ensure forward capacity | |
455 // gets reset after reading. | |
456 EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoadingDeferred)); | |
457 WriteLoader(10, 20); | |
458 | |
459 EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 20)); | |
460 EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoading)); | |
461 ReadLoader(10, 20, buffer); | |
462 | |
463 VerifyBuffer(buffer, 10, 20); | |
464 ConfirmLoaderBufferForwardCapacity(10); | |
465 | |
466 // Make and outstanding read request larger than forward capacity. Ensure | |
467 // forward capacity gets extended. | |
468 ReadLoader(30, 20, buffer); | |
469 ConfirmLoaderBufferForwardCapacity(20); | |
470 | |
471 // Fulfill outstanding request. Ensure forward capacity gets reset. | |
472 EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 20)); | |
473 WriteLoader(30, 20); | |
474 | |
475 VerifyBuffer(buffer, 30, 20); | |
476 ConfirmLoaderBufferForwardCapacity(10); | |
477 | |
478 // Try to read further ahead than kForwardWaitThreshold allows. Ensure | |
479 // forward capacity is not changed. | |
480 EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kCacheMiss, 0)); | |
481 ReadLoader(0x00300000, 1, buffer); | |
482 | |
483 ConfirmLoaderBufferForwardCapacity(10); | |
484 | |
485 // Try to read more than maximum forward capacity. Ensure forward capacity is | |
486 // not changed. | |
487 EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kFailed, 0)); | |
488 ReadLoader(30, 0x01400001, buffer); | |
489 | |
490 ConfirmLoaderBufferForwardCapacity(10); | |
491 | |
492 StopWhenLoad(); | |
493 } | |
494 | |
495 TEST_F(BufferedResourceLoaderTest, ReadOutsideBuffer) { | |
496 Initialize(kHttpUrl, 10, 0x00FFFFFF); | |
497 Start(); | |
498 PartialResponse(10, 0x00FFFFFF, 0x01000000); | |
499 | |
500 uint8 buffer[10]; | |
501 InSequence s; | |
502 | |
503 // Read very far ahead will get a cache miss. | |
504 EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kCacheMiss, 0)); | |
505 ReadLoader(0x00FFFFFF, 1, buffer); | |
506 | |
507 // The following call will not call ReadCallback() because it is waiting for | |
508 // data to arrive. | |
509 ReadLoader(10, 10, buffer); | |
510 | |
511 // Writing to loader will fulfill the read request. | |
512 EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 10)); | |
513 WriteLoader(10, 20); | |
514 VerifyBuffer(buffer, 10, 10); | |
515 | |
516 // The following call cannot be fulfilled now. | |
517 ReadLoader(25, 10, buffer); | |
518 | |
519 EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoadingFinished)); | |
520 EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 5)); | |
521 loader_->didFinishLoading(url_loader_, 0, -1); | |
522 } | |
523 | |
524 TEST_F(BufferedResourceLoaderTest, RequestFailedWhenRead) { | |
525 Initialize(kHttpUrl, 10, 29); | |
526 Start(); | |
527 PartialResponse(10, 29, 30); | |
528 | |
529 uint8 buffer[10]; | |
530 InSequence s; | |
531 | |
532 // We should convert any error we receive to BufferedResourceLoader::kFailed. | |
533 ReadLoader(10, 10, buffer); | |
534 EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoadingFailed)); | |
535 EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kFailed, 0)); | |
536 WebURLError error; | |
537 error.reason = net::ERR_TIMED_OUT; | |
538 error.isCancellation = false; | |
539 loader_->didFail(url_loader_, error); | |
540 } | |
541 | |
542 TEST_F(BufferedResourceLoaderTest, RequestFailedWithNoPendingReads) { | |
543 Initialize(kHttpUrl, 10, 29); | |
544 Start(); | |
545 PartialResponse(10, 29, 30); | |
546 | |
547 uint8 buffer[10]; | |
548 InSequence s; | |
549 | |
550 // Write enough data so that a read would technically complete had the request | |
551 // not failed. | |
552 WriteLoader(10, 20); | |
553 | |
554 // Fail without a pending read. | |
555 WebURLError error; | |
556 error.reason = net::ERR_TIMED_OUT; | |
557 error.isCancellation = false; | |
558 EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoadingFailed)); | |
559 loader_->didFail(url_loader_, error); | |
560 | |
561 // Now we should immediately fail any read even if we have data buffered. | |
562 EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kFailed, 0)); | |
563 ReadLoader(10, 10, buffer); | |
564 } | |
565 | |
566 TEST_F(BufferedResourceLoaderTest, RequestCancelledWhenRead) { | |
567 Initialize(kHttpUrl, 10, 29); | |
568 Start(); | |
569 PartialResponse(10, 29, 30); | |
570 | |
571 uint8 buffer[10]; | |
572 InSequence s; | |
573 | |
574 // We should convert any error we receive to BufferedResourceLoader::kFailed. | |
575 ReadLoader(10, 10, buffer); | |
576 EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoadingFailed)); | |
577 EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kFailed, 0)); | |
578 WebURLError error; | |
579 error.reason = 0; | |
580 error.isCancellation = true; | |
581 loader_->didFail(url_loader_, error); | |
582 } | |
583 | |
584 // Tests the data buffering logic of NeverDefer strategy. | |
585 TEST_F(BufferedResourceLoaderTest, NeverDeferStrategy) { | |
586 Initialize(kHttpUrl, 10, 99); | |
587 SetLoaderBuffer(10, 20); | |
588 loader_->UpdateDeferStrategy(BufferedResourceLoader::kNeverDefer); | |
589 Start(); | |
590 PartialResponse(10, 99, 100); | |
591 | |
592 uint8 buffer[10]; | |
593 | |
594 // Read past the buffer size; should not defer regardless. | |
595 WriteLoader(10, 10); | |
596 WriteLoader(20, 50); | |
597 | |
598 // Should move past window. | |
599 EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kCacheMiss, 0)); | |
600 ReadLoader(10, 10, buffer); | |
601 | |
602 StopWhenLoad(); | |
603 } | |
604 | |
605 // Tests the data buffering logic of ReadThenDefer strategy. | |
606 TEST_F(BufferedResourceLoaderTest, ReadThenDeferStrategy) { | |
607 Initialize(kHttpUrl, 10, 99); | |
608 SetLoaderBuffer(10, 20); | |
609 loader_->UpdateDeferStrategy(BufferedResourceLoader::kReadThenDefer); | |
610 Start(); | |
611 PartialResponse(10, 99, 100); | |
612 | |
613 uint8 buffer[10]; | |
614 | |
615 // Make an outstanding read request. | |
616 ReadLoader(10, 10, buffer); | |
617 | |
618 // Receive almost enough data to cover, shouldn't defer. | |
619 WriteLoader(10, 9); | |
620 | |
621 // As soon as we have received enough data to fulfill the read, defer. | |
622 EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoadingDeferred)); | |
623 EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 10)); | |
624 WriteLoader(19, 1); | |
625 | |
626 VerifyBuffer(buffer, 10, 10); | |
627 | |
628 // Read again which should disable deferring since there should be nothing | |
629 // left in our internal buffer. | |
630 EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoading)); | |
631 ReadLoader(20, 10, buffer); | |
632 | |
633 // Over-fulfill requested bytes, then deferring should be enabled again. | |
634 EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoadingDeferred)); | |
635 EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 10)); | |
636 WriteLoader(20, 40); | |
637 | |
638 VerifyBuffer(buffer, 20, 10); | |
639 | |
640 // Read far ahead, which should disable deferring. In this case we still have | |
641 // bytes in our internal buffer. | |
642 EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoading)); | |
643 ReadLoader(80, 10, buffer); | |
644 | |
645 // Fulfill requested bytes, then deferring should be enabled again. | |
646 EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoadingDeferred)); | |
647 EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 10)); | |
648 WriteLoader(60, 40); | |
649 | |
650 VerifyBuffer(buffer, 80, 10); | |
651 | |
652 StopWhenLoad(); | |
653 } | |
654 | |
655 // Tests the data buffering logic of kCapacityDefer strategy. | |
656 TEST_F(BufferedResourceLoaderTest, ThresholdDeferStrategy) { | |
657 Initialize(kHttpUrl, 10, 99); | |
658 SetLoaderBuffer(10, 20); | |
659 Start(); | |
660 PartialResponse(10, 99, 100); | |
661 | |
662 uint8 buffer[10]; | |
663 InSequence s; | |
664 | |
665 // Write half of capacity: keep not deferring. | |
666 WriteData(5); | |
667 | |
668 // Write rest of space until capacity: start deferring. | |
669 EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoadingDeferred)); | |
670 WriteData(5); | |
671 | |
672 // Read a byte from the buffer: stop deferring. | |
673 EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 1)); | |
674 EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoading)); | |
675 ReadLoader(10, 1, buffer); | |
676 | |
677 // Write a byte to hit capacity: start deferring. | |
678 EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoadingDeferred)); | |
679 WriteData(6); | |
680 | |
681 StopWhenLoad(); | |
682 } | |
683 | |
684 TEST_F(BufferedResourceLoaderTest, Tricky_ReadForwardsPastBuffered) { | |
685 Initialize(kHttpUrl, 10, 99); | |
686 SetLoaderBuffer(10, 10); | |
687 Start(); | |
688 PartialResponse(10, 99, 100); | |
689 | |
690 uint8 buffer[256]; | |
691 InSequence s; | |
692 | |
693 // PRECONDITION | |
694 WriteUntilThreshold(); | |
695 EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 1)); | |
696 EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoading)); | |
697 ReadLoader(10, 1, buffer); | |
698 ConfirmBufferState(1, 10, 9, 10); | |
699 ConfirmLoaderOffsets(11, 0, 0); | |
700 | |
701 // *** TRICKY BUSINESS, PT. I *** | |
702 // Read past buffered: stop deferring. | |
703 // | |
704 // In order for the read to complete we must: | |
705 // 1) Stop deferring to receive more data. | |
706 // | |
707 // BEFORE | |
708 // offset=11 [xxxxxxxxx_] | |
709 // ^ ^^^ requested 4 bytes @ offset 20 | |
710 // AFTER | |
711 // offset=24 [__________] | |
712 // | |
713 ReadLoader(20, 4, buffer); | |
714 | |
715 // Write a little, make sure we didn't start deferring. | |
716 WriteData(2); | |
717 | |
718 // Write the rest, read should complete. | |
719 EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 4)); | |
720 WriteData(2); | |
721 | |
722 // POSTCONDITION | |
723 ConfirmBufferState(4, 10, 0, 10); | |
724 ConfirmLoaderOffsets(24, 0, 0); | |
725 | |
726 StopWhenLoad(); | |
727 } | |
728 | |
729 TEST_F(BufferedResourceLoaderTest, Tricky_ReadBackwardsPastBuffered) { | |
730 Initialize(kHttpUrl, 10, 99); | |
731 SetLoaderBuffer(10, 10); | |
732 Start(); | |
733 PartialResponse(10, 99, 100); | |
734 | |
735 uint8 buffer[256]; | |
736 InSequence s; | |
737 | |
738 // PRECONDITION | |
739 WriteUntilThreshold(); | |
740 ConfirmBufferState(0, 10, 10, 10); | |
741 ConfirmLoaderOffsets(10, 0, 0); | |
742 | |
743 // *** TRICKY BUSINESS, PT. II *** | |
744 // Read backwards a little too much: cache miss. | |
745 // | |
746 // BEFORE | |
747 // offset=10 [__________|xxxxxxxxxx] | |
748 // ^ ^^^ requested 10 bytes @ offset 9 | |
749 // AFTER | |
750 // offset=10 [__________|xxxxxxxxxx] !!! cache miss !!! | |
751 // | |
752 EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kCacheMiss, 0)); | |
753 ReadLoader(9, 4, buffer); | |
754 | |
755 // POSTCONDITION | |
756 ConfirmBufferState(0, 10, 10, 10); | |
757 ConfirmLoaderOffsets(10, 0, 0); | |
758 | |
759 StopWhenLoad(); | |
760 } | |
761 | |
762 TEST_F(BufferedResourceLoaderTest, Tricky_SmallReadWithinThreshold) { | |
763 Initialize(kHttpUrl, 10, 99); | |
764 SetLoaderBuffer(10, 10); | |
765 Start(); | |
766 PartialResponse(10, 99, 100); | |
767 | |
768 uint8 buffer[256]; | |
769 InSequence s; | |
770 | |
771 // PRECONDITION | |
772 WriteUntilThreshold(); | |
773 ConfirmBufferState(0, 10, 10, 10); | |
774 ConfirmLoaderOffsets(10, 0, 0); | |
775 | |
776 // *** TRICKY BUSINESS, PT. III *** | |
777 // Read past forward capacity but within capacity: stop deferring. | |
778 // | |
779 // In order for the read to complete we must: | |
780 // 1) Adjust offset forward to create capacity. | |
781 // 2) Stop deferring to receive more data. | |
782 // | |
783 // BEFORE | |
784 // offset=10 [xxxxxxxxxx] | |
785 // ^^^^ requested 4 bytes @ offset 24 | |
786 // ADJUSTED OFFSET | |
787 // offset=20 [__________] | |
788 // ^^^^ requested 4 bytes @ offset 24 | |
789 // AFTER | |
790 // offset=28 [__________] | |
791 // | |
792 EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoading)); | |
793 ReadLoader(24, 4, buffer); | |
794 ConfirmLoaderOffsets(20, 4, 8); | |
795 | |
796 // Write a little, make sure we didn't start deferring. | |
797 WriteData(4); | |
798 | |
799 // Write the rest, read should complete. | |
800 EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 4)); | |
801 WriteData(4); | |
802 | |
803 // POSTCONDITION | |
804 ConfirmBufferState(8, 10, 0, 10); | |
805 ConfirmLoaderOffsets(28, 0, 0); | |
806 | |
807 StopWhenLoad(); | |
808 } | |
809 | |
810 TEST_F(BufferedResourceLoaderTest, Tricky_LargeReadWithinThreshold) { | |
811 Initialize(kHttpUrl, 10, 99); | |
812 SetLoaderBuffer(10, 10); | |
813 Start(); | |
814 PartialResponse(10, 99, 100); | |
815 | |
816 uint8 buffer[256]; | |
817 InSequence s; | |
818 | |
819 // PRECONDITION | |
820 WriteUntilThreshold(); | |
821 ConfirmBufferState(0, 10, 10, 10); | |
822 ConfirmLoaderOffsets(10, 0, 0); | |
823 | |
824 // *** TRICKY BUSINESS, PT. IV *** | |
825 // Read a large amount past forward capacity but within | |
826 // capacity: stop deferring. | |
827 // | |
828 // In order for the read to complete we must: | |
829 // 1) Adjust offset forward to create capacity. | |
830 // 2) Expand capacity to make sure we don't defer as data arrives. | |
831 // 3) Stop deferring to receive more data. | |
832 // | |
833 // BEFORE | |
834 // offset=10 [xxxxxxxxxx] | |
835 // ^^^^^^^^^^^^ requested 12 bytes @ offset 24 | |
836 // ADJUSTED OFFSET | |
837 // offset=20 [__________] | |
838 // ^^^^^^ ^^^^^^ requested 12 bytes @ offset 24 | |
839 // ADJUSTED CAPACITY | |
840 // offset=20 [________________] | |
841 // ^^^^^^^^^^^^ requested 12 bytes @ offset 24 | |
842 // AFTER | |
843 // offset=36 [__________] | |
844 // | |
845 EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoading)); | |
846 ReadLoader(24, 12, buffer); | |
847 ConfirmLoaderOffsets(20, 4, 16); | |
848 ConfirmBufferState(10, 10, 0, 16); | |
849 | |
850 // Write a little, make sure we didn't start deferring. | |
851 WriteData(10); | |
852 | |
853 // Write the rest, read should complete and capacity should go back to normal. | |
854 EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 12)); | |
855 WriteData(6); | |
856 ConfirmLoaderBufferForwardCapacity(10); | |
857 | |
858 // POSTCONDITION | |
859 ConfirmBufferState(6, 10, 0, 10); | |
860 ConfirmLoaderOffsets(36, 0, 0); | |
861 | |
862 StopWhenLoad(); | |
863 } | |
864 | |
865 TEST_F(BufferedResourceLoaderTest, Tricky_LargeReadBackwards) { | |
866 Initialize(kHttpUrl, 10, 99); | |
867 SetLoaderBuffer(10, 10); | |
868 Start(); | |
869 PartialResponse(10, 99, 100); | |
870 | |
871 uint8 buffer[256]; | |
872 InSequence s; | |
873 | |
874 // PRECONDITION | |
875 WriteUntilThreshold(); | |
876 EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 10)); | |
877 EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoading)); | |
878 ReadLoader(10, 10, buffer); | |
879 WriteUntilThreshold(); | |
880 ConfirmBufferState(10, 10, 10, 10); | |
881 ConfirmLoaderOffsets(20, 0, 0); | |
882 | |
883 // *** TRICKY BUSINESS, PT. V *** | |
884 // Read a large amount that involves backwards data: stop deferring. | |
885 // | |
886 // In order for the read to complete we must: | |
887 // 1) Adjust offset *backwards* to create capacity. | |
888 // 2) Expand capacity to make sure we don't defer as data arrives. | |
889 // 3) Stop deferring to receive more data. | |
890 // | |
891 // BEFORE | |
892 // offset=20 [xxxxxxxxxx|xxxxxxxxxx] | |
893 // ^^^^ ^^^^^^^^^^ ^^^^ requested 18 bytes @ offset 16 | |
894 // ADJUSTED OFFSET | |
895 // offset=16 [____xxxxxx|xxxxxxxxxx]xxxx | |
896 // ^^^^^^^^^^ ^^^^^^^^ requested 18 bytes @ offset 16 | |
897 // ADJUSTED CAPACITY | |
898 // offset=16 [____xxxxxx|xxxxxxxxxxxxxx____] | |
899 // ^^^^^^^^^^^^^^^^^^ requested 18 bytes @ offset 16 | |
900 // AFTER | |
901 // offset=34 [xxxxxxxxxx|__________] | |
902 // | |
903 EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoading)); | |
904 ReadLoader(16, 18, buffer); | |
905 ConfirmLoaderOffsets(16, 0, 18); | |
906 ConfirmBufferState(6, 10, 14, 18); | |
907 | |
908 // Write a little, make sure we didn't start deferring. | |
909 WriteData(2); | |
910 | |
911 // Write the rest, read should complete and capacity should go back to normal. | |
912 EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 18)); | |
913 WriteData(2); | |
914 ConfirmLoaderBufferForwardCapacity(10); | |
915 | |
916 // POSTCONDITION | |
917 ConfirmBufferState(4, 10, 0, 10); | |
918 ConfirmLoaderOffsets(34, 0, 0); | |
919 | |
920 StopWhenLoad(); | |
921 } | |
922 | |
923 TEST_F(BufferedResourceLoaderTest, Tricky_ReadPastThreshold) { | |
924 const int kSize = 5 * 1024 * 1024; | |
925 const int kThreshold = 2 * 1024 * 1024; | |
926 | |
927 Initialize(kHttpUrl, 10, kSize); | |
928 SetLoaderBuffer(10, 10); | |
929 Start(); | |
930 PartialResponse(10, kSize - 1, kSize); | |
931 | |
932 uint8 buffer[256]; | |
933 InSequence s; | |
934 | |
935 // PRECONDITION | |
936 WriteUntilThreshold(); | |
937 ConfirmBufferState(0, 10, 10, 10); | |
938 ConfirmLoaderOffsets(10, 0, 0); | |
939 | |
940 // *** TRICKY BUSINESS, PT. VI *** | |
941 // Read past the forward wait threshold: cache miss. | |
942 // | |
943 // BEFORE | |
944 // offset=10 [xxxxxxxxxx] ... | |
945 // ^^^^ requested 10 bytes @ threshold | |
946 // AFTER | |
947 // offset=10 [xxxxxxxxxx] !!! cache miss !!! | |
948 // | |
949 EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kCacheMiss, 0)); | |
950 ReadLoader(kThreshold + 20, 10, buffer); | |
951 | |
952 // POSTCONDITION | |
953 ConfirmBufferState(0, 10, 10, 10); | |
954 ConfirmLoaderOffsets(10, 0, 0); | |
955 | |
956 StopWhenLoad(); | |
957 } | |
958 | |
959 TEST_F(BufferedResourceLoaderTest, HasSingleOrigin) { | |
960 // Make sure no redirect case works as expected. | |
961 Initialize(kHttpUrl, -1, -1); | |
962 Start(); | |
963 FullResponse(1024); | |
964 EXPECT_TRUE(loader_->HasSingleOrigin()); | |
965 StopWhenLoad(); | |
966 | |
967 // Test redirect to the same domain. | |
968 Initialize(kHttpUrl, -1, -1); | |
969 Start(); | |
970 Redirect(kHttpRedirectToSameDomainUrl1); | |
971 FullResponse(1024); | |
972 EXPECT_TRUE(loader_->HasSingleOrigin()); | |
973 StopWhenLoad(); | |
974 | |
975 // Test redirect twice to the same domain. | |
976 Initialize(kHttpUrl, -1, -1); | |
977 Start(); | |
978 Redirect(kHttpRedirectToSameDomainUrl1); | |
979 Redirect(kHttpRedirectToSameDomainUrl2); | |
980 FullResponse(1024); | |
981 EXPECT_TRUE(loader_->HasSingleOrigin()); | |
982 StopWhenLoad(); | |
983 | |
984 // Test redirect to a different domain. | |
985 Initialize(kHttpUrl, -1, -1); | |
986 Start(); | |
987 Redirect(kHttpRedirectToDifferentDomainUrl1); | |
988 FullResponse(1024); | |
989 EXPECT_FALSE(loader_->HasSingleOrigin()); | |
990 StopWhenLoad(); | |
991 | |
992 // Test redirect to the same domain and then to a different domain. | |
993 Initialize(kHttpUrl, -1, -1); | |
994 Start(); | |
995 Redirect(kHttpRedirectToSameDomainUrl1); | |
996 Redirect(kHttpRedirectToDifferentDomainUrl1); | |
997 FullResponse(1024); | |
998 EXPECT_FALSE(loader_->HasSingleOrigin()); | |
999 StopWhenLoad(); | |
1000 } | |
1001 | |
1002 TEST_F(BufferedResourceLoaderTest, BufferWindow_Default) { | |
1003 Initialize(kHttpUrl, -1, -1); | |
1004 Start(); | |
1005 | |
1006 // Test ensures that default construction of a BufferedResourceLoader has sane | |
1007 // values. | |
1008 // | |
1009 // Please do not change these values in order to make a test pass! Instead, | |
1010 // start a conversation on what the default buffer window capacities should | |
1011 // be. | |
1012 ConfirmLoaderBufferBackwardCapacity(2 * 1024 * 1024); | |
1013 ConfirmLoaderBufferForwardCapacity(2 * 1024 * 1024); | |
1014 | |
1015 StopWhenLoad(); | |
1016 } | |
1017 | |
1018 TEST_F(BufferedResourceLoaderTest, BufferWindow_Bitrate_Unknown) { | |
1019 Initialize(kHttpUrl, -1, -1); | |
1020 Start(); | |
1021 loader_->SetBitrate(0); | |
1022 CheckBufferWindowBounds(); | |
1023 StopWhenLoad(); | |
1024 } | |
1025 | |
1026 TEST_F(BufferedResourceLoaderTest, BufferWindow_Bitrate_BelowLowerBound) { | |
1027 Initialize(kHttpUrl, -1, -1); | |
1028 Start(); | |
1029 loader_->SetBitrate(1024 * 8); // 1 Kbps. | |
1030 CheckBufferWindowBounds(); | |
1031 StopWhenLoad(); | |
1032 } | |
1033 | |
1034 TEST_F(BufferedResourceLoaderTest, BufferWindow_Bitrate_WithinBounds) { | |
1035 Initialize(kHttpUrl, -1, -1); | |
1036 Start(); | |
1037 loader_->SetBitrate(2 * 1024 * 1024 * 8); // 2 Mbps. | |
1038 CheckBufferWindowBounds(); | |
1039 StopWhenLoad(); | |
1040 } | |
1041 | |
1042 TEST_F(BufferedResourceLoaderTest, BufferWindow_Bitrate_AboveUpperBound) { | |
1043 Initialize(kHttpUrl, -1, -1); | |
1044 Start(); | |
1045 loader_->SetBitrate(100 * 1024 * 1024 * 8); // 100 Mbps. | |
1046 CheckBufferWindowBounds(); | |
1047 StopWhenLoad(); | |
1048 } | |
1049 | |
1050 TEST_F(BufferedResourceLoaderTest, BufferWindow_PlaybackRate_Negative) { | |
1051 Initialize(kHttpUrl, -1, -1); | |
1052 Start(); | |
1053 loader_->SetPlaybackRate(-10); | |
1054 CheckBufferWindowBounds(); | |
1055 StopWhenLoad(); | |
1056 } | |
1057 | |
1058 TEST_F(BufferedResourceLoaderTest, BufferWindow_PlaybackRate_Zero) { | |
1059 Initialize(kHttpUrl, -1, -1); | |
1060 Start(); | |
1061 loader_->SetPlaybackRate(0); | |
1062 CheckBufferWindowBounds(); | |
1063 StopWhenLoad(); | |
1064 } | |
1065 | |
1066 TEST_F(BufferedResourceLoaderTest, BufferWindow_PlaybackRate_BelowLowerBound) { | |
1067 Initialize(kHttpUrl, -1, -1); | |
1068 Start(); | |
1069 loader_->SetPlaybackRate(0.1f); | |
1070 CheckBufferWindowBounds(); | |
1071 StopWhenLoad(); | |
1072 } | |
1073 | |
1074 TEST_F(BufferedResourceLoaderTest, BufferWindow_PlaybackRate_WithinBounds) { | |
1075 Initialize(kHttpUrl, -1, -1); | |
1076 Start(); | |
1077 loader_->SetPlaybackRate(10); | |
1078 CheckBufferWindowBounds(); | |
1079 StopWhenLoad(); | |
1080 } | |
1081 | |
1082 TEST_F(BufferedResourceLoaderTest, BufferWindow_PlaybackRate_AboveUpperBound) { | |
1083 Initialize(kHttpUrl, -1, -1); | |
1084 Start(); | |
1085 loader_->SetPlaybackRate(100); | |
1086 CheckBufferWindowBounds(); | |
1087 StopWhenLoad(); | |
1088 } | |
1089 | |
1090 static void ExpectContentRange( | |
1091 const std::string& str, bool expect_success, | |
1092 int64 expected_first, int64 expected_last, int64 expected_size) { | |
1093 int64 first, last, size; | |
1094 ASSERT_EQ(expect_success, BufferedResourceLoader::ParseContentRange( | |
1095 str, &first, &last, &size)) << str; | |
1096 if (!expect_success) | |
1097 return; | |
1098 EXPECT_EQ(first, expected_first); | |
1099 EXPECT_EQ(last, expected_last); | |
1100 EXPECT_EQ(size, expected_size); | |
1101 } | |
1102 | |
1103 static void ExpectContentRangeFailure(const std::string& str) { | |
1104 ExpectContentRange(str, false, 0, 0, 0); | |
1105 } | |
1106 | |
1107 static void ExpectContentRangeSuccess( | |
1108 const std::string& str, | |
1109 int64 expected_first, int64 expected_last, int64 expected_size) { | |
1110 ExpectContentRange(str, true, expected_first, expected_last, expected_size); | |
1111 } | |
1112 | |
1113 TEST(BufferedResourceLoaderStandaloneTest, ParseContentRange) { | |
1114 ExpectContentRangeFailure("cytes 0-499/500"); | |
1115 ExpectContentRangeFailure("bytes 0499/500"); | |
1116 ExpectContentRangeFailure("bytes 0-499500"); | |
1117 ExpectContentRangeFailure("bytes 0-499/500-blorg"); | |
1118 ExpectContentRangeFailure("bytes 0-499/500-1"); | |
1119 ExpectContentRangeFailure("bytes 0-499/400"); | |
1120 ExpectContentRangeFailure("bytes 0-/400"); | |
1121 ExpectContentRangeFailure("bytes -300/400"); | |
1122 ExpectContentRangeFailure("bytes 20-10/400"); | |
1123 | |
1124 ExpectContentRangeSuccess("bytes 0-499/500", 0, 499, 500); | |
1125 ExpectContentRangeSuccess("bytes 0-0/500", 0, 0, 500); | |
1126 ExpectContentRangeSuccess("bytes 10-11/50", 10, 11, 50); | |
1127 ExpectContentRangeSuccess("bytes 10-11/*", 10, 11, | |
1128 kPositionNotSpecified); | |
1129 } | |
1130 | |
1131 } // namespace content | |
OLD | NEW |