Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(962)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: media/blink/multibuffer_data_source_unittest.cc

Issue 1399603003: Tie multibuffers to URLs (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@media_cache
Patch Set: compile fixes Created 5 years, 2 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
« media/blink/multibuffer_data_source.cc ('K') | « media/blink/multibuffer_data_source.cc ('k') | media/blink/multibuffer_resource_loader.h » ('j') | media/blink/multibuffer_resource_loader.h » ('J')
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: media/blink/multibuffer_data_source_unittest.cc
diff --git a/media/blink/buffered_data_source_unittest.cc b/media/blink/multibuffer_data_source_unittest.cc
similarity index 58%
copy from media/blink/buffered_data_source_unittest.cc
copy to media/blink/multibuffer_data_source_unittest.cc
index 878d5f7ea007d663509dca2b131239f303645ad0..4b1132f59434d38922f588b4543add3f21dadbed 100644
--- a/media/blink/buffered_data_source_unittest.cc
+++ b/media/blink/multibuffer_data_source_unittest.cc
@@ -11,6 +11,8 @@
#include "media/blink/buffered_data_source.h"
#include "media/blink/mock_webframeclient.h"
#include "media/blink/mock_weburlloader.h"
+#include "media/blink/multibuffer_data_source.h"
+#include "media/blink/multibuffer_reader.h"
#include "media/blink/test_response_generator.h"
#include "third_party/WebKit/public/platform/WebURLResponse.h"
#include "third_party/WebKit/public/web/WebLocalFrame.h"
@@ -33,6 +35,93 @@ using blink::WebView;
namespace media {
+class MockResourceMultiBuffer;
+
+class MockMultiBufferDataProvider : public ResourceMultiBufferDataProvider {
+ public:
+ MockMultiBufferDataProvider(MultiBuffer::BlockId pos,
+ MockResourceMultiBuffer* multibuffer);
+ ~MockMultiBufferDataProvider();
+ void ForgetMockMultiBuffer() { mock_multibuffer_ = nullptr; }
+ void Start() override {
+ // Create a mock active loader.
+ // Keep track of active loading state via loadAsynchronously() and cancel().
+ NiceMock<MockWebURLLoader>* url_loader = new NiceMock<MockWebURLLoader>();
+ ON_CALL(*url_loader, cancel())
+ .WillByDefault(Assign(&loading_, false));
+ loading_ = true;
+ active_loader_.reset(
+ new ActiveLoader(scoped_ptr<WebURLLoader>(url_loader)));
+ if (!on_start_.is_null()) {
+ on_start_.Run();
+ }
+ }
+
+ bool loading() const { return loading_; }
+ void RunOnStart(base::Closure cb) {
+ on_start_ = cb;
+ }
+
+ private:
+ MockResourceMultiBuffer* mock_multibuffer_;
+ bool loading_;
+ base::Closure on_start_;
+};
+
+class MockResourceMultiBuffer : public ResourceMultiBuffer {
+ public:
+ explicit MockResourceMultiBuffer(blink::WebFrame* frame)
+ : ResourceMultiBuffer(frame) {
+ }
+ ~MockResourceMultiBuffer() override {
+ for (auto i : data_providers_)
+ i->ForgetMockMultiBuffer();
+ }
+ MultiBuffer::DataProvider* CreateWriter(const BlockId& pos) override {
+ MockMultiBufferDataProvider* ret =
+ new MockMultiBufferDataProvider(pos, this);
+ data_providers_.insert(ret);
+ ret->Start();
+ return ret;
+ }
+ void Unregister(MockMultiBufferDataProvider* provider) {
+ data_providers_.erase(provider);
+ }
+
+ MockMultiBufferDataProvider* GetProvider() {
+ EXPECT_EQ(data_providers_.size(), 1U);
+ if (data_providers_.size() != 1) return nullptr;
+ return *data_providers_.begin();
+ }
+ MockMultiBufferDataProvider* GetProvider_allownull() {
+ EXPECT_LE(data_providers_.size(), 1U);
+ if (data_providers_.size() != 1U) return nullptr;
+ return *data_providers_.begin();
+ }
+ bool HasProvider() const {
+ return data_providers_.size() == 1U;
+ }
+ bool loading() {
+ if (data_providers_.empty()) return false;
+ return GetProvider()->loading();
+ }
+ private:
+ std::set<MockMultiBufferDataProvider*> data_providers_;
+};
+
+MockMultiBufferDataProvider::MockMultiBufferDataProvider(
+ MultiBuffer::BlockId pos,
+ MockResourceMultiBuffer* multibuffer)
+ : ResourceMultiBufferDataProvider(pos, multibuffer),
+ mock_multibuffer_(multibuffer),
+ loading_(false) {
+}
+
+MockMultiBufferDataProvider::~MockMultiBufferDataProvider() {
+ if (mock_multibuffer_)
+ mock_multibuffer_->Unregister(this);
+}
+
class MockBufferedDataSourceHost : public BufferedDataSourceHost {
public:
MockBufferedDataSourceHost() {}
@@ -45,52 +134,31 @@ class MockBufferedDataSourceHost : public BufferedDataSourceHost {
DISALLOW_COPY_AND_ASSIGN(MockBufferedDataSourceHost);
};
-// Overrides CreateResourceLoader() to permit injecting a MockWebURLLoader.
-// Also keeps track of whether said MockWebURLLoader is actively loading.
-class MockBufferedDataSource : public BufferedDataSource {
+class MockMultibufferDataSource : public MultibufferDataSource {
public:
- MockBufferedDataSource(
+ MockMultibufferDataSource(
const GURL& url,
const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
+ ResourceMultiBuffer* multibuffer,
WebLocalFrame* frame,
BufferedDataSourceHost* host)
- : BufferedDataSource(url,
- BufferedResourceLoader::kUnspecified,
- task_runner,
- frame,
- new media::MediaLog(),
- host,
- base::Bind(&MockBufferedDataSource::set_downloading,
- base::Unretained(this))),
- downloading_(false),
- loading_(false) {}
- virtual ~MockBufferedDataSource() {}
-
- MOCK_METHOD2(CreateResourceLoader, BufferedResourceLoader*(int64, int64));
- BufferedResourceLoader* CreateMockResourceLoader(int64 first_byte_position,
- int64 last_byte_position) {
- CHECK(!loading_) << "Previous resource load wasn't cancelled";
-
- BufferedResourceLoader* loader =
- BufferedDataSource::CreateResourceLoader(first_byte_position,
- last_byte_position);
-
- // Keep track of active loading state via loadAsynchronously() and cancel().
- NiceMock<MockWebURLLoader>* url_loader = new NiceMock<MockWebURLLoader>();
- ON_CALL(*url_loader, loadAsynchronously(_, _))
- .WillByDefault(Assign(&loading_, true));
- ON_CALL(*url_loader, cancel())
- .WillByDefault(Assign(&loading_, false));
-
- // |test_loader_| will be used when Start() is called.
- loader->test_loader_ = scoped_ptr<WebURLLoader>(url_loader);
- return loader;
- }
+ : MultibufferDataSource(url,
+ UrlData::kUnspecified,
+ task_runner,
+ multibuffer,
+ frame,
+ new media::MediaLog(),
+ host,
+ base::Bind(
+ &MockMultibufferDataSource::set_downloading,
+ base::Unretained(this))),
+ downloading_(false) {}
- bool loading() { return loading_; }
- void set_loading(bool loading) { loading_ = loading; }
bool downloading() { return downloading_; }
- void set_downloading(bool downloading) { downloading_ = downloading; }
+ void set_downloading(bool downloading) {
+ downloading_ = downloading;
+ }
+ bool range_supported() { return url_data_->range_supported(); }
private:
// Whether the resource is downloading or deferred.
@@ -99,29 +167,30 @@ class MockBufferedDataSource : public BufferedDataSource {
// Whether the resource load has starting loading but yet to been cancelled.
bool loading_;
- DISALLOW_COPY_AND_ASSIGN(MockBufferedDataSource);
+ DISALLOW_COPY_AND_ASSIGN(MockMultibufferDataSource);
};
static const int64 kFileSize = 5000000;
-static const int64 kFarReadPosition = 4000000;
-static const int kDataSize = 1024;
+static const int64 kFarReadPosition = 3997696;
+static const int kDataSize = 32 << 10;
static const char kHttpUrl[] = "http://localhost/foo.webm";
static const char kFileUrl[] = "file:///tmp/bar.webm";
static const char kHttpDifferentPathUrl[] = "http://localhost/bar.webm";
static const char kHttpDifferentOriginUrl[] = "http://127.0.0.1/foo.webm";
-class BufferedDataSourceTest : public testing::Test {
+class MultibufferDataSourceTest : public testing::Test {
public:
- BufferedDataSourceTest()
+ MultibufferDataSourceTest()
: view_(WebView::create(NULL)),
frame_(
WebLocalFrame::create(blink::WebTreeScopeType::Document, &client_)),
- preload_(BufferedDataSource::AUTO) {
+ preload_(MultibufferDataSource::AUTO),
+ resource_multibuffer_(frame_) {
view_->setMainFrame(frame_);
}
- virtual ~BufferedDataSourceTest() {
+ virtual ~MultibufferDataSourceTest() {
view_->close();
frame_->close();
}
@@ -131,21 +200,22 @@ class BufferedDataSourceTest : public testing::Test {
void Initialize(const char* url, bool expected) {
GURL gurl(url);
data_source_.reset(
- new MockBufferedDataSource(gurl,
+ new MockMultibufferDataSource(gurl,
message_loop_.task_runner(),
+ &resource_multibuffer_,
view_->mainFrame()->toWebLocalFrame(),
&host_));
data_source_->SetPreload(preload_);
response_generator_.reset(new TestResponseGenerator(gurl, kFileSize));
- ExpectCreateResourceLoader();
EXPECT_CALL(*this, OnInitialize(expected));
- data_source_->Initialize(base::Bind(&BufferedDataSourceTest::OnInitialize,
- base::Unretained(this)));
+ data_source_->Initialize(
+ base::Bind(&MultibufferDataSourceTest::OnInitialize,
+ base::Unretained(this)));
message_loop_.RunUntilIdle();
- bool is_http = gurl.SchemeIsHTTPOrHTTPS();
- EXPECT_EQ(data_source_->downloading(), is_http);
+ // Always loading after initialize.
+ EXPECT_EQ(data_source_->downloading(), true);
}
// Helper to initialize tests with a valid 200 response.
@@ -154,6 +224,9 @@ class BufferedDataSourceTest : public testing::Test {
EXPECT_CALL(host_, SetTotalBytes(response_generator_->content_length()));
Respond(response_generator_->Generate200());
+
+ EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize));
+ ReceiveData(kDataSize);
}
// Helper to initialize tests with a valid 206 response.
@@ -162,6 +235,8 @@ class BufferedDataSourceTest : public testing::Test {
EXPECT_CALL(host_, SetTotalBytes(response_generator_->content_length()));
Respond(response_generator_->Generate206(0));
+ EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize));
+ ReceiveData(kDataSize);
}
// Helper to initialize tests with a valid file:// response.
@@ -171,6 +246,8 @@ class BufferedDataSourceTest : public testing::Test {
EXPECT_CALL(host_, SetTotalBytes(kFileSize));
EXPECT_CALL(host_, AddBufferedByteRange(0, kFileSize));
Respond(response_generator_->GenerateFileResponse(0));
+
+ ReceiveData(kDataSize);
}
// Stops any active loaders and shuts down the data source.
@@ -178,8 +255,9 @@ class BufferedDataSourceTest : public testing::Test {
// This typically happens when the page is closed and for our purposes is
// appropriate to do when tearing down a test.
void Stop() {
- if (data_source_->loading()) {
- loader()->didFail(url_loader(), response_generator_->GenerateError());
+ if (loading()) {
+ data_provider()->didFail(
+ url_loader(), response_generator_->GenerateError());
message_loop_.RunUntilIdle();
}
@@ -187,37 +265,42 @@ class BufferedDataSourceTest : public testing::Test {
message_loop_.RunUntilIdle();
}
- void ExpectCreateResourceLoader() {
- EXPECT_CALL(*data_source_, CreateResourceLoader(_, _))
- .WillOnce(Invoke(data_source_.get(),
- &MockBufferedDataSource::CreateMockResourceLoader));
- message_loop_.RunUntilIdle();
- }
-
void Respond(const WebURLResponse& response) {
- loader()->didReceiveResponse(url_loader(), response);
+ EXPECT_TRUE(url_loader());
+ if (!active_loader()) return;
+ data_provider()->didReceiveResponse(url_loader(), response);
message_loop_.RunUntilIdle();
}
void ReceiveData(int size) {
+ EXPECT_TRUE(url_loader());
+ if (!url_loader()) return;
scoped_ptr<char[]> data(new char[size]);
memset(data.get(), 0xA5, size); // Arbitrary non-zero value.
- loader()->didReceiveData(url_loader(), data.get(), size, size);
+ data_provider()->didReceiveData(url_loader(), data.get(), size, size);
message_loop_.RunUntilIdle();
}
void FinishLoading() {
- data_source_->set_loading(false);
- loader()->didFinishLoading(url_loader(), 0, -1);
+ EXPECT_TRUE(url_loader());
+ if (!url_loader()) return;
+ data_provider()->didFinishLoading(url_loader(), 0, -1);
message_loop_.RunUntilIdle();
}
+ void Restart() {
+ EXPECT_TRUE(data_provider());
+ EXPECT_FALSE(active_loader_allownull());
+ if (!data_provider()) return;
+ data_provider()->Start();
+ }
+
MOCK_METHOD1(ReadCallback, void(int size));
- void ReadAt(int64 position) {
- data_source_->Read(position, kDataSize, buffer_,
- base::Bind(&BufferedDataSourceTest::ReadCallback,
+ void ReadAt(int64 position, int64 howmuch=kDataSize) {
+ data_source_->Read(position, howmuch, buffer_,
+ base::Bind(&MultibufferDataSourceTest::ReadCallback,
base::Unretained(this)));
message_loop_.RunUntilIdle();
}
@@ -225,17 +308,17 @@ class BufferedDataSourceTest : public testing::Test {
void ExecuteMixedResponseSuccessTest(const WebURLResponse& response1,
const WebURLResponse& response2) {
EXPECT_CALL(host_, SetTotalBytes(kFileSize));
- EXPECT_CALL(host_, AddBufferedByteRange(kDataSize, kDataSize * 2 - 1));
- EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize - 1));
+ EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize * 2));
+ EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize));
EXPECT_CALL(*this, ReadCallback(kDataSize)).Times(2);
Respond(response1);
- ReadAt(0);
ReceiveData(kDataSize);
- EXPECT_TRUE(data_source_->loading());
+ ReadAt(0);
+ EXPECT_TRUE(loading());
- ExpectCreateResourceLoader();
FinishLoading();
+ Restart();
ReadAt(kDataSize);
Respond(response2);
ReceiveData(kDataSize);
@@ -246,102 +329,143 @@ class BufferedDataSourceTest : public testing::Test {
void ExecuteMixedResponseFailureTest(const WebURLResponse& response1,
const WebURLResponse& response2) {
EXPECT_CALL(host_, SetTotalBytes(kFileSize));
- EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize - 1));
+ EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize));
EXPECT_CALL(*this, ReadCallback(kDataSize));
EXPECT_CALL(*this, ReadCallback(media::DataSource::kReadError));
Respond(response1);
- ReadAt(0);
ReceiveData(kDataSize);
- EXPECT_TRUE(data_source_->loading());
+ ReadAt(0);
+ EXPECT_TRUE(loading());
- ExpectCreateResourceLoader();
FinishLoading();
+ Restart();
ReadAt(kDataSize);
Respond(response2);
Stop();
}
+ void CheckCapacityDefer() {
+ EXPECT_EQ(2 << 20, preload_low());
+ EXPECT_EQ(3 << 20, preload_high());
+ }
+
+ void CheckReadThenDefer() {
+ EXPECT_EQ(0, preload_low());
+ EXPECT_EQ(0, preload_high());
+ }
+
+ void CheckNeverDefer() {
+ EXPECT_EQ(1LL << 40, preload_low());
+ EXPECT_EQ(1LL << 40, preload_high());
+ }
+
// Accessors for private variables on |data_source_|.
- BufferedResourceLoader* loader() {
+ MultiBufferReader* loader() {
return data_source_->loader_.get();
}
- ActiveLoader* active_loader() { return loader()->active_loader_.get(); }
+
+ MockMultiBufferDataProvider* data_provider() {
+ return resource_multibuffer_.GetProvider();
+ }
+ ActiveLoader* active_loader() {
+ EXPECT_TRUE(data_provider());
+ if (!data_provider()) return nullptr;
+ return data_provider()->active_loader_.get();
+ }
+ ActiveLoader* active_loader_allownull() {
+ MockMultiBufferDataProvider* data_provider =
+ resource_multibuffer_.GetProvider_allownull();
+ if (!data_provider) return nullptr;
+ return data_provider->active_loader_.get();
+ }
WebURLLoader* url_loader() {
- return loader()->active_loader_->loader_.get();
+ EXPECT_TRUE(active_loader());
+ if (!active_loader()) return nullptr;
+ return active_loader()->loader_.get();
}
- BufferedDataSource::Preload preload() { return data_source_->preload_; }
- void set_preload(BufferedDataSource::Preload preload) { preload_ = preload; }
- BufferedResourceLoader::DeferStrategy defer_strategy() {
- return loader()->defer_strategy_;
+ bool loading() { return resource_multibuffer_.loading(); }
+
+ MultibufferDataSource::Preload preload() { return data_source_->preload_; }
+ void set_preload(MultibufferDataSource::Preload preload) {
+ preload_ = preload;
+ }
+ int64 preload_high() {
+ CHECK(loader());
+ return loader()->preload_high(); }
+ int64 preload_low() {
+ CHECK(loader());
+ return loader()->preload_low();
}
int data_source_bitrate() { return data_source_->bitrate_; }
double data_source_playback_rate() { return data_source_->playback_rate_; }
- int loader_bitrate() { return loader()->bitrate_; }
- double loader_playback_rate() { return loader()->playback_rate_; }
bool is_local_source() { return data_source_->assume_fully_buffered(); }
void set_might_be_reused_from_cache_in_future(bool value) {
- loader()->might_be_reused_from_cache_in_future_ = value;
+ data_source_->url_data_->set_cacheable(value);
}
- scoped_ptr<MockBufferedDataSource> data_source_;
-
- scoped_ptr<TestResponseGenerator> response_generator_;
+ protected:
MockWebFrameClient client_;
WebView* view_;
WebLocalFrame* frame_;
+ MultibufferDataSource::Preload preload_;
+ MockResourceMultiBuffer resource_multibuffer_;
+
+ scoped_ptr<MockMultibufferDataSource> data_source_;
+
+ scoped_ptr<TestResponseGenerator> response_generator_;
StrictMock<MockBufferedDataSourceHost> host_;
base::MessageLoop message_loop_;
- private:
- // Used for calling BufferedDataSource::Read().
- uint8 buffer_[kDataSize];
-
- BufferedDataSource::Preload preload_;
+ // Used for calling MultibufferDataSource::Read().
+ uint8 buffer_[kDataSize * 2];
- DISALLOW_COPY_AND_ASSIGN(BufferedDataSourceTest);
+ DISALLOW_COPY_AND_ASSIGN(MultibufferDataSourceTest);
};
-TEST_F(BufferedDataSourceTest, Range_Supported) {
+TEST_F(MultibufferDataSourceTest, Range_Supported) {
InitializeWith206Response();
- EXPECT_TRUE(data_source_->loading());
+ EXPECT_TRUE(loading());
EXPECT_FALSE(data_source_->IsStreaming());
Stop();
}
-TEST_F(BufferedDataSourceTest, Range_InstanceSizeUnknown) {
+TEST_F(MultibufferDataSourceTest, Range_InstanceSizeUnknown) {
Initialize(kHttpUrl, true);
Respond(response_generator_->Generate206(
0, TestResponseGenerator::kNoContentRangeInstanceSize));
- EXPECT_TRUE(data_source_->loading());
+ EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize));
+ ReceiveData(kDataSize);
+
+ EXPECT_TRUE(loading());
EXPECT_TRUE(data_source_->IsStreaming());
Stop();
}
-TEST_F(BufferedDataSourceTest, Range_NotFound) {
+TEST_F(MultibufferDataSourceTest, Range_NotFound) {
Initialize(kHttpUrl, false);
Respond(response_generator_->Generate404());
- EXPECT_FALSE(data_source_->loading());
+ EXPECT_FALSE(loading());
Stop();
}
-TEST_F(BufferedDataSourceTest, Range_NotSupported) {
+TEST_F(MultibufferDataSourceTest, Range_NotSupported) {
InitializeWith200Response();
- EXPECT_TRUE(data_source_->loading());
+ EXPECT_TRUE(loading());
EXPECT_TRUE(data_source_->IsStreaming());
Stop();
}
// Special carve-out for Apache versions that choose to return a 200 for
// Range:0- ("because it's more efficient" than a 206)
-TEST_F(BufferedDataSourceTest, Range_SupportedButReturned200) {
+TEST_F(MultibufferDataSourceTest, Range_SupportedButReturned200) {
Initialize(kHttpUrl, true);
EXPECT_CALL(host_, SetTotalBytes(response_generator_->content_length()));
WebURLResponse response = response_generator_->Generate200();
@@ -349,21 +473,24 @@ TEST_F(BufferedDataSourceTest, Range_SupportedButReturned200) {
WebString::fromUTF8("bytes"));
Respond(response);
- EXPECT_TRUE(data_source_->loading());
+ EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize));
+ ReceiveData(kDataSize);
+
+ EXPECT_TRUE(loading());
EXPECT_FALSE(data_source_->IsStreaming());
Stop();
}
-TEST_F(BufferedDataSourceTest, Range_MissingContentRange) {
+TEST_F(MultibufferDataSourceTest, Range_MissingContentRange) {
Initialize(kHttpUrl, false);
Respond(response_generator_->Generate206(
0, TestResponseGenerator::kNoContentRange));
- EXPECT_FALSE(data_source_->loading());
+ EXPECT_FALSE(loading());
Stop();
}
-TEST_F(BufferedDataSourceTest, Range_MissingContentLength) {
+TEST_F(MultibufferDataSourceTest, Range_MissingContentLength) {
Initialize(kHttpUrl, true);
// It'll manage without a Content-Length response.
@@ -371,121 +498,115 @@ TEST_F(BufferedDataSourceTest, Range_MissingContentLength) {
Respond(response_generator_->Generate206(
0, TestResponseGenerator::kNoContentLength));
- EXPECT_TRUE(data_source_->loading());
+ EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize));
+ ReceiveData(kDataSize);
+
+ EXPECT_TRUE(loading());
EXPECT_FALSE(data_source_->IsStreaming());
Stop();
}
-TEST_F(BufferedDataSourceTest, Range_WrongContentRange) {
+TEST_F(MultibufferDataSourceTest, Range_WrongContentRange) {
Initialize(kHttpUrl, false);
// Now it's done and will fail.
Respond(response_generator_->Generate206(1337));
- EXPECT_FALSE(data_source_->loading());
+ EXPECT_FALSE(loading());
Stop();
}
// Test the case where the initial response from the server indicates that
// Range requests are supported, but a later request prove otherwise.
-TEST_F(BufferedDataSourceTest, Range_ServerLied) {
+TEST_F(MultibufferDataSourceTest, Range_ServerLied) {
InitializeWith206Response();
// Read causing a new request to be made -- we'll expect it to error.
- ExpectCreateResourceLoader();
ReadAt(kFarReadPosition);
// Return a 200 in response to a range request.
EXPECT_CALL(*this, ReadCallback(media::DataSource::kReadError));
Respond(response_generator_->Generate200());
- EXPECT_FALSE(data_source_->loading());
+ EXPECT_FALSE(loading());
Stop();
}
-TEST_F(BufferedDataSourceTest, Http_AbortWhileReading) {
+TEST_F(MultibufferDataSourceTest, Http_AbortWhileReading) {
InitializeWith206Response();
// Make sure there's a pending read -- we'll expect it to error.
- ReadAt(0);
+ ReadAt(kFileSize);
// Abort!!!
EXPECT_CALL(*this, ReadCallback(media::DataSource::kReadError));
data_source_->Abort();
message_loop_.RunUntilIdle();
- EXPECT_FALSE(data_source_->loading());
+ EXPECT_FALSE(loading());
Stop();
}
-TEST_F(BufferedDataSourceTest, File_AbortWhileReading) {
+TEST_F(MultibufferDataSourceTest, File_AbortWhileReading) {
InitializeWithFileResponse();
// Make sure there's a pending read -- we'll expect it to error.
- ReadAt(0);
+ ReadAt(kFileSize);
// Abort!!!
EXPECT_CALL(*this, ReadCallback(media::DataSource::kReadError));
data_source_->Abort();
message_loop_.RunUntilIdle();
- EXPECT_FALSE(data_source_->loading());
+ EXPECT_FALSE(loading());
Stop();
}
-TEST_F(BufferedDataSourceTest, Http_Retry) {
+TEST_F(MultibufferDataSourceTest, Http_Retry) {
InitializeWith206Response();
// Read to advance our position.
EXPECT_CALL(*this, ReadCallback(kDataSize));
- EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize - 1));
ReadAt(0);
- ReceiveData(kDataSize);
// Issue a pending read but terminate the connection to force a retry.
ReadAt(kDataSize);
- ExpectCreateResourceLoader();
FinishLoading();
+ Restart();
Respond(response_generator_->Generate206(kDataSize));
// Complete the read.
EXPECT_CALL(*this, ReadCallback(kDataSize));
- EXPECT_CALL(host_, AddBufferedByteRange(kDataSize, (kDataSize * 2) - 1));
+ EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize * 2));
ReceiveData(kDataSize);
- EXPECT_TRUE(data_source_->loading());
+ EXPECT_TRUE(loading());
Stop();
}
-TEST_F(BufferedDataSourceTest, Http_RetryOnError) {
+TEST_F(MultibufferDataSourceTest, Http_RetryOnError) {
InitializeWith206Response();
// Read to advance our position.
EXPECT_CALL(*this, ReadCallback(kDataSize));
- EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize - 1));
ReadAt(0);
- ReceiveData(kDataSize);
// Issue a pending read but trigger an error to force a retry.
EXPECT_CALL(*this, ReadCallback(kDataSize));
- EXPECT_CALL(host_, AddBufferedByteRange(kDataSize, (kDataSize * 2) - 1));
+ EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize * 2));
ReadAt(kDataSize);
base::RunLoop run_loop;
- EXPECT_CALL(*data_source_, CreateResourceLoader(_, _))
- .WillOnce(
- DoAll(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit),
- Invoke(data_source_.get(),
- &MockBufferedDataSource::CreateMockResourceLoader)));
- loader()->didFail(url_loader(), response_generator_->GenerateError());
+ data_provider()->didFail(url_loader(), response_generator_->GenerateError());
+ data_provider()->RunOnStart(run_loop.QuitClosure());
run_loop.Run();
Respond(response_generator_->Generate206(kDataSize));
ReceiveData(kDataSize);
FinishLoading();
- EXPECT_FALSE(data_source_->loading());
+ EXPECT_FALSE(loading());
Stop();
}
-TEST_F(BufferedDataSourceTest, Http_PartialResponse) {
+TEST_F(MultibufferDataSourceTest, Http_PartialResponse) {
Initialize(kHttpUrl, true);
WebURLResponse response1 =
response_generator_->GeneratePartial206(0, kDataSize - 1);
@@ -496,7 +617,7 @@ TEST_F(BufferedDataSourceTest, Http_PartialResponse) {
ExecuteMixedResponseSuccessTest(response1, response2);
}
-TEST_F(BufferedDataSourceTest,
+TEST_F(MultibufferDataSourceTest,
Http_MixedResponse_RedirectedToDifferentPathResponse) {
Initialize(kHttpUrl, true);
WebURLResponse response1 =
@@ -509,7 +630,7 @@ TEST_F(BufferedDataSourceTest,
ExecuteMixedResponseSuccessTest(response1, response2);
}
-TEST_F(BufferedDataSourceTest,
+TEST_F(MultibufferDataSourceTest,
Http_MixedResponse_RedirectedToDifferentOriginResponse) {
Initialize(kHttpUrl, true);
WebURLResponse response1 =
@@ -522,7 +643,7 @@ TEST_F(BufferedDataSourceTest,
ExecuteMixedResponseFailureTest(response1, response2);
}
-TEST_F(BufferedDataSourceTest,
+TEST_F(MultibufferDataSourceTest,
Http_MixedResponse_ServiceWorkerGeneratedResponseAndNormalResponse) {
Initialize(kHttpUrl, true);
WebURLResponse response1 =
@@ -535,7 +656,7 @@ TEST_F(BufferedDataSourceTest,
ExecuteMixedResponseFailureTest(response1, response2);
}
-TEST_F(BufferedDataSourceTest,
+TEST_F(MultibufferDataSourceTest,
Http_MixedResponse_ServiceWorkerProxiedAndSameURLResponse) {
Initialize(kHttpUrl, true);
WebURLResponse response1 =
@@ -549,7 +670,7 @@ TEST_F(BufferedDataSourceTest,
ExecuteMixedResponseSuccessTest(response1, response2);
}
-TEST_F(BufferedDataSourceTest,
+TEST_F(MultibufferDataSourceTest,
Http_MixedResponse_ServiceWorkerProxiedAndDifferentPathResponse) {
Initialize(kHttpUrl, true);
WebURLResponse response1 =
@@ -563,7 +684,7 @@ TEST_F(BufferedDataSourceTest,
ExecuteMixedResponseSuccessTest(response1, response2);
}
-TEST_F(BufferedDataSourceTest,
+TEST_F(MultibufferDataSourceTest,
Http_MixedResponse_ServiceWorkerProxiedAndDifferentOriginResponse) {
Initialize(kHttpUrl, true);
WebURLResponse response1 =
@@ -577,106 +698,107 @@ TEST_F(BufferedDataSourceTest,
ExecuteMixedResponseFailureTest(response1, response2);
}
-TEST_F(BufferedDataSourceTest, File_Retry) {
+TEST_F(MultibufferDataSourceTest, File_Retry) {
InitializeWithFileResponse();
// Read to advance our position.
EXPECT_CALL(*this, ReadCallback(kDataSize));
ReadAt(0);
- ReceiveData(kDataSize);
// Issue a pending read but terminate the connection to force a retry.
ReadAt(kDataSize);
- ExpectCreateResourceLoader();
FinishLoading();
+ Restart();
Respond(response_generator_->GenerateFileResponse(kDataSize));
// Complete the read.
EXPECT_CALL(*this, ReadCallback(kDataSize));
ReceiveData(kDataSize);
- EXPECT_TRUE(data_source_->loading());
+ EXPECT_TRUE(loading());
Stop();
}
-TEST_F(BufferedDataSourceTest, Http_TooManyRetries) {
+TEST_F(MultibufferDataSourceTest, Http_TooManyRetries) {
InitializeWith206Response();
// Make sure there's a pending read -- we'll expect it to error.
- ReadAt(0);
+ ReadAt(kDataSize);
// It'll try three times.
- ExpectCreateResourceLoader();
FinishLoading();
- Respond(response_generator_->Generate206(0));
+ Restart();
+ Respond(response_generator_->Generate206(kDataSize));
- ExpectCreateResourceLoader();
FinishLoading();
- Respond(response_generator_->Generate206(0));
+ Restart();
+ Respond(response_generator_->Generate206(kDataSize));
- ExpectCreateResourceLoader();
FinishLoading();
- Respond(response_generator_->Generate206(0));
+ Restart();
+ Respond(response_generator_->Generate206(kDataSize));
// It'll error after this.
EXPECT_CALL(*this, ReadCallback(media::DataSource::kReadError));
FinishLoading();
- EXPECT_FALSE(data_source_->loading());
+ EXPECT_FALSE(loading());
Stop();
}
-TEST_F(BufferedDataSourceTest, File_TooManyRetries) {
+TEST_F(MultibufferDataSourceTest, File_TooManyRetries) {
InitializeWithFileResponse();
// Make sure there's a pending read -- we'll expect it to error.
- ReadAt(0);
+ ReadAt(kDataSize);
// It'll try three times.
- ExpectCreateResourceLoader();
FinishLoading();
+ Restart();
Respond(response_generator_->GenerateFileResponse(0));
- ExpectCreateResourceLoader();
FinishLoading();
+ Restart();
Respond(response_generator_->GenerateFileResponse(0));
- ExpectCreateResourceLoader();
FinishLoading();
+ Restart();
Respond(response_generator_->GenerateFileResponse(0));
// It'll error after this.
EXPECT_CALL(*this, ReadCallback(media::DataSource::kReadError));
FinishLoading();
- EXPECT_FALSE(data_source_->loading());
+ EXPECT_FALSE(loading());
Stop();
}
-TEST_F(BufferedDataSourceTest, File_InstanceSizeUnknown) {
+TEST_F(MultibufferDataSourceTest, File_InstanceSizeUnknown) {
Initialize(kFileUrl, false);
- EXPECT_FALSE(data_source_->downloading());
- Respond(response_generator_->GenerateFileResponse(-1));
+ Respond(response_generator_->GenerateFileResponse(
+ media::DataSource::kReadError));
+ ReceiveData(kDataSize);
- EXPECT_FALSE(data_source_->loading());
+ EXPECT_FALSE(data_source_->downloading());
+ EXPECT_FALSE(loading());
Stop();
}
-TEST_F(BufferedDataSourceTest, File_Successful) {
+TEST_F(MultibufferDataSourceTest, File_Successful) {
InitializeWithFileResponse();
- EXPECT_TRUE(data_source_->loading());
+ EXPECT_TRUE(loading());
EXPECT_FALSE(data_source_->IsStreaming());
Stop();
}
-TEST_F(BufferedDataSourceTest, StopDuringRead) {
+TEST_F(MultibufferDataSourceTest, StopDuringRead) {
InitializeWith206Response();
uint8 buffer[256];
data_source_->Read(0, arraysize(buffer), buffer, base::Bind(
- &BufferedDataSourceTest::ReadCallback, base::Unretained(this)));
+ &MultibufferDataSourceTest::ReadCallback, base::Unretained(this)));
// The outstanding read should fail before the stop callback runs.
{
@@ -687,301 +809,295 @@ TEST_F(BufferedDataSourceTest, StopDuringRead) {
message_loop_.RunUntilIdle();
}
-TEST_F(BufferedDataSourceTest, DefaultValues) {
+TEST_F(MultibufferDataSourceTest, DefaultValues) {
InitializeWith206Response();
// Ensure we have sane values for default loading scenario.
- EXPECT_EQ(BufferedDataSource::AUTO, preload());
- EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
+ EXPECT_EQ(MultibufferDataSource::AUTO, preload());
+ EXPECT_EQ(2 << 20, preload_low());
+ EXPECT_EQ(3 << 20, preload_high());
EXPECT_EQ(0, data_source_bitrate());
EXPECT_EQ(0.0, data_source_playback_rate());
- EXPECT_EQ(0, loader_bitrate());
- EXPECT_EQ(0.0, loader_playback_rate());
- EXPECT_TRUE(data_source_->loading());
+ EXPECT_TRUE(loading());
Stop();
}
-TEST_F(BufferedDataSourceTest, SetBitrate) {
+TEST_F(MultibufferDataSourceTest, SetBitrate) {
InitializeWith206Response();
data_source_->SetBitrate(1234);
message_loop_.RunUntilIdle();
EXPECT_EQ(1234, data_source_bitrate());
- EXPECT_EQ(1234, loader_bitrate());
// Read so far ahead to cause the loader to get recreated.
- BufferedResourceLoader* old_loader = loader();
- ExpectCreateResourceLoader();
+ MockMultiBufferDataProvider* old_loader = data_provider();
ReadAt(kFarReadPosition);
Respond(response_generator_->Generate206(kFarReadPosition));
// Verify loader changed but still has same bitrate.
- EXPECT_NE(old_loader, loader());
- EXPECT_EQ(1234, loader_bitrate());
+ EXPECT_NE(old_loader, data_provider());
- EXPECT_TRUE(data_source_->loading());
+ EXPECT_TRUE(loading());
EXPECT_CALL(*this, ReadCallback(media::DataSource::kReadError));
Stop();
}
-TEST_F(BufferedDataSourceTest, MediaPlaybackRateChanged) {
+TEST_F(MultibufferDataSourceTest, MediaPlaybackRateChanged) {
InitializeWith206Response();
data_source_->MediaPlaybackRateChanged(2.0);
message_loop_.RunUntilIdle();
EXPECT_EQ(2.0, data_source_playback_rate());
- EXPECT_EQ(2.0, loader_playback_rate());
// Read so far ahead to cause the loader to get recreated.
- BufferedResourceLoader* old_loader = loader();
- ExpectCreateResourceLoader();
+ MockMultiBufferDataProvider* old_loader = data_provider();
ReadAt(kFarReadPosition);
Respond(response_generator_->Generate206(kFarReadPosition));
// Verify loader changed but still has same playback rate.
- EXPECT_NE(old_loader, loader());
+ EXPECT_NE(old_loader, data_provider());
- EXPECT_TRUE(data_source_->loading());
+ EXPECT_TRUE(loading());
EXPECT_CALL(*this, ReadCallback(media::DataSource::kReadError));
Stop();
}
-TEST_F(BufferedDataSourceTest, Http_Read) {
+TEST_F(MultibufferDataSourceTest, Http_Read) {
InitializeWith206Response();
- ReadAt(0);
-
- // Receive first half of the read.
- EXPECT_CALL(host_, AddBufferedByteRange(0, (kDataSize / 2) - 1));
- ReceiveData(kDataSize / 2);
+ EXPECT_CALL(*this, ReadCallback(kDataSize));
+ ReadAt(0, kDataSize * 2);
- // Receive last half of the read.
+ ReadAt(kDataSize, kDataSize);
EXPECT_CALL(*this, ReadCallback(kDataSize));
- EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize - 1));
- ReceiveData(kDataSize / 2);
+ EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize * 2));
+ ReceiveData(kDataSize/2);
+ ReceiveData(kDataSize/2);
EXPECT_TRUE(data_source_->downloading());
Stop();
}
-TEST_F(BufferedDataSourceTest, Http_Read_Seek) {
+TEST_F(MultibufferDataSourceTest, Http_Read_Seek) {
InitializeWith206Response();
// Read a bit from the beginning.
- ReadAt(0);
EXPECT_CALL(*this, ReadCallback(kDataSize));
- EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize - 1));
- ReceiveData(kDataSize);
+ ReadAt(0);
// Simulate a seek by reading a bit beyond kDataSize.
ReadAt(kDataSize * 2);
// We receive data leading up to but not including our read.
- EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize * 2 - 1));
+ // No notification will happen, since it's progress outside
+ // of our current range.
ReceiveData(kDataSize);
// We now receive the rest of the data for our read.
EXPECT_CALL(*this, ReadCallback(kDataSize));
- EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize * 3 - 1));
+ EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize * 3));
ReceiveData(kDataSize);
EXPECT_TRUE(data_source_->downloading());
Stop();
}
-TEST_F(BufferedDataSourceTest, File_Read) {
+TEST_F(MultibufferDataSourceTest, File_Read) {
InitializeWithFileResponse();
- ReadAt(0);
-
- // Receive first half of the read but no buffering update.
- ReceiveData(kDataSize / 2);
+ EXPECT_CALL(*this, ReadCallback(kDataSize));
+ ReadAt(0, kDataSize * 2);
- // Receive last half of the read but no buffering update.
+ ReadAt(kDataSize, kDataSize);
EXPECT_CALL(*this, ReadCallback(kDataSize));
- ReceiveData(kDataSize / 2);
+ ReceiveData(kDataSize);
Stop();
}
-TEST_F(BufferedDataSourceTest, Http_FinishLoading) {
+TEST_F(MultibufferDataSourceTest, Http_FinishLoading) {
InitializeWith206Response();
EXPECT_TRUE(data_source_->downloading());
+ // premature didFinishLoading() will cause a retry.
FinishLoading();
- EXPECT_FALSE(data_source_->downloading());
+ EXPECT_TRUE(data_source_->downloading());
Stop();
}
-TEST_F(BufferedDataSourceTest, File_FinishLoading) {
+TEST_F(MultibufferDataSourceTest, File_FinishLoading) {
InitializeWithFileResponse();
- EXPECT_FALSE(data_source_->downloading());
+ ReceiveData(kDataSize);
+
+ EXPECT_TRUE(data_source_->downloading());
+ // premature didFinishLoading() will cause a retry.
FinishLoading();
- EXPECT_FALSE(data_source_->downloading());
+ EXPECT_TRUE(data_source_->downloading());
Stop();
}
-TEST_F(BufferedDataSourceTest, LocalResource_DeferStrategy) {
+TEST_F(MultibufferDataSourceTest, LocalResource_DeferStrategy) {
InitializeWithFileResponse();
- EXPECT_EQ(BufferedDataSource::AUTO, preload());
+ EXPECT_EQ(MultibufferDataSource::AUTO, preload());
EXPECT_TRUE(is_local_source());
- EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
+ CheckCapacityDefer();
data_source_->MediaIsPlaying();
- EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
+ CheckCapacityDefer();
data_source_->MediaIsPaused();
- EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
+ CheckCapacityDefer();
Stop();
}
-TEST_F(BufferedDataSourceTest, LocalResource_PreloadMetadata_DeferStrategy) {
- set_preload(BufferedDataSource::METADATA);
+TEST_F(MultibufferDataSourceTest, LocalResource_PreloadMetadata_DeferStrategy) {
+ set_preload(MultibufferDataSource::METADATA);
InitializeWithFileResponse();
- EXPECT_EQ(BufferedDataSource::METADATA, preload());
+ EXPECT_EQ(MultibufferDataSource::METADATA, preload());
EXPECT_TRUE(is_local_source());
- EXPECT_EQ(BufferedResourceLoader::kReadThenDefer, defer_strategy());
+ CheckReadThenDefer();
data_source_->MediaIsPlaying();
- EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
+ CheckCapacityDefer();
data_source_->MediaIsPaused();
- EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
+ CheckCapacityDefer();
Stop();
}
-TEST_F(BufferedDataSourceTest, ExternalResource_Reponse200_DeferStrategy) {
+TEST_F(MultibufferDataSourceTest, ExternalResource_Reponse200_DeferStrategy) {
InitializeWith200Response();
- EXPECT_EQ(BufferedDataSource::AUTO, preload());
+ EXPECT_EQ(MultibufferDataSource::AUTO, preload());
EXPECT_FALSE(is_local_source());
- EXPECT_FALSE(loader()->range_supported());
- EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
+ EXPECT_FALSE(data_source_->range_supported());
+ CheckCapacityDefer();
data_source_->MediaIsPlaying();
- EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
+ CheckCapacityDefer();
data_source_->MediaIsPaused();
- EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
+ CheckCapacityDefer();
Stop();
}
-TEST_F(BufferedDataSourceTest,
+TEST_F(MultibufferDataSourceTest,
ExternalResource_Response200_PreloadMetadata_DeferStrategy) {
- set_preload(BufferedDataSource::METADATA);
+ set_preload(MultibufferDataSource::METADATA);
InitializeWith200Response();
- EXPECT_EQ(BufferedDataSource::METADATA, preload());
+ EXPECT_EQ(MultibufferDataSource::METADATA, preload());
EXPECT_FALSE(is_local_source());
- EXPECT_FALSE(loader()->range_supported());
- EXPECT_EQ(BufferedResourceLoader::kReadThenDefer, defer_strategy());
+ EXPECT_FALSE(data_source_->range_supported());
+ CheckReadThenDefer();
data_source_->MediaIsPlaying();
- EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
+ CheckCapacityDefer();
data_source_->MediaIsPaused();
- EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
+ CheckCapacityDefer();
Stop();
}
-TEST_F(BufferedDataSourceTest, ExternalResource_Reponse206_DeferStrategy) {
+TEST_F(MultibufferDataSourceTest, ExternalResource_Reponse206_DeferStrategy) {
InitializeWith206Response();
- EXPECT_EQ(BufferedDataSource::AUTO, preload());
+ EXPECT_EQ(MultibufferDataSource::AUTO, preload());
EXPECT_FALSE(is_local_source());
- EXPECT_TRUE(loader()->range_supported());
- EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
+ EXPECT_TRUE(data_source_->range_supported());
+ CheckCapacityDefer();
data_source_->MediaIsPlaying();
- EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
+ CheckCapacityDefer();
set_might_be_reused_from_cache_in_future(true);
data_source_->MediaIsPaused();
- EXPECT_EQ(BufferedResourceLoader::kNeverDefer, defer_strategy());
+ CheckNeverDefer();
data_source_->MediaIsPlaying();
- EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
+ CheckCapacityDefer();
+
set_might_be_reused_from_cache_in_future(false);
data_source_->MediaIsPaused();
- EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
+ CheckCapacityDefer();
Stop();
}
-TEST_F(BufferedDataSourceTest,
+TEST_F(MultibufferDataSourceTest,
ExternalResource_Response206_PreloadMetadata_DeferStrategy) {
- set_preload(BufferedDataSource::METADATA);
+ set_preload(MultibufferDataSource::METADATA);
InitializeWith206Response();
- EXPECT_EQ(BufferedDataSource::METADATA, preload());
+ EXPECT_EQ(MultibufferDataSource::METADATA, preload());
EXPECT_FALSE(is_local_source());
- EXPECT_TRUE(loader()->range_supported());
- EXPECT_EQ(BufferedResourceLoader::kReadThenDefer, defer_strategy());
+ EXPECT_TRUE(data_source_->range_supported());
+ CheckReadThenDefer();
data_source_->MediaIsPlaying();
- EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
+ CheckCapacityDefer();
+
set_might_be_reused_from_cache_in_future(true);
data_source_->MediaIsPaused();
- EXPECT_EQ(BufferedResourceLoader::kNeverDefer, defer_strategy());
+ CheckNeverDefer();
data_source_->MediaIsPlaying();
- EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
+ CheckCapacityDefer();
set_might_be_reused_from_cache_in_future(false);
data_source_->MediaIsPaused();
- EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
+ CheckCapacityDefer();
Stop();
}
-TEST_F(BufferedDataSourceTest, ExternalResource_Response206_VerifyDefer) {
- set_preload(BufferedDataSource::METADATA);
+TEST_F(MultibufferDataSourceTest, ExternalResource_Response206_VerifyDefer) {
+ set_preload(MultibufferDataSource::METADATA);
InitializeWith206Response();
- EXPECT_EQ(BufferedDataSource::METADATA, preload());
+ EXPECT_EQ(MultibufferDataSource::METADATA, preload());
EXPECT_FALSE(is_local_source());
- EXPECT_TRUE(loader()->range_supported());
- EXPECT_EQ(BufferedResourceLoader::kReadThenDefer, defer_strategy());
+ EXPECT_TRUE(data_source_->range_supported());
+ CheckReadThenDefer();
// Read a bit from the beginning.
- ReadAt(0);
EXPECT_CALL(*this, ReadCallback(kDataSize));
- EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize - 1));
- ReceiveData(kDataSize);
+ ReadAt(0);
ASSERT_TRUE(active_loader());
EXPECT_TRUE(active_loader()->deferred());
}
-TEST_F(BufferedDataSourceTest, ExternalResource_Response206_CancelAfterDefer) {
- set_preload(BufferedDataSource::METADATA);
+TEST_F(MultibufferDataSourceTest,
+ ExternalResource_Response206_CancelAfterDefer) {
+ set_preload(MultibufferDataSource::METADATA);
InitializeWith206Response();
- EXPECT_EQ(BufferedDataSource::METADATA, preload());
+ EXPECT_EQ(MultibufferDataSource::METADATA, preload());
EXPECT_FALSE(is_local_source());
- EXPECT_TRUE(loader()->range_supported());
- EXPECT_EQ(BufferedResourceLoader::kReadThenDefer, defer_strategy());
- data_source_->OnBufferingHaveEnough();
+ EXPECT_TRUE(data_source_->range_supported());
+ CheckReadThenDefer();
+
+ ReadAt(kDataSize);
+ data_source_->OnBufferingHaveEnough();
ASSERT_TRUE(active_loader());
- // Read a bit from the beginning.
- ReadAt(0);
EXPECT_CALL(*this, ReadCallback(kDataSize));
- EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize - 1));
+ EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize*2));
ReceiveData(kDataSize);
- EXPECT_FALSE(active_loader());
+ EXPECT_FALSE(active_loader_allownull());
}
} // namespace media
« media/blink/multibuffer_data_source.cc ('K') | « media/blink/multibuffer_data_source.cc ('k') | media/blink/multibuffer_resource_loader.h » ('j') | media/blink/multibuffer_resource_loader.h » ('J')

Powered by Google App Engine
This is Rietveld 408576698