webkit/media/buffered_resource_loader_unittest.cc - Issue 10692106: Split BufferedResourceLoader's network callback into separate loading state and progress callbacks.

Unified Diff: webkit/media/buffered_resource_loader_unittest.cc

Issue 10692106: Split BufferedResourceLoader's network callback into separate loading state and progress callbacks. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src

Patch Set: add bug #s Created 8 years, 5 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

Index: webkit/media/buffered_resource_loader_unittest.cc

diff --git a/webkit/media/buffered_resource_loader_unittest.cc b/webkit/media/buffered_resource_loader_unittest.cc

index 541c5a8c1cb8d5a8755de1dd376730c64ebc0005..6274199a31133b7c98bd37756808d4defb2064e4 100644

--- a/webkit/media/buffered_resource_loader_unittest.cc

+++ b/webkit/media/buffered_resource_loader_unittest.cc

@@ -24,6 +24,7 @@

#include "webkit/mocks/mock_webframeclient.h"

#include "webkit/mocks/mock_weburlloader.h"

+using ::testing::_;

using ::testing::InSequence;

using ::testing::Return;

using ::testing::Truly;

@@ -103,10 +104,14 @@ class BufferedResourceLoaderTest : public testing::Test {

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::NetworkCallback,

+ base::Bind(&BufferedResourceLoaderTest::LoadingCallback,

+ base::Unretained(this)),

+ base::Bind(&BufferedResourceLoaderTest::ProgressCallback,

base::Unretained(this)),

view_->mainFrame());

}

@@ -202,8 +207,7 @@ class BufferedResourceLoaderTest : public testing::Test {

// Helper method to write to |loader_| from |data_|.

void WriteLoader(int position, int size) {

- EXPECT_CALL(*this, NetworkCallback())

- .RetiresOnSaturation();

+ EXPECT_CALL(*this, ProgressCallback(position + size - 1));

loader_->didReceiveData(url_loader_,

reinterpret_cast<char*>(data_ + position),

size,

@@ -211,8 +215,7 @@ class BufferedResourceLoaderTest : public testing::Test {

}

void WriteData(int size) {

- EXPECT_CALL(*this, NetworkCallback())

- .RetiresOnSaturation();

+ EXPECT_CALL(*this, ProgressCallback(_));

scoped_array<char> data(new char[size]);

loader_->didReceiveData(url_loader_, data.get(), size, size);

@@ -223,9 +226,9 @@ class BufferedResourceLoaderTest : public testing::Test {

int capacity = loader_->buffer_.forward_capacity();

CHECK_LT(buffered, capacity);

- EXPECT_CALL(*this, NetworkCallback());

+ EXPECT_CALL(*this, LoadingCallback(

+ BufferedResourceLoader::kLoadingDeferred));

WriteData(capacity - buffered);

- ConfirmLoaderDeferredState(true);

}

// Helper method to read from |loader_|.

@@ -267,10 +270,6 @@ class BufferedResourceLoaderTest : public testing::Test {

EXPECT_EQ(loader_->buffer_.forward_capacity(), expected_forward_capacity);

}

- void ConfirmLoaderDeferredState(bool expectedVal) {

- EXPECT_EQ(loader_->active_loader_->deferred(), expectedVal);

Ami GONE FROM CHROMIUM 2012/07/09 00:25:46 Does allow de-friend'ing some tests from BRL?

scherkus (not reviewing) 2012/07/09 18:53:30 Not yet -- BRL is my experiment in friending all o

- }

// Makes sure the |loader_| buffer window is in a reasonable range.

void CheckBufferWindowBounds() {

// Corresponds to value defined in buffered_resource_loader.cc.

@@ -286,7 +285,8 @@ class BufferedResourceLoaderTest : public testing::Test {

MOCK_METHOD1(StartCallback, void(BufferedResourceLoader::Status));

MOCK_METHOD2(ReadCallback, void(BufferedResourceLoader::Status, int));

- MOCK_METHOD0(NetworkCallback, void());

+ MOCK_METHOD1(LoadingCallback, void(BufferedResourceLoader::LoadingState));

+ MOCK_METHOD1(ProgressCallback, void(int64));

// Accessors for private variables on |loader_|.

int forward_bytes() { return loader_->buffer_.forward_bytes(); }

@@ -428,7 +428,7 @@ TEST_F(BufferedResourceLoaderTest, BufferAndRead) {

ReadLoader(9, 10, buffer);

// Response has completed.

- EXPECT_CALL(*this, NetworkCallback());

+ EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoadingFinished));

loader_->didFinishLoading(url_loader_, 0);

// Try to read 10 from position 25 will just return with 5 bytes.

@@ -452,17 +452,16 @@ TEST_F(BufferedResourceLoaderTest, ReadExtendBuffer) {

Start();

PartialResponse(10, 0x014FFFFFF, 0x015000000);

- // Don't test for network callbacks (covered by *Strategy tests).

- EXPECT_CALL(*this, NetworkCallback())

- .WillRepeatedly(Return());

uint8 buffer[20];

InSequence s;

// Write more than forward capacity and read it back. Ensure forward capacity

- // gets reset.

+ // 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);

@@ -471,7 +470,6 @@ TEST_F(BufferedResourceLoaderTest, ReadExtendBuffer) {

// 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.

@@ -522,7 +520,7 @@ TEST_F(BufferedResourceLoaderTest, ReadOutsideBuffer) {

// The following call cannot be fulfilled now.

ReadLoader(25, 10, buffer);

- EXPECT_CALL(*this, NetworkCallback());

+ EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoadingFinished));

EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 5));

loader_->didFinishLoading(url_loader_, 0);

}

@@ -537,7 +535,7 @@ TEST_F(BufferedResourceLoaderTest, RequestFailedWhenRead) {

// We should convert any error we receive to BufferedResourceLoader::kFailed.

ReadLoader(10, 10, buffer);

- EXPECT_CALL(*this, NetworkCallback());

+ EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoadingFailed));

EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kFailed, 0));

WebURLError error;

error.reason = net::ERR_TIMED_OUT;

@@ -561,7 +559,7 @@ TEST_F(BufferedResourceLoaderTest, RequestFailedWithNoPendingReads) {

WebURLError error;

error.reason = net::ERR_TIMED_OUT;

error.isCancellation = false;

- EXPECT_CALL(*this, NetworkCallback());

+ EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoadingFailed));

loader_->didFail(url_loader_, error);

// Now we should immediately fail any read even if we have data buffered.

@@ -579,7 +577,7 @@ TEST_F(BufferedResourceLoaderTest, RequestCancelledWhenRead) {

// We should convert any error we receive to BufferedResourceLoader::kFailed.

ReadLoader(10, 10, buffer);

- EXPECT_CALL(*this, NetworkCallback());

+ EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoadingFailed));

EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kFailed, 0));

WebURLError error;

error.reason = 0;

@@ -600,7 +598,6 @@ TEST_F(BufferedResourceLoaderTest, NeverDeferStrategy) {

// Read past the buffer size; should not defer regardless.

WriteLoader(10, 10);

WriteLoader(20, 50);

- ConfirmLoaderDeferredState(false);

// Should move past window.

EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kCacheMiss, 0));

@@ -624,44 +621,36 @@ TEST_F(BufferedResourceLoaderTest, ReadThenDeferStrategy) {

// Receive almost enough data to cover, shouldn't defer.

WriteLoader(10, 9);

- ConfirmLoaderDeferredState(false);

// As soon as we have received enough data to fulfill the read, defer.

- EXPECT_CALL(*this, NetworkCallback());

+ EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoadingDeferred));

EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 10));

WriteLoader(19, 1);

- ConfirmLoaderDeferredState(true);

VerifyBuffer(buffer, 10, 10);

// Read again which should disable deferring since there should be nothing

// left in our internal buffer.

- EXPECT_CALL(*this, NetworkCallback());

+ EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoading));

ReadLoader(20, 10, buffer);

- ConfirmLoaderDeferredState(false);

// Over-fulfill requested bytes, then deferring should be enabled again.

- EXPECT_CALL(*this, NetworkCallback());

+ EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoadingDeferred));

EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 10));

WriteLoader(20, 40);

- ConfirmLoaderDeferredState(true);

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, NetworkCallback());

+ EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoading));

ReadLoader(80, 10, buffer);

- ConfirmLoaderDeferredState(false);

// Fulfill requested bytes, then deferring should be enabled again.

- EXPECT_CALL(*this, NetworkCallback());

+ EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoadingDeferred));

EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 10));

WriteLoader(60, 40);

- ConfirmLoaderDeferredState(true);

VerifyBuffer(buffer, 80, 10);

StopWhenLoad();

@@ -677,38 +666,29 @@ TEST_F(BufferedResourceLoaderTest, ThresholdDeferStrategy) {

uint8 buffer[10];

InSequence s;

- // Initial expectation: we're not deferring.

- ConfirmLoaderDeferredState(false);

// Write half of threshold: keep not deferring.

WriteData(5);

- ConfirmLoaderDeferredState(false);

// Write rest of space until threshold: start deferring.

- EXPECT_CALL(*this, NetworkCallback());

+ EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoadingDeferred));

WriteData(5);

- ConfirmLoaderDeferredState(true);

// Read a little from the buffer: keep deferring.

EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 1));

ReadLoader(10, 1, buffer);

- ConfirmLoaderDeferredState(true);

// Read a little more and go under threshold: stop deferring.

EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 4));

- EXPECT_CALL(*this, NetworkCallback());

+ EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoading));

ReadLoader(12, 4, buffer);

- ConfirmLoaderDeferredState(false);

// Write rest of space until threshold: start deferring.

- EXPECT_CALL(*this, NetworkCallback());

+ EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoadingDeferred));

WriteData(6);

- ConfirmLoaderDeferredState(true);

// Read a little from the buffer: keep deferring.

EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 1));

ReadLoader(16, 1, buffer);

- ConfirmLoaderDeferredState(true);

StopWhenLoad();

}

@@ -728,7 +708,6 @@ TEST_F(BufferedResourceLoaderTest, Tricky_ReadForwardsPastBuffered) {

ReadLoader(10, 1, buffer);

ConfirmBufferState(1, 10, 9, 10);

ConfirmLoaderOffsets(11, 0, 0);

- ConfirmLoaderDeferredState(true);

// *** TRICKY BUSINESS, PT. I ***

// Read past buffered: stop deferring.

@@ -742,23 +721,19 @@ TEST_F(BufferedResourceLoaderTest, Tricky_ReadForwardsPastBuffered) {

// AFTER

// offset=24 [__________]

- EXPECT_CALL(*this, NetworkCallback());

+ EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoading));

ReadLoader(20, 4, buffer);

- ConfirmLoaderDeferredState(false);

// Write a little, make sure we didn't start deferring.

WriteData(2);

- ConfirmLoaderDeferredState(false);

// Write the rest, read should complete.

EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 4));

WriteData(2);

- ConfirmLoaderDeferredState(false);

// POSTCONDITION

ConfirmBufferState(4, 10, 0, 10);

ConfirmLoaderOffsets(24, 0, 0);

- ConfirmLoaderDeferredState(false);

StopWhenLoad();

}

@@ -776,7 +751,6 @@ TEST_F(BufferedResourceLoaderTest, Tricky_ReadBackwardsPastBuffered) {

WriteUntilThreshold();

ConfirmBufferState(0, 10, 10, 10);

ConfirmLoaderOffsets(10, 0, 0);

- ConfirmLoaderDeferredState(true);

// *** TRICKY BUSINESS, PT. II ***

// Read backwards a little too much: cache miss.

@@ -793,7 +767,6 @@ TEST_F(BufferedResourceLoaderTest, Tricky_ReadBackwardsPastBuffered) {

// POSTCONDITION

ConfirmBufferState(0, 10, 10, 10);

ConfirmLoaderOffsets(10, 0, 0);

- ConfirmLoaderDeferredState(true);

StopWhenLoad();

}

@@ -811,7 +784,6 @@ TEST_F(BufferedResourceLoaderTest, Tricky_SmallReadWithinThreshold) {

WriteUntilThreshold();

ConfirmBufferState(0, 10, 10, 10);

ConfirmLoaderOffsets(10, 0, 0);

- ConfirmLoaderDeferredState(true);

// *** TRICKY BUSINESS, PT. III ***

// Read past forward capacity but within threshold: stop deferring.

@@ -829,24 +801,20 @@ TEST_F(BufferedResourceLoaderTest, Tricky_SmallReadWithinThreshold) {

// AFTER

// offset=28 [__________]

- EXPECT_CALL(*this, NetworkCallback());

+ EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoading));

ReadLoader(24, 4, buffer);

ConfirmLoaderOffsets(20, 4, 8);

- ConfirmLoaderDeferredState(false);

// Write a little, make sure we didn't start deferring.

WriteData(4);

- ConfirmLoaderDeferredState(false);

// Write the rest, read should complete.

EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 4));

WriteData(4);

- ConfirmLoaderDeferredState(false);

// POSTCONDITION

ConfirmBufferState(8, 10, 0, 10);

ConfirmLoaderOffsets(28, 0, 0);

- ConfirmLoaderDeferredState(false);

StopWhenLoad();

}

@@ -864,7 +832,6 @@ TEST_F(BufferedResourceLoaderTest, Tricky_LargeReadWithinThreshold) {

WriteUntilThreshold();

ConfirmBufferState(0, 10, 10, 10);

ConfirmLoaderOffsets(10, 0, 0);

- ConfirmLoaderDeferredState(true);

// *** TRICKY BUSINESS, PT. IV ***

// Read a large amount past forward capacity but within

@@ -887,26 +854,22 @@ TEST_F(BufferedResourceLoaderTest, Tricky_LargeReadWithinThreshold) {

// AFTER

// offset=36 [__________]

- EXPECT_CALL(*this, NetworkCallback());

+ EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoading));

ReadLoader(24, 12, buffer);

ConfirmLoaderOffsets(20, 4, 16);

ConfirmBufferState(10, 10, 0, 16);

- ConfirmLoaderDeferredState(false);

// Write a little, make sure we didn't start deferring.

WriteData(10);

- ConfirmLoaderDeferredState(false);

// Write the rest, read should complete and capacity should go back to normal.

EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 12));

WriteData(6);

ConfirmLoaderBufferForwardCapacity(10);

- ConfirmLoaderDeferredState(false);

// POSTCONDITION

ConfirmBufferState(6, 10, 0, 10);

ConfirmLoaderOffsets(36, 0, 0);

- ConfirmLoaderDeferredState(false);

StopWhenLoad();

}

@@ -923,12 +886,11 @@ TEST_F(BufferedResourceLoaderTest, Tricky_LargeReadBackwards) {

// PRECONDITION

WriteUntilThreshold();

EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 10));

- EXPECT_CALL(*this, NetworkCallback());

+ EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoading));

ReadLoader(10, 10, buffer);

WriteUntilThreshold();

ConfirmBufferState(10, 10, 10, 10);

ConfirmLoaderOffsets(20, 0, 0);

- ConfirmLoaderDeferredState(true);

// *** TRICKY BUSINESS, PT. V ***

// Read a large amount that involves backwards data: stop deferring.

@@ -950,26 +912,22 @@ TEST_F(BufferedResourceLoaderTest, Tricky_LargeReadBackwards) {

// AFTER

// offset=34 [xxxxxxxxxx|__________]

- EXPECT_CALL(*this, NetworkCallback());

+ EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoading));

ReadLoader(16, 18, buffer);

ConfirmLoaderOffsets(16, 0, 18);

ConfirmBufferState(6, 10, 14, 18);

- ConfirmLoaderDeferredState(false);

// Write a little, make sure we didn't start deferring.

WriteData(2);

- ConfirmLoaderDeferredState(false);

// Write the rest, read should complete and capacity should go back to normal.

EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 18));

WriteData(2);

ConfirmLoaderBufferForwardCapacity(10);

- ConfirmLoaderDeferredState(false);

// POSTCONDITION

ConfirmBufferState(4, 10, 0, 10);

ConfirmLoaderOffsets(34, 0, 0);

- ConfirmLoaderDeferredState(false);

StopWhenLoad();

}

@@ -990,7 +948,6 @@ TEST_F(BufferedResourceLoaderTest, Tricky_ReadPastThreshold) {

WriteUntilThreshold();

ConfirmBufferState(0, 10, 10, 10);

ConfirmLoaderOffsets(10, 0, 0);

- ConfirmLoaderDeferredState(true);

// *** TRICKY BUSINESS, PT. VI ***

// Read past the forward wait threshold: cache miss.

@@ -1007,7 +964,6 @@ TEST_F(BufferedResourceLoaderTest, Tricky_ReadPastThreshold) {

// POSTCONDITION

ConfirmBufferState(0, 10, 10, 10);

ConfirmLoaderOffsets(10, 0, 0);

- ConfirmLoaderDeferredState(true);

StopWhenLoad();

}

« webkit/media/buffered_resource_loader.h ('K') | « webkit/media/buffered_resource_loader.cc ('k') | no next file » | no next file with comments »