blob: 04d01ac63f9a53ee0421036a1ae35411988c8884 [file] [log] [blame]
// Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <stdint.h>
#include <algorithm>
#include <string>
#include "base/bind.h"
#include "base/format_macros.h"
#include "base/macros.h"
#include "base/message_loop/message_loop.h"
#include "base/strings/stringprintf.h"
#include "media/base/media_log.h"
#include "media/base/seekable_buffer.h"
#include "media/blink/buffered_resource_loader.h"
#include "media/blink/mock_webframeclient.h"
#include "media/blink/mock_weburlloader.h"
#include "net/base/net_errors.h"
#include "net/http/http_request_headers.h"
#include "net/http/http_util.h"
#include "third_party/WebKit/public/platform/WebString.h"
#include "third_party/WebKit/public/platform/WebURLError.h"
#include "third_party/WebKit/public/platform/WebURLRequest.h"
#include "third_party/WebKit/public/platform/WebURLResponse.h"
#include "third_party/WebKit/public/web/WebLocalFrame.h"
#include "third_party/WebKit/public/web/WebView.h"
using ::testing::_;
using ::testing::InSequence;
using ::testing::Return;
using ::testing::Truly;
using ::testing::NiceMock;
using blink::WebLocalFrame;
using blink::WebString;
using blink::WebURLError;
using blink::WebURLResponse;
using blink::WebView;
namespace media {
static const char* kHttpUrl = "http://test";
static const char kHttpRedirectToSameDomainUrl1[] = "http://test/ing";
static const char kHttpRedirectToSameDomainUrl2[] = "http://test/ing2";
static const char kHttpRedirectToDifferentDomainUrl1[] = "http://test2";
static const int kDataSize = 1024;
static const int kHttpOK = 200;
static const int kHttpPartialContent = 206;
enum NetworkState {
NONE,
LOADED,
LOADING
};
// Predicate that tests that request disallows compressed data.
static bool CorrectAcceptEncoding(const blink::WebURLRequest &request) {
std::string value = request.httpHeaderField(
WebString::fromUTF8(net::HttpRequestHeaders::kAcceptEncoding)).utf8();
return (value.find("identity;q=1") != std::string::npos) &&
(value.find("*;q=0") != std::string::npos);
}
class BufferedResourceLoaderTest : public testing::Test {
public:
BufferedResourceLoaderTest()
: view_(WebView::create(NULL)),
frame_(WebLocalFrame::create(blink::WebTreeScopeType::Document,
&client_)) {
view_->setMainFrame(frame_);
for (int i = 0; i < kDataSize; ++i) {
data_[i] = i;
}
}
virtual ~BufferedResourceLoaderTest() {
view_->close();
frame_->close();
}
void Initialize(const char* url, int first_position, int last_position) {
gurl_ = GURL(url);
first_position_ = first_position;
last_position_ = last_position;
loader_.reset(new BufferedResourceLoader(
gurl_, BufferedResourceLoader::kUnspecified,
first_position_, last_position_,
BufferedResourceLoader::kCapacityDefer, 0, 0,
new MediaLog()));
// |test_loader_| will be used when Start() is called.
url_loader_ = new NiceMock<MockWebURLLoader>();
loader_->test_loader_ = std::unique_ptr<blink::WebURLLoader>(url_loader_);
}
void SetLoaderBuffer(int forward_capacity, int backward_capacity) {
loader_->buffer_.set_forward_capacity(forward_capacity);
loader_->buffer_.set_backward_capacity(backward_capacity);
loader_->buffer_.Clear();
}
void Start() {
InSequence s;
EXPECT_CALL(*url_loader_, loadAsynchronously(Truly(CorrectAcceptEncoding),
loader_.get()));
EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoading));
loader_->Start(
base::Bind(&BufferedResourceLoaderTest::StartCallback,
base::Unretained(this)),
base::Bind(&BufferedResourceLoaderTest::LoadingCallback,
base::Unretained(this)),
base::Bind(&BufferedResourceLoaderTest::ProgressCallback,
base::Unretained(this)),
view_->mainFrame());
}
void FullResponse(int64_t instance_size) {
FullResponse(instance_size, BufferedResourceLoader::kOk);
}
void FullResponse(int64_t instance_size,
BufferedResourceLoader::Status status) {
EXPECT_CALL(*this, StartCallback(status));
WebURLResponse response(gurl_);
response.setHTTPHeaderField(WebString::fromUTF8("Content-Length"),
WebString::fromUTF8(base::StringPrintf("%"
PRId64, instance_size)));
response.setExpectedContentLength(instance_size);
response.setHTTPStatusCode(kHttpOK);
loader_->didReceiveResponse(url_loader_, response);
if (status == BufferedResourceLoader::kOk) {
EXPECT_EQ(instance_size, loader_->content_length());
EXPECT_EQ(instance_size, loader_->instance_size());
}
EXPECT_FALSE(loader_->range_supported());
}
void PartialResponse(int64_t first_position,
int64_t last_position,
int64_t instance_size) {
PartialResponse(first_position, last_position, instance_size, false, true);
}
void PartialResponse(int64_t first_position,
int64_t last_position,
int64_t instance_size,
bool chunked,
bool accept_ranges) {
EXPECT_CALL(*this, StartCallback(BufferedResourceLoader::kOk));
WebURLResponse response(gurl_);
response.setHTTPHeaderField(WebString::fromUTF8("Content-Range"),
WebString::fromUTF8(base::StringPrintf("bytes "
"%" PRId64 "-%" PRId64 "/%" PRId64,
first_position,
last_position,
instance_size)));
// HTTP 1.1 doesn't permit Content-Length with Transfer-Encoding: chunked.
int64_t content_length = -1;
if (chunked) {
response.setHTTPHeaderField(WebString::fromUTF8("Transfer-Encoding"),
WebString::fromUTF8("chunked"));
} else {
content_length = last_position - first_position + 1;
}
response.setExpectedContentLength(content_length);
// A server isn't required to return Accept-Ranges even though it might.
if (accept_ranges) {
response.setHTTPHeaderField(WebString::fromUTF8("Accept-Ranges"),
WebString::fromUTF8("bytes"));
}
response.setHTTPStatusCode(kHttpPartialContent);
loader_->didReceiveResponse(url_loader_, response);
// XXX: what's the difference between these two? For example in the chunked
// range request case, Content-Length is unspecified (because it's chunked)
// but Content-Range: a-b/c can be returned, where c == Content-Length
//
// Can we eliminate one?
EXPECT_EQ(content_length, loader_->content_length());
EXPECT_EQ(instance_size, loader_->instance_size());
// A valid partial response should always result in this being true.
EXPECT_TRUE(loader_->range_supported());
}
void Redirect(const char* url) {
GURL redirectUrl(url);
blink::WebURLRequest newRequest(redirectUrl);
blink::WebURLResponse redirectResponse(gurl_);
loader_->willFollowRedirect(url_loader_, newRequest, redirectResponse);
base::MessageLoop::current()->RunUntilIdle();
}
void StopWhenLoad() {
InSequence s;
EXPECT_CALL(*url_loader_, cancel());
loader_->Stop();
loader_.reset();
}
// Helper method to write to |loader_| from |data_|.
void WriteLoader(int position, int size) {
EXPECT_CALL(*this, ProgressCallback(position + size - 1));
loader_->didReceiveData(url_loader_,
reinterpret_cast<char*>(data_ + position),
size,
size);
}
void WriteData(int size) {
EXPECT_CALL(*this, ProgressCallback(_));
std::unique_ptr<char[]> data(new char[size]);
loader_->didReceiveData(url_loader_, data.get(), size, size);
}
void WriteUntilThreshold() {
int buffered = loader_->buffer_.forward_bytes();
int capacity = loader_->buffer_.forward_capacity();
CHECK_LT(buffered, capacity);
EXPECT_CALL(*this, LoadingCallback(
BufferedResourceLoader::kLoadingDeferred));
WriteData(capacity - buffered);
}
// Helper method to read from |loader_|.
void ReadLoader(int64_t position, int size, uint8_t* buffer) {
loader_->Read(position, size, buffer,
base::Bind(&BufferedResourceLoaderTest::ReadCallback,
base::Unretained(this)));
}
// Verifies that data in buffer[0...size] is equal to data_[pos...pos+size].
void VerifyBuffer(uint8_t* buffer, int pos, int size) {
EXPECT_EQ(0, memcmp(buffer, data_ + pos, size));
}
void ConfirmLoaderOffsets(int64_t expected_offset,
int expected_first_offset,
int expected_last_offset) {
EXPECT_EQ(loader_->offset_, expected_offset);
EXPECT_EQ(loader_->first_offset_, expected_first_offset);
EXPECT_EQ(loader_->last_offset_, expected_last_offset);
}
void ConfirmBufferState(int backward_bytes,
int backward_capacity,
int forward_bytes,
int forward_capacity) {
EXPECT_EQ(backward_bytes, loader_->buffer_.backward_bytes());
EXPECT_EQ(backward_capacity, loader_->buffer_.backward_capacity());
EXPECT_EQ(forward_bytes, loader_->buffer_.forward_bytes());
EXPECT_EQ(forward_capacity, loader_->buffer_.forward_capacity());
EXPECT_EQ(backward_bytes + forward_bytes, loader_->GetMemoryUsage());
}
void ConfirmLoaderBufferBackwardCapacity(int expected_backward_capacity) {
EXPECT_EQ(loader_->buffer_.backward_capacity(),
expected_backward_capacity);
}
void ConfirmLoaderBufferForwardCapacity(int expected_forward_capacity) {
EXPECT_EQ(loader_->buffer_.forward_capacity(), expected_forward_capacity);
}
// Makes sure the |loader_| buffer window is in a reasonable range.
void CheckBufferWindowBounds() {
// Corresponds to value defined in buffered_resource_loader.cc.
static const int kMinBufferCapacity = 2 * 1024 * 1024;
EXPECT_GE(loader_->buffer_.forward_capacity(), kMinBufferCapacity);
EXPECT_GE(loader_->buffer_.backward_capacity(), kMinBufferCapacity);
// Corresponds to value defined in buffered_resource_loader.cc.
static const int kMaxBufferCapacity = 20 * 1024 * 1024;
EXPECT_LE(loader_->buffer_.forward_capacity(), kMaxBufferCapacity);
EXPECT_LE(loader_->buffer_.backward_capacity(), kMaxBufferCapacity);
}
bool HasActiveLoader() { return !!loader_->active_loader_; }
MOCK_METHOD1(StartCallback, void(BufferedResourceLoader::Status));
MOCK_METHOD2(ReadCallback, void(BufferedResourceLoader::Status, int));
MOCK_METHOD1(LoadingCallback, void(BufferedResourceLoader::LoadingState));
MOCK_METHOD1(ProgressCallback, void(int64_t));
protected:
GURL gurl_;
int64_t first_position_;
int64_t last_position_;
std::unique_ptr<BufferedResourceLoader> loader_;
NiceMock<MockWebURLLoader>* url_loader_;
MockWebFrameClient client_;
WebView* view_;
WebLocalFrame* frame_;
base::MessageLoop message_loop_;
uint8_t data_[kDataSize];
private:
DISALLOW_COPY_AND_ASSIGN(BufferedResourceLoaderTest);
};
TEST_F(BufferedResourceLoaderTest, StartStop) {
Initialize(kHttpUrl, -1, -1);
Start();
StopWhenLoad();
}
// Tests that a bad HTTP response is recived, e.g. file not found.
TEST_F(BufferedResourceLoaderTest, BadHttpResponse) {
Initialize(kHttpUrl, -1, -1);
Start();
EXPECT_CALL(*this, StartCallback(BufferedResourceLoader::kFailed));
WebURLResponse response(gurl_);
response.setHTTPStatusCode(404);
response.setHTTPStatusText("Not Found\n");
loader_->didReceiveResponse(url_loader_, response);
StopWhenLoad();
}
// Tests that partial content is requested but not fulfilled.
TEST_F(BufferedResourceLoaderTest, NotPartialResponse) {
Initialize(kHttpUrl, 100, -1);
Start();
FullResponse(1024, BufferedResourceLoader::kFailed);
StopWhenLoad();
}
// Tests that a 200 response is received.
TEST_F(BufferedResourceLoaderTest, FullResponse) {
Initialize(kHttpUrl, -1, -1);
Start();
FullResponse(1024);
StopWhenLoad();
}
// Tests that a partial content response is received.
TEST_F(BufferedResourceLoaderTest, PartialResponse) {
Initialize(kHttpUrl, 100, 200);
Start();
PartialResponse(100, 200, 1024);
StopWhenLoad();
}
TEST_F(BufferedResourceLoaderTest, PartialResponse_Chunked) {
Initialize(kHttpUrl, 100, 200);
Start();
PartialResponse(100, 200, 1024, true, true);
StopWhenLoad();
}
TEST_F(BufferedResourceLoaderTest, PartialResponse_NoAcceptRanges) {
Initialize(kHttpUrl, 100, 200);
Start();
PartialResponse(100, 200, 1024, false, false);
StopWhenLoad();
}
TEST_F(BufferedResourceLoaderTest, PartialResponse_ChunkedNoAcceptRanges) {
Initialize(kHttpUrl, 100, 200);
Start();
PartialResponse(100, 200, 1024, true, false);
StopWhenLoad();
}
// Tests that an invalid partial response is received.
TEST_F(BufferedResourceLoaderTest, InvalidPartialResponse) {
Initialize(kHttpUrl, 0, 10);
Start();
EXPECT_CALL(*this, StartCallback(BufferedResourceLoader::kFailed));
WebURLResponse response(gurl_);
response.setHTTPHeaderField(WebString::fromUTF8("Content-Range"),
WebString::fromUTF8(base::StringPrintf("bytes "
"%d-%d/%d", 1, 10, 1024)));
response.setExpectedContentLength(10);
response.setHTTPStatusCode(kHttpPartialContent);
loader_->didReceiveResponse(url_loader_, response);
StopWhenLoad();
}
// Tests the logic of sliding window for data buffering and reading.
TEST_F(BufferedResourceLoaderTest, BufferAndRead) {
Initialize(kHttpUrl, 10, 29);
loader_->UpdateDeferStrategy(BufferedResourceLoader::kCapacityDefer);
Start();
PartialResponse(10, 29, 30);
uint8_t buffer[10];
InSequence s;
// Writes 10 bytes and read them back.
WriteLoader(10, 10);
EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 10));
ReadLoader(10, 10, buffer);
VerifyBuffer(buffer, 10, 10);
// Writes 10 bytes and read 2 times.
WriteLoader(20, 10);
EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 5));
ReadLoader(20, 5, buffer);
VerifyBuffer(buffer, 20, 5);
EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 5));
ReadLoader(25, 5, buffer);
VerifyBuffer(buffer, 25, 5);
// Read backward within buffer.
EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 10));
ReadLoader(10, 10, buffer);
VerifyBuffer(buffer, 10, 10);
// Read backward outside buffer.
EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kCacheMiss, 0));
ReadLoader(9, 10, buffer);
// Response has completed.
EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoadingFinished));
loader_->didFinishLoading(url_loader_, 0, -1);
// Try to read 10 from position 25 will just return with 5 bytes.
EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 5));
ReadLoader(25, 10, buffer);
VerifyBuffer(buffer, 25, 5);
// Try to read outside buffered range after request has completed.
EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kCacheMiss, 0));
ReadLoader(5, 10, buffer);
// Try to read beyond the instance size.
EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 0));
ReadLoader(30, 10, buffer);
}
// Tests the logic of expanding the data buffer for large reads.
TEST_F(BufferedResourceLoaderTest, ReadExtendBuffer) {
Initialize(kHttpUrl, 10, 0x014FFFFFF);
SetLoaderBuffer(10, 20);
Start();
PartialResponse(10, 0x014FFFFFF, 0x015000000);
uint8_t buffer[20];
InSequence s;
// Write more than forward capacity and read it back. Ensure forward capacity
// gets reset after reading.
EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoadingDeferred));
WriteLoader(10, 20);
EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 20));
EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoading));
ReadLoader(10, 20, buffer);
VerifyBuffer(buffer, 10, 20);
ConfirmLoaderBufferForwardCapacity(10);
// Make and outstanding read request larger than forward capacity. Ensure
// forward capacity gets extended.
ReadLoader(30, 20, buffer);
ConfirmLoaderBufferForwardCapacity(20);
// Fulfill outstanding request. Ensure forward capacity gets reset.
EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 20));
WriteLoader(30, 20);
VerifyBuffer(buffer, 30, 20);
ConfirmLoaderBufferForwardCapacity(10);
// Try to read further ahead than kForwardWaitThreshold allows. Ensure
// forward capacity is not changed.
EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kCacheMiss, 0));
ReadLoader(0x00300000, 1, buffer);
ConfirmLoaderBufferForwardCapacity(10);
// Try to read more than maximum forward capacity. Ensure forward capacity is
// not changed.
EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kFailed, 0));
ReadLoader(30, 0x01400001, buffer);
ConfirmLoaderBufferForwardCapacity(10);
StopWhenLoad();
}
TEST_F(BufferedResourceLoaderTest, ReadOutsideBuffer) {
Initialize(kHttpUrl, 10, 0x00FFFFFF);
Start();
PartialResponse(10, 0x00FFFFFF, 0x01000000);
uint8_t buffer[10];
InSequence s;
// Read very far ahead will get a cache miss.
EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kCacheMiss, 0));
ReadLoader(0x00FFFFFF, 1, buffer);
// The following call will not call ReadCallback() because it is waiting for
// data to arrive.
ReadLoader(10, 10, buffer);
// Writing to loader will fulfill the read request.
EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 10));
WriteLoader(10, 20);
VerifyBuffer(buffer, 10, 10);
// The following call cannot be fulfilled now.
ReadLoader(25, 10, buffer);
EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoadingFinished));
EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 5));
loader_->didFinishLoading(url_loader_, 0, -1);
}
TEST_F(BufferedResourceLoaderTest, RequestFailedWhenRead) {
Initialize(kHttpUrl, 10, 29);
Start();
PartialResponse(10, 29, 30);
uint8_t buffer[10];
InSequence s;
// We should convert any error we receive to BufferedResourceLoader::kFailed.
ReadLoader(10, 10, buffer);
EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoadingFailed));
EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kFailed, 0));
WebURLError error;
error.reason = net::ERR_TIMED_OUT;
error.isCancellation = false;
loader_->didFail(url_loader_, error);
}
TEST_F(BufferedResourceLoaderTest, RequestFailedWithNoPendingReads) {
Initialize(kHttpUrl, 10, 29);
Start();
PartialResponse(10, 29, 30);
uint8_t buffer[10];
InSequence s;
// Write enough data so that a read would technically complete had the request
// not failed.
WriteLoader(10, 20);
// Fail without a pending read.
WebURLError error;
error.reason = net::ERR_TIMED_OUT;
error.isCancellation = false;
EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoadingFailed));
loader_->didFail(url_loader_, error);
// Now we should immediately fail any read even if we have data buffered.
EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kFailed, 0));
ReadLoader(10, 10, buffer);
}
TEST_F(BufferedResourceLoaderTest, RequestCancelledWhenRead) {
Initialize(kHttpUrl, 10, 29);
Start();
PartialResponse(10, 29, 30);
uint8_t buffer[10];
InSequence s;
// We should convert any error we receive to BufferedResourceLoader::kFailed.
ReadLoader(10, 10, buffer);
EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoadingFailed));
EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kFailed, 0));
WebURLError error;
error.reason = 0;
error.isCancellation = true;
loader_->didFail(url_loader_, error);
}
// Tests the data buffering logic of NeverDefer strategy.
TEST_F(BufferedResourceLoaderTest, NeverDeferStrategy) {
Initialize(kHttpUrl, 10, 99);
SetLoaderBuffer(10, 20);
loader_->UpdateDeferStrategy(BufferedResourceLoader::kNeverDefer);
Start();
PartialResponse(10, 99, 100);
uint8_t buffer[10];
// Read past the buffer size; should not defer regardless.
WriteLoader(10, 10);
WriteLoader(20, 50);
// Should move past window.
EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kCacheMiss, 0));
ReadLoader(10, 10, buffer);
StopWhenLoad();
}
// Tests the data buffering logic of ReadThenDefer strategy.
TEST_F(BufferedResourceLoaderTest, ReadThenDeferStrategy) {
Initialize(kHttpUrl, 10, 99);
SetLoaderBuffer(10, 20);
loader_->UpdateDeferStrategy(BufferedResourceLoader::kReadThenDefer);
Start();
PartialResponse(10, 99, 100);
uint8_t buffer[10];
// Make an outstanding read request.
ReadLoader(10, 10, buffer);
// Receive almost enough data to cover, shouldn't defer.
WriteLoader(10, 9);
// As soon as we have received enough data to fulfill the read, defer.
EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoadingDeferred));
EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 10));
WriteLoader(19, 1);
VerifyBuffer(buffer, 10, 10);
// Read again which should disable deferring since there should be nothing
// left in our internal buffer.
EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoading));
ReadLoader(20, 10, buffer);
// Over-fulfill requested bytes, then deferring should be enabled again.
EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoadingDeferred));
EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 10));
WriteLoader(20, 40);
VerifyBuffer(buffer, 20, 10);
// Read far ahead, which should disable deferring. In this case we still have
// bytes in our internal buffer.
EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoading));
ReadLoader(80, 10, buffer);
// Fulfill requested bytes, then deferring should be enabled again.
EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoadingDeferred));
EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 10));
WriteLoader(60, 40);
VerifyBuffer(buffer, 80, 10);
StopWhenLoad();
}
// Tests the data buffering logic of kCapacityDefer strategy.
TEST_F(BufferedResourceLoaderTest, ThresholdDeferStrategy) {
Initialize(kHttpUrl, 10, 99);
SetLoaderBuffer(10, 20);
Start();
PartialResponse(10, 99, 100);
uint8_t buffer[10];
InSequence s;
// Write half of capacity: keep not deferring.
WriteData(5);
// Write rest of space until capacity: start deferring.
EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoadingDeferred));
WriteData(5);
// Read a byte from the buffer: stop deferring.
EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 1));
EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoading));
ReadLoader(10, 1, buffer);
// Write a byte to hit capacity: start deferring.
EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoadingDeferred));
WriteData(6);
StopWhenLoad();
}
TEST_F(BufferedResourceLoaderTest, Tricky_ReadForwardsPastBuffered) {
Initialize(kHttpUrl, 10, 99);
SetLoaderBuffer(10, 10);
Start();
PartialResponse(10, 99, 100);
uint8_t buffer[256];
InSequence s;
// PRECONDITION
WriteUntilThreshold();
EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 1));
EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoading));
ReadLoader(10, 1, buffer);
ConfirmBufferState(1, 10, 9, 10);
ConfirmLoaderOffsets(11, 0, 0);
// *** TRICKY BUSINESS, PT. I ***
// Read past buffered: stop deferring.
//
// In order for the read to complete we must:
// 1) Stop deferring to receive more data.
//
// BEFORE
// offset=11 [xxxxxxxxx_]
// ^ ^^^ requested 4 bytes @ offset 20
// AFTER
// offset=24 [__________]
//
ReadLoader(20, 4, buffer);
// Write a little, make sure we didn't start deferring.
WriteData(2);
// Write the rest, read should complete.
EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 4));
WriteData(2);
// POSTCONDITION
ConfirmBufferState(4, 10, 0, 10);
ConfirmLoaderOffsets(24, 0, 0);
StopWhenLoad();
}
TEST_F(BufferedResourceLoaderTest, Tricky_ReadBackwardsPastBuffered) {
Initialize(kHttpUrl, 10, 99);
SetLoaderBuffer(10, 10);
Start();
PartialResponse(10, 99, 100);
uint8_t buffer[256];
InSequence s;
// PRECONDITION
WriteUntilThreshold();
ConfirmBufferState(0, 10, 10, 10);
ConfirmLoaderOffsets(10, 0, 0);
// *** TRICKY BUSINESS, PT. II ***
// Read backwards a little too much: cache miss.
//
// BEFORE
// offset=10 [__________|xxxxxxxxxx]
// ^ ^^^ requested 10 bytes @ offset 9
// AFTER
// offset=10 [__________|xxxxxxxxxx] !!! cache miss !!!
//
EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kCacheMiss, 0));
ReadLoader(9, 4, buffer);
// POSTCONDITION
ConfirmBufferState(0, 10, 10, 10);
ConfirmLoaderOffsets(10, 0, 0);
StopWhenLoad();
}
TEST_F(BufferedResourceLoaderTest, Tricky_SmallReadWithinThreshold) {
Initialize(kHttpUrl, 10, 99);
SetLoaderBuffer(10, 10);
Start();
PartialResponse(10, 99, 100);
uint8_t buffer[256];
InSequence s;
// PRECONDITION
WriteUntilThreshold();
ConfirmBufferState(0, 10, 10, 10);
ConfirmLoaderOffsets(10, 0, 0);
// *** TRICKY BUSINESS, PT. III ***
// Read past forward capacity but within capacity: stop deferring.
//
// In order for the read to complete we must:
// 1) Adjust offset forward to create capacity.
// 2) Stop deferring to receive more data.
//
// BEFORE
// offset=10 [xxxxxxxxxx]
// ^^^^ requested 4 bytes @ offset 24
// ADJUSTED OFFSET
// offset=20 [__________]
// ^^^^ requested 4 bytes @ offset 24
// AFTER
// offset=28 [__________]
//
EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoading));
ReadLoader(24, 4, buffer);
ConfirmLoaderOffsets(20, 4, 8);
// Write a little, make sure we didn't start deferring.
WriteData(4);
// Write the rest, read should complete.
EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 4));
WriteData(4);
// POSTCONDITION
ConfirmBufferState(8, 10, 0, 10);
ConfirmLoaderOffsets(28, 0, 0);
StopWhenLoad();
}
TEST_F(BufferedResourceLoaderTest, Tricky_LargeReadWithinThreshold) {
Initialize(kHttpUrl, 10, 99);
SetLoaderBuffer(10, 10);
Start();
PartialResponse(10, 99, 100);
uint8_t buffer[256];
InSequence s;
// PRECONDITION
WriteUntilThreshold();
ConfirmBufferState(0, 10, 10, 10);
ConfirmLoaderOffsets(10, 0, 0);
// *** TRICKY BUSINESS, PT. IV ***
// Read a large amount past forward capacity but within
// capacity: stop deferring.
//
// In order for the read to complete we must:
// 1) Adjust offset forward to create capacity.
// 2) Expand capacity to make sure we don't defer as data arrives.
// 3) Stop deferring to receive more data.
//
// BEFORE
// offset=10 [xxxxxxxxxx]
// ^^^^^^^^^^^^ requested 12 bytes @ offset 24
// ADJUSTED OFFSET
// offset=20 [__________]
// ^^^^^^ ^^^^^^ requested 12 bytes @ offset 24
// ADJUSTED CAPACITY
// offset=20 [________________]
// ^^^^^^^^^^^^ requested 12 bytes @ offset 24
// AFTER
// offset=36 [__________]
//
EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoading));
ReadLoader(24, 12, buffer);
ConfirmLoaderOffsets(20, 4, 16);
ConfirmBufferState(10, 10, 0, 16);
// Write a little, make sure we didn't start deferring.
WriteData(10);
// Write the rest, read should complete and capacity should go back to normal.
EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 12));
WriteData(6);
ConfirmLoaderBufferForwardCapacity(10);
// POSTCONDITION
ConfirmBufferState(6, 10, 0, 10);
ConfirmLoaderOffsets(36, 0, 0);
StopWhenLoad();
}
TEST_F(BufferedResourceLoaderTest, Tricky_LargeReadBackwards) {
Initialize(kHttpUrl, 10, 99);
SetLoaderBuffer(10, 10);
Start();
PartialResponse(10, 99, 100);
uint8_t buffer[256];
InSequence s;
// PRECONDITION
WriteUntilThreshold();
EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 10));
EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoading));
ReadLoader(10, 10, buffer);
WriteUntilThreshold();
ConfirmBufferState(10, 10, 10, 10);
ConfirmLoaderOffsets(20, 0, 0);
// *** TRICKY BUSINESS, PT. V ***
// Read a large amount that involves backwards data: stop deferring.
//
// In order for the read to complete we must:
// 1) Adjust offset *backwards* to create capacity.
// 2) Expand capacity to make sure we don't defer as data arrives.
// 3) Stop deferring to receive more data.
//
// BEFORE
// offset=20 [xxxxxxxxxx|xxxxxxxxxx]
// ^^^^ ^^^^^^^^^^ ^^^^ requested 18 bytes @ offset 16
// ADJUSTED OFFSET
// offset=16 [____xxxxxx|xxxxxxxxxx]xxxx
// ^^^^^^^^^^ ^^^^^^^^ requested 18 bytes @ offset 16
// ADJUSTED CAPACITY
// offset=16 [____xxxxxx|xxxxxxxxxxxxxx____]
// ^^^^^^^^^^^^^^^^^^ requested 18 bytes @ offset 16
// AFTER
// offset=34 [xxxxxxxxxx|__________]
//
EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoading));
ReadLoader(16, 18, buffer);
ConfirmLoaderOffsets(16, 0, 18);
ConfirmBufferState(6, 10, 14, 18);
// Write a little, make sure we didn't start deferring.
WriteData(2);
// Write the rest, read should complete and capacity should go back to normal.
EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 18));
WriteData(2);
ConfirmLoaderBufferForwardCapacity(10);
// POSTCONDITION
ConfirmBufferState(4, 10, 0, 10);
ConfirmLoaderOffsets(34, 0, 0);
StopWhenLoad();
}
TEST_F(BufferedResourceLoaderTest, Tricky_ReadPastThreshold) {
const int kSize = 5 * 1024 * 1024;
const int kThreshold = 2 * 1024 * 1024;
Initialize(kHttpUrl, 10, kSize);
SetLoaderBuffer(10, 10);
Start();
PartialResponse(10, kSize - 1, kSize);
uint8_t buffer[256];
InSequence s;
// PRECONDITION
WriteUntilThreshold();
ConfirmBufferState(0, 10, 10, 10);
ConfirmLoaderOffsets(10, 0, 0);
// *** TRICKY BUSINESS, PT. VI ***
// Read past the forward wait threshold: cache miss.
//
// BEFORE
// offset=10 [xxxxxxxxxx] ...
// ^^^^ requested 10 bytes @ threshold
// AFTER
// offset=10 [xxxxxxxxxx] !!! cache miss !!!
//
EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kCacheMiss, 0));
ReadLoader(kThreshold + 20, 10, buffer);
// POSTCONDITION
ConfirmBufferState(0, 10, 10, 10);
ConfirmLoaderOffsets(10, 0, 0);
StopWhenLoad();
}
TEST_F(BufferedResourceLoaderTest, HasSingleOrigin) {
// Make sure no redirect case works as expected.
Initialize(kHttpUrl, -1, -1);
Start();
FullResponse(1024);
EXPECT_TRUE(loader_->HasSingleOrigin());
StopWhenLoad();
// Test redirect to the same domain.
Initialize(kHttpUrl, -1, -1);
Start();
Redirect(kHttpRedirectToSameDomainUrl1);
FullResponse(1024);
EXPECT_TRUE(loader_->HasSingleOrigin());
StopWhenLoad();
// Test redirect twice to the same domain.
Initialize(kHttpUrl, -1, -1);
Start();
Redirect(kHttpRedirectToSameDomainUrl1);
Redirect(kHttpRedirectToSameDomainUrl2);
FullResponse(1024);
EXPECT_TRUE(loader_->HasSingleOrigin());
StopWhenLoad();
// Test redirect to a different domain.
Initialize(kHttpUrl, -1, -1);
Start();
Redirect(kHttpRedirectToDifferentDomainUrl1);
FullResponse(1024);
EXPECT_FALSE(loader_->HasSingleOrigin());
StopWhenLoad();
// Test redirect to the same domain and then to a different domain.
Initialize(kHttpUrl, -1, -1);
Start();
Redirect(kHttpRedirectToSameDomainUrl1);
Redirect(kHttpRedirectToDifferentDomainUrl1);
FullResponse(1024);
EXPECT_FALSE(loader_->HasSingleOrigin());
StopWhenLoad();
}
TEST_F(BufferedResourceLoaderTest, BufferWindow_Default) {
Initialize(kHttpUrl, -1, -1);
Start();
// Test ensures that default construction of a BufferedResourceLoader has sane
// values.
//
// Please do not change these values in order to make a test pass! Instead,
// start a conversation on what the default buffer window capacities should
// be.
ConfirmLoaderBufferBackwardCapacity(2 * 1024 * 1024);
ConfirmLoaderBufferForwardCapacity(2 * 1024 * 1024);
StopWhenLoad();
}
TEST_F(BufferedResourceLoaderTest, BufferWindow_Bitrate_Unknown) {
Initialize(kHttpUrl, -1, -1);
Start();
loader_->SetBitrate(0);
CheckBufferWindowBounds();
StopWhenLoad();
}
TEST_F(BufferedResourceLoaderTest, BufferWindow_Bitrate_BelowLowerBound) {
Initialize(kHttpUrl, -1, -1);
Start();
loader_->SetBitrate(1024 * 8); // 1 Kbps.
CheckBufferWindowBounds();
StopWhenLoad();
}
TEST_F(BufferedResourceLoaderTest, BufferWindow_Bitrate_WithinBounds) {
Initialize(kHttpUrl, -1, -1);
Start();
loader_->SetBitrate(2 * 1024 * 1024 * 8); // 2 Mbps.
CheckBufferWindowBounds();
StopWhenLoad();
}
TEST_F(BufferedResourceLoaderTest, BufferWindow_Bitrate_AboveUpperBound) {
Initialize(kHttpUrl, -1, -1);
Start();
loader_->SetBitrate(100 * 1024 * 1024 * 8); // 100 Mbps.
CheckBufferWindowBounds();
StopWhenLoad();
}
TEST_F(BufferedResourceLoaderTest, BufferWindow_PlaybackRate_Negative) {
Initialize(kHttpUrl, -1, -1);
Start();
loader_->SetPlaybackRate(-10);
CheckBufferWindowBounds();
StopWhenLoad();
}
TEST_F(BufferedResourceLoaderTest, BufferWindow_PlaybackRate_Zero) {
Initialize(kHttpUrl, -1, -1);
Start();
loader_->SetPlaybackRate(0);
CheckBufferWindowBounds();
StopWhenLoad();
}
TEST_F(BufferedResourceLoaderTest, BufferWindow_PlaybackRate_BelowLowerBound) {
Initialize(kHttpUrl, -1, -1);
Start();
loader_->SetPlaybackRate(0.1);
CheckBufferWindowBounds();
StopWhenLoad();
}
TEST_F(BufferedResourceLoaderTest, BufferWindow_PlaybackRate_WithinBounds) {
Initialize(kHttpUrl, -1, -1);
Start();
loader_->SetPlaybackRate(10);
CheckBufferWindowBounds();
StopWhenLoad();
}
TEST_F(BufferedResourceLoaderTest, BufferWindow_PlaybackRate_AboveUpperBound) {
Initialize(kHttpUrl, -1, -1);
Start();
loader_->SetPlaybackRate(100);
CheckBufferWindowBounds();
StopWhenLoad();
}
static void ExpectContentRange(const std::string& str,
bool expect_success,
int64_t expected_first,
int64_t expected_last,
int64_t expected_size) {
int64_t first, last, size;
ASSERT_EQ(expect_success, BufferedResourceLoader::ParseContentRange(
str, &first, &last, &size)) << str;
if (!expect_success)
return;
EXPECT_EQ(first, expected_first);
EXPECT_EQ(last, expected_last);
EXPECT_EQ(size, expected_size);
}
static void ExpectContentRangeFailure(const std::string& str) {
ExpectContentRange(str, false, 0, 0, 0);
}
static void ExpectContentRangeSuccess(const std::string& str,
int64_t expected_first,
int64_t expected_last,
int64_t expected_size) {
ExpectContentRange(str, true, expected_first, expected_last, expected_size);
}
TEST(BufferedResourceLoaderStandaloneTest, ParseContentRange) {
ExpectContentRangeFailure("cytes 0-499/500");
ExpectContentRangeFailure("bytes 0499/500");
ExpectContentRangeFailure("bytes 0-499500");
ExpectContentRangeFailure("bytes 0-499/500-blorg");
ExpectContentRangeFailure("bytes 0-499/500-1");
ExpectContentRangeFailure("bytes 0-499/400");
ExpectContentRangeFailure("bytes 0-/400");
ExpectContentRangeFailure("bytes -300/400");
ExpectContentRangeFailure("bytes 20-10/400");
ExpectContentRangeSuccess("bytes 0-499/500", 0, 499, 500);
ExpectContentRangeSuccess("bytes 0-0/500", 0, 0, 500);
ExpectContentRangeSuccess("bytes 10-11/50", 10, 11, 50);
ExpectContentRangeSuccess("bytes 10-11/*", 10, 11,
kPositionNotSpecified);
}
// Tests the data buffering logic of ReadThenDefer strategy.
TEST_F(BufferedResourceLoaderTest, CancelAfterDeferral) {
Initialize(kHttpUrl, 10, 99);
SetLoaderBuffer(10, 20);
loader_->UpdateDeferStrategy(BufferedResourceLoader::kReadThenDefer);
loader_->CancelUponDeferral();
Start();
PartialResponse(10, 99, 100);
uint8_t buffer[10];
// Make an outstanding read request.
ReadLoader(10, 10, buffer);
// Receive almost enough data to cover, shouldn't defer.
WriteLoader(10, 9);
EXPECT_TRUE(HasActiveLoader());
// As soon as we have received enough data to fulfill the read, defer.
EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoadingDeferred));
EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 10));
WriteLoader(19, 1);
VerifyBuffer(buffer, 10, 10);
EXPECT_FALSE(HasActiveLoader());
}
} // namespace media