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