| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2013 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "base/bind.h" | |
| 6 #include "base/message_loop.h" | |
| 7 #include "media/base/media_log.h" | |
| 8 #include "media/base/mock_data_source_host.h" | |
| 9 #include "media/base/mock_filters.h" | |
| 10 #include "media/base/test_helpers.h" | |
| 11 #include "third_party/WebKit/public/platform/WebURLResponse.h" | |
| 12 #include "third_party/WebKit/public/web/WebView.h" | |
| 13 #include "webkit/mocks/mock_webframeclient.h" | |
| 14 #include "webkit/mocks/mock_weburlloader.h" | |
| 15 #include "webkit/renderer/media/buffered_data_source.h" | |
| 16 #include "webkit/renderer/media/test_response_generator.h" | |
| 17 | |
| 18 using ::testing::_; | |
| 19 using ::testing::Assign; | |
| 20 using ::testing::Invoke; | |
| 21 using ::testing::InSequence; | |
| 22 using ::testing::NiceMock; | |
| 23 using ::testing::StrictMock; | |
| 24 | |
| 25 using WebKit::WebFrame; | |
| 26 using WebKit::WebString; | |
| 27 using WebKit::WebURLLoader; | |
| 28 using WebKit::WebURLResponse; | |
| 29 using WebKit::WebView; | |
| 30 | |
| 31 using webkit_glue::MockWebFrameClient; | |
| 32 using webkit_glue::MockWebURLLoader; | |
| 33 | |
| 34 namespace webkit_media { | |
| 35 | |
| 36 // Overrides CreateResourceLoader() to permit injecting a MockWebURLLoader. | |
| 37 // Also keeps track of whether said MockWebURLLoader is actively loading. | |
| 38 class MockBufferedDataSource : public BufferedDataSource { | |
| 39 public: | |
| 40 MockBufferedDataSource( | |
| 41 const scoped_refptr<base::MessageLoopProxy>& message_loop, | |
| 42 WebFrame* frame) | |
| 43 : BufferedDataSource(message_loop, frame, new media::MediaLog(), | |
| 44 base::Bind(&MockBufferedDataSource::set_downloading, | |
| 45 base::Unretained(this))), | |
| 46 downloading_(false), | |
| 47 loading_(false) { | |
| 48 } | |
| 49 virtual ~MockBufferedDataSource() {} | |
| 50 | |
| 51 MOCK_METHOD2(CreateResourceLoader, BufferedResourceLoader*(int64, int64)); | |
| 52 BufferedResourceLoader* CreateMockResourceLoader(int64 first_byte_position, | |
| 53 int64 last_byte_position) { | |
| 54 CHECK(!loading_) << "Previous resource load wasn't cancelled"; | |
| 55 | |
| 56 BufferedResourceLoader* loader = | |
| 57 BufferedDataSource::CreateResourceLoader(first_byte_position, | |
| 58 last_byte_position); | |
| 59 | |
| 60 // Keep track of active loading state via loadAsynchronously() and cancel(). | |
| 61 NiceMock<MockWebURLLoader>* url_loader = new NiceMock<MockWebURLLoader>(); | |
| 62 ON_CALL(*url_loader, loadAsynchronously(_, _)) | |
| 63 .WillByDefault(Assign(&loading_, true)); | |
| 64 ON_CALL(*url_loader, cancel()) | |
| 65 .WillByDefault(Assign(&loading_, false)); | |
| 66 | |
| 67 // |test_loader_| will be used when Start() is called. | |
| 68 loader->test_loader_ = scoped_ptr<WebURLLoader>(url_loader); | |
| 69 return loader; | |
| 70 } | |
| 71 | |
| 72 bool loading() { return loading_; } | |
| 73 void set_loading(bool loading) { loading_ = loading; } | |
| 74 bool downloading() { return downloading_; } | |
| 75 void set_downloading(bool downloading) { downloading_ = downloading; } | |
| 76 | |
| 77 private: | |
| 78 // Whether the resource is downloading or deferred. | |
| 79 bool downloading_; | |
| 80 | |
| 81 // Whether the resource load has starting loading but yet to been cancelled. | |
| 82 bool loading_; | |
| 83 | |
| 84 DISALLOW_COPY_AND_ASSIGN(MockBufferedDataSource); | |
| 85 }; | |
| 86 | |
| 87 static const int64 kFileSize = 5000000; | |
| 88 static const int64 kFarReadPosition = 4000000; | |
| 89 static const int kDataSize = 1024; | |
| 90 | |
| 91 static const char kHttpUrl[] = "http://localhost/foo.webm"; | |
| 92 static const char kFileUrl[] = "file:///tmp/bar.webm"; | |
| 93 | |
| 94 class BufferedDataSourceTest : public testing::Test { | |
| 95 public: | |
| 96 BufferedDataSourceTest() | |
| 97 : view_(WebView::create(NULL)) { | |
| 98 view_->initializeMainFrame(&client_); | |
| 99 | |
| 100 data_source_.reset(new MockBufferedDataSource( | |
| 101 message_loop_.message_loop_proxy(), view_->mainFrame())); | |
| 102 data_source_->set_host(&host_); | |
| 103 } | |
| 104 | |
| 105 virtual ~BufferedDataSourceTest() { | |
| 106 view_->close(); | |
| 107 } | |
| 108 | |
| 109 MOCK_METHOD1(OnInitialize, void(bool)); | |
| 110 | |
| 111 void Initialize(const char* url, bool expected) { | |
| 112 GURL gurl(url); | |
| 113 response_generator_.reset(new TestResponseGenerator(gurl, kFileSize)); | |
| 114 | |
| 115 ExpectCreateResourceLoader(); | |
| 116 EXPECT_CALL(*this, OnInitialize(expected)); | |
| 117 data_source_->Initialize( | |
| 118 gurl, BufferedResourceLoader::kUnspecified, base::Bind( | |
| 119 &BufferedDataSourceTest::OnInitialize, base::Unretained(this))); | |
| 120 message_loop_.RunUntilIdle(); | |
| 121 | |
| 122 bool is_http = gurl.SchemeIs(kHttpScheme) || gurl.SchemeIs(kHttpsScheme); | |
| 123 EXPECT_EQ(data_source_->downloading(), is_http); | |
| 124 } | |
| 125 | |
| 126 // Helper to initialize tests with a valid 206 response. | |
| 127 void InitializeWith206Response() { | |
| 128 Initialize(kHttpUrl, true); | |
| 129 | |
| 130 EXPECT_CALL(host_, SetTotalBytes(response_generator_->content_length())); | |
| 131 Respond(response_generator_->Generate206(0)); | |
| 132 } | |
| 133 | |
| 134 // Helper to initialize tests with a valid file:// response. | |
| 135 void InitializeWithFileResponse() { | |
| 136 Initialize(kFileUrl, true); | |
| 137 | |
| 138 EXPECT_CALL(host_, SetTotalBytes(kFileSize)); | |
| 139 EXPECT_CALL(host_, AddBufferedByteRange(0, kFileSize)); | |
| 140 Respond(response_generator_->GenerateFileResponse(0)); | |
| 141 } | |
| 142 | |
| 143 // Stops any active loaders and shuts down the data source. | |
| 144 // | |
| 145 // This typically happens when the page is closed and for our purposes is | |
| 146 // appropriate to do when tearing down a test. | |
| 147 void Stop() { | |
| 148 if (data_source_->loading()) { | |
| 149 loader()->didFail(url_loader(), response_generator_->GenerateError()); | |
| 150 message_loop_.RunUntilIdle(); | |
| 151 } | |
| 152 | |
| 153 data_source_->Stop(media::NewExpectedClosure()); | |
| 154 message_loop_.RunUntilIdle(); | |
| 155 } | |
| 156 | |
| 157 void ExpectCreateResourceLoader() { | |
| 158 EXPECT_CALL(*data_source_, CreateResourceLoader(_, _)) | |
| 159 .WillOnce(Invoke(data_source_.get(), | |
| 160 &MockBufferedDataSource::CreateMockResourceLoader)); | |
| 161 message_loop_.RunUntilIdle(); | |
| 162 } | |
| 163 | |
| 164 void Respond(const WebURLResponse& response) { | |
| 165 loader()->didReceiveResponse(url_loader(), response); | |
| 166 message_loop_.RunUntilIdle(); | |
| 167 } | |
| 168 | |
| 169 void ReceiveData(int size) { | |
| 170 scoped_ptr<char[]> data(new char[size]); | |
| 171 memset(data.get(), 0xA5, size); // Arbitrary non-zero value. | |
| 172 | |
| 173 loader()->didReceiveData(url_loader(), data.get(), size, size); | |
| 174 message_loop_.RunUntilIdle(); | |
| 175 } | |
| 176 | |
| 177 void FinishLoading() { | |
| 178 data_source_->set_loading(false); | |
| 179 loader()->didFinishLoading(url_loader(), 0); | |
| 180 message_loop_.RunUntilIdle(); | |
| 181 } | |
| 182 | |
| 183 MOCK_METHOD1(ReadCallback, void(int size)); | |
| 184 | |
| 185 void ReadAt(int64 position) { | |
| 186 data_source_->Read(position, kDataSize, buffer_, | |
| 187 base::Bind(&BufferedDataSourceTest::ReadCallback, | |
| 188 base::Unretained(this))); | |
| 189 message_loop_.RunUntilIdle(); | |
| 190 } | |
| 191 | |
| 192 // Accessors for private variables on |data_source_|. | |
| 193 BufferedResourceLoader* loader() { | |
| 194 return data_source_->loader_.get(); | |
| 195 } | |
| 196 WebURLLoader* url_loader() { | |
| 197 return loader()->active_loader_->loader_.get(); | |
| 198 } | |
| 199 | |
| 200 Preload preload() { return data_source_->preload_; } | |
| 201 BufferedResourceLoader::DeferStrategy defer_strategy() { | |
| 202 return loader()->defer_strategy_; | |
| 203 } | |
| 204 int data_source_bitrate() { return data_source_->bitrate_; } | |
| 205 int data_source_playback_rate() { return data_source_->playback_rate_; } | |
| 206 int loader_bitrate() { return loader()->bitrate_; } | |
| 207 int loader_playback_rate() { return loader()->playback_rate_; } | |
| 208 | |
| 209 scoped_ptr<MockBufferedDataSource> data_source_; | |
| 210 | |
| 211 scoped_ptr<TestResponseGenerator> response_generator_; | |
| 212 MockWebFrameClient client_; | |
| 213 WebView* view_; | |
| 214 | |
| 215 StrictMock<media::MockDataSourceHost> host_; | |
| 216 base::MessageLoop message_loop_; | |
| 217 | |
| 218 private: | |
| 219 // Used for calling BufferedDataSource::Read(). | |
| 220 uint8 buffer_[kDataSize]; | |
| 221 | |
| 222 DISALLOW_COPY_AND_ASSIGN(BufferedDataSourceTest); | |
| 223 }; | |
| 224 | |
| 225 TEST_F(BufferedDataSourceTest, Range_Supported) { | |
| 226 Initialize(kHttpUrl, true); | |
| 227 | |
| 228 EXPECT_CALL(host_, SetTotalBytes(response_generator_->content_length())); | |
| 229 Respond(response_generator_->Generate206(0)); | |
| 230 | |
| 231 EXPECT_TRUE(data_source_->loading()); | |
| 232 EXPECT_FALSE(data_source_->IsStreaming()); | |
| 233 Stop(); | |
| 234 } | |
| 235 | |
| 236 TEST_F(BufferedDataSourceTest, Range_InstanceSizeUnknown) { | |
| 237 Initialize(kHttpUrl, true); | |
| 238 | |
| 239 Respond(response_generator_->Generate206( | |
| 240 0, TestResponseGenerator::kNoContentRangeInstanceSize)); | |
| 241 | |
| 242 EXPECT_TRUE(data_source_->loading()); | |
| 243 EXPECT_TRUE(data_source_->IsStreaming()); | |
| 244 Stop(); | |
| 245 } | |
| 246 | |
| 247 TEST_F(BufferedDataSourceTest, Range_NotFound) { | |
| 248 Initialize(kHttpUrl, false); | |
| 249 Respond(response_generator_->Generate404()); | |
| 250 | |
| 251 EXPECT_FALSE(data_source_->loading()); | |
| 252 Stop(); | |
| 253 } | |
| 254 | |
| 255 TEST_F(BufferedDataSourceTest, Range_NotSupported) { | |
| 256 Initialize(kHttpUrl, true); | |
| 257 EXPECT_CALL(host_, SetTotalBytes(response_generator_->content_length())); | |
| 258 Respond(response_generator_->Generate200()); | |
| 259 | |
| 260 EXPECT_TRUE(data_source_->loading()); | |
| 261 EXPECT_TRUE(data_source_->IsStreaming()); | |
| 262 Stop(); | |
| 263 } | |
| 264 | |
| 265 // Special carve-out for Apache versions that choose to return a 200 for | |
| 266 // Range:0- ("because it's more efficient" than a 206) | |
| 267 TEST_F(BufferedDataSourceTest, Range_SupportedButReturned200) { | |
| 268 Initialize(kHttpUrl, true); | |
| 269 EXPECT_CALL(host_, SetTotalBytes(response_generator_->content_length())); | |
| 270 WebURLResponse response = response_generator_->Generate200(); | |
| 271 response.setHTTPHeaderField(WebString::fromUTF8("Accept-Ranges"), | |
| 272 WebString::fromUTF8("bytes")); | |
| 273 Respond(response); | |
| 274 | |
| 275 EXPECT_TRUE(data_source_->loading()); | |
| 276 EXPECT_FALSE(data_source_->IsStreaming()); | |
| 277 Stop(); | |
| 278 } | |
| 279 | |
| 280 TEST_F(BufferedDataSourceTest, Range_MissingContentRange) { | |
| 281 Initialize(kHttpUrl, false); | |
| 282 Respond(response_generator_->Generate206( | |
| 283 0, TestResponseGenerator::kNoContentRange)); | |
| 284 | |
| 285 EXPECT_FALSE(data_source_->loading()); | |
| 286 Stop(); | |
| 287 } | |
| 288 | |
| 289 TEST_F(BufferedDataSourceTest, Range_MissingContentLength) { | |
| 290 Initialize(kHttpUrl, true); | |
| 291 | |
| 292 // It'll manage without a Content-Length response. | |
| 293 EXPECT_CALL(host_, SetTotalBytes(response_generator_->content_length())); | |
| 294 Respond(response_generator_->Generate206( | |
| 295 0, TestResponseGenerator::kNoContentLength)); | |
| 296 | |
| 297 EXPECT_TRUE(data_source_->loading()); | |
| 298 EXPECT_FALSE(data_source_->IsStreaming()); | |
| 299 Stop(); | |
| 300 } | |
| 301 | |
| 302 TEST_F(BufferedDataSourceTest, Range_WrongContentRange) { | |
| 303 Initialize(kHttpUrl, false); | |
| 304 | |
| 305 // Now it's done and will fail. | |
| 306 Respond(response_generator_->Generate206(1337)); | |
| 307 | |
| 308 EXPECT_FALSE(data_source_->loading()); | |
| 309 Stop(); | |
| 310 } | |
| 311 | |
| 312 // Test the case where the initial response from the server indicates that | |
| 313 // Range requests are supported, but a later request prove otherwise. | |
| 314 TEST_F(BufferedDataSourceTest, Range_ServerLied) { | |
| 315 InitializeWith206Response(); | |
| 316 | |
| 317 // Read causing a new request to be made -- we'll expect it to error. | |
| 318 ExpectCreateResourceLoader(); | |
| 319 ReadAt(kFarReadPosition); | |
| 320 | |
| 321 // Return a 200 in response to a range request. | |
| 322 EXPECT_CALL(*this, ReadCallback(media::DataSource::kReadError)); | |
| 323 Respond(response_generator_->Generate200()); | |
| 324 | |
| 325 EXPECT_FALSE(data_source_->loading()); | |
| 326 Stop(); | |
| 327 } | |
| 328 | |
| 329 TEST_F(BufferedDataSourceTest, Http_AbortWhileReading) { | |
| 330 InitializeWith206Response(); | |
| 331 | |
| 332 // Make sure there's a pending read -- we'll expect it to error. | |
| 333 ReadAt(0); | |
| 334 | |
| 335 // Abort!!! | |
| 336 EXPECT_CALL(*this, ReadCallback(media::DataSource::kReadError)); | |
| 337 data_source_->Abort(); | |
| 338 message_loop_.RunUntilIdle(); | |
| 339 | |
| 340 EXPECT_FALSE(data_source_->loading()); | |
| 341 Stop(); | |
| 342 } | |
| 343 | |
| 344 TEST_F(BufferedDataSourceTest, File_AbortWhileReading) { | |
| 345 InitializeWithFileResponse(); | |
| 346 | |
| 347 // Make sure there's a pending read -- we'll expect it to error. | |
| 348 ReadAt(0); | |
| 349 | |
| 350 // Abort!!! | |
| 351 EXPECT_CALL(*this, ReadCallback(media::DataSource::kReadError)); | |
| 352 data_source_->Abort(); | |
| 353 message_loop_.RunUntilIdle(); | |
| 354 | |
| 355 EXPECT_FALSE(data_source_->loading()); | |
| 356 Stop(); | |
| 357 } | |
| 358 | |
| 359 TEST_F(BufferedDataSourceTest, Http_Retry) { | |
| 360 InitializeWith206Response(); | |
| 361 | |
| 362 // Read to advance our position. | |
| 363 EXPECT_CALL(*this, ReadCallback(kDataSize)); | |
| 364 EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize - 1)); | |
| 365 ReadAt(0); | |
| 366 ReceiveData(kDataSize); | |
| 367 | |
| 368 // Issue a pending read but terminate the connection to force a retry. | |
| 369 ReadAt(kDataSize); | |
| 370 ExpectCreateResourceLoader(); | |
| 371 FinishLoading(); | |
| 372 Respond(response_generator_->Generate206(kDataSize)); | |
| 373 | |
| 374 // Complete the read. | |
| 375 EXPECT_CALL(*this, ReadCallback(kDataSize)); | |
| 376 EXPECT_CALL(host_, AddBufferedByteRange(kDataSize, (kDataSize * 2) - 1)); | |
| 377 ReceiveData(kDataSize); | |
| 378 | |
| 379 EXPECT_TRUE(data_source_->loading()); | |
| 380 Stop(); | |
| 381 } | |
| 382 | |
| 383 TEST_F(BufferedDataSourceTest, File_Retry) { | |
| 384 InitializeWithFileResponse(); | |
| 385 | |
| 386 // Read to advance our position. | |
| 387 EXPECT_CALL(*this, ReadCallback(kDataSize)); | |
| 388 ReadAt(0); | |
| 389 ReceiveData(kDataSize); | |
| 390 | |
| 391 // Issue a pending read but terminate the connection to force a retry. | |
| 392 ReadAt(kDataSize); | |
| 393 ExpectCreateResourceLoader(); | |
| 394 FinishLoading(); | |
| 395 Respond(response_generator_->GenerateFileResponse(kDataSize)); | |
| 396 | |
| 397 // Complete the read. | |
| 398 EXPECT_CALL(*this, ReadCallback(kDataSize)); | |
| 399 ReceiveData(kDataSize); | |
| 400 | |
| 401 EXPECT_TRUE(data_source_->loading()); | |
| 402 Stop(); | |
| 403 } | |
| 404 | |
| 405 TEST_F(BufferedDataSourceTest, Http_TooManyRetries) { | |
| 406 InitializeWith206Response(); | |
| 407 | |
| 408 // Make sure there's a pending read -- we'll expect it to error. | |
| 409 ReadAt(0); | |
| 410 | |
| 411 // It'll try three times. | |
| 412 ExpectCreateResourceLoader(); | |
| 413 FinishLoading(); | |
| 414 Respond(response_generator_->Generate206(0)); | |
| 415 | |
| 416 ExpectCreateResourceLoader(); | |
| 417 FinishLoading(); | |
| 418 Respond(response_generator_->Generate206(0)); | |
| 419 | |
| 420 ExpectCreateResourceLoader(); | |
| 421 FinishLoading(); | |
| 422 Respond(response_generator_->Generate206(0)); | |
| 423 | |
| 424 // It'll error after this. | |
| 425 EXPECT_CALL(*this, ReadCallback(media::DataSource::kReadError)); | |
| 426 FinishLoading(); | |
| 427 | |
| 428 EXPECT_FALSE(data_source_->loading()); | |
| 429 Stop(); | |
| 430 } | |
| 431 | |
| 432 TEST_F(BufferedDataSourceTest, File_TooManyRetries) { | |
| 433 InitializeWithFileResponse(); | |
| 434 | |
| 435 // Make sure there's a pending read -- we'll expect it to error. | |
| 436 ReadAt(0); | |
| 437 | |
| 438 // It'll try three times. | |
| 439 ExpectCreateResourceLoader(); | |
| 440 FinishLoading(); | |
| 441 Respond(response_generator_->GenerateFileResponse(0)); | |
| 442 | |
| 443 ExpectCreateResourceLoader(); | |
| 444 FinishLoading(); | |
| 445 Respond(response_generator_->GenerateFileResponse(0)); | |
| 446 | |
| 447 ExpectCreateResourceLoader(); | |
| 448 FinishLoading(); | |
| 449 Respond(response_generator_->GenerateFileResponse(0)); | |
| 450 | |
| 451 // It'll error after this. | |
| 452 EXPECT_CALL(*this, ReadCallback(media::DataSource::kReadError)); | |
| 453 FinishLoading(); | |
| 454 | |
| 455 EXPECT_FALSE(data_source_->loading()); | |
| 456 Stop(); | |
| 457 } | |
| 458 | |
| 459 TEST_F(BufferedDataSourceTest, File_InstanceSizeUnknown) { | |
| 460 Initialize(kFileUrl, false); | |
| 461 EXPECT_FALSE(data_source_->downloading()); | |
| 462 | |
| 463 Respond(response_generator_->GenerateFileResponse(-1)); | |
| 464 | |
| 465 EXPECT_FALSE(data_source_->loading()); | |
| 466 Stop(); | |
| 467 } | |
| 468 | |
| 469 TEST_F(BufferedDataSourceTest, File_Successful) { | |
| 470 InitializeWithFileResponse(); | |
| 471 | |
| 472 EXPECT_TRUE(data_source_->loading()); | |
| 473 EXPECT_FALSE(data_source_->IsStreaming()); | |
| 474 Stop(); | |
| 475 } | |
| 476 | |
| 477 static void SetTrue(bool* value) { | |
| 478 *value = true; | |
| 479 } | |
| 480 | |
| 481 // This test makes sure that Stop() does not require a task to run on | |
| 482 // |message_loop_| before it calls its callback. This prevents accidental | |
| 483 // introduction of a pipeline teardown deadlock. The pipeline owner blocks | |
| 484 // the render message loop while waiting for Stop() to complete. Since this | |
| 485 // object runs on the render message loop, Stop() will not complete if it | |
| 486 // requires a task to run on the the message loop that is being blocked. | |
| 487 TEST_F(BufferedDataSourceTest, StopDoesNotUseMessageLoopForCallback) { | |
| 488 InitializeWith206Response(); | |
| 489 | |
| 490 // Stop() the data source, using a callback that lets us verify that it was | |
| 491 // called before Stop() returns. This is to make sure that the callback does | |
| 492 // not require |message_loop_| to execute tasks before being called. | |
| 493 bool stop_done_called = false; | |
| 494 EXPECT_TRUE(data_source_->loading()); | |
| 495 data_source_->Stop(base::Bind(&SetTrue, &stop_done_called)); | |
| 496 | |
| 497 // Verify that the callback was called inside the Stop() call. | |
| 498 EXPECT_TRUE(stop_done_called); | |
| 499 message_loop_.RunUntilIdle(); | |
| 500 } | |
| 501 | |
| 502 TEST_F(BufferedDataSourceTest, StopDuringRead) { | |
| 503 InitializeWith206Response(); | |
| 504 | |
| 505 uint8 buffer[256]; | |
| 506 data_source_->Read(0, arraysize(buffer), buffer, base::Bind( | |
| 507 &BufferedDataSourceTest::ReadCallback, base::Unretained(this))); | |
| 508 | |
| 509 // The outstanding read should fail before the stop callback runs. | |
| 510 { | |
| 511 InSequence s; | |
| 512 EXPECT_CALL(*this, ReadCallback(media::DataSource::kReadError)); | |
| 513 data_source_->Stop(media::NewExpectedClosure()); | |
| 514 } | |
| 515 message_loop_.RunUntilIdle(); | |
| 516 } | |
| 517 | |
| 518 TEST_F(BufferedDataSourceTest, DefaultValues) { | |
| 519 InitializeWith206Response(); | |
| 520 | |
| 521 // Ensure we have sane values for default loading scenario. | |
| 522 EXPECT_EQ(AUTO, preload()); | |
| 523 EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy()); | |
| 524 | |
| 525 EXPECT_EQ(0, data_source_bitrate()); | |
| 526 EXPECT_EQ(0.0f, data_source_playback_rate()); | |
| 527 EXPECT_EQ(0, loader_bitrate()); | |
| 528 EXPECT_EQ(0.0f, loader_playback_rate()); | |
| 529 | |
| 530 EXPECT_TRUE(data_source_->loading()); | |
| 531 Stop(); | |
| 532 } | |
| 533 | |
| 534 TEST_F(BufferedDataSourceTest, SetBitrate) { | |
| 535 InitializeWith206Response(); | |
| 536 | |
| 537 data_source_->SetBitrate(1234); | |
| 538 message_loop_.RunUntilIdle(); | |
| 539 EXPECT_EQ(1234, data_source_bitrate()); | |
| 540 EXPECT_EQ(1234, loader_bitrate()); | |
| 541 | |
| 542 // Read so far ahead to cause the loader to get recreated. | |
| 543 BufferedResourceLoader* old_loader = loader(); | |
| 544 ExpectCreateResourceLoader(); | |
| 545 ReadAt(kFarReadPosition); | |
| 546 Respond(response_generator_->Generate206(kFarReadPosition)); | |
| 547 | |
| 548 // Verify loader changed but still has same bitrate. | |
| 549 EXPECT_NE(old_loader, loader()); | |
| 550 EXPECT_EQ(1234, loader_bitrate()); | |
| 551 | |
| 552 EXPECT_TRUE(data_source_->loading()); | |
| 553 EXPECT_CALL(*this, ReadCallback(media::DataSource::kReadError)); | |
| 554 Stop(); | |
| 555 } | |
| 556 | |
| 557 TEST_F(BufferedDataSourceTest, SetPlaybackRate) { | |
| 558 InitializeWith206Response(); | |
| 559 | |
| 560 data_source_->SetPlaybackRate(2.0f); | |
| 561 message_loop_.RunUntilIdle(); | |
| 562 EXPECT_EQ(2.0f, data_source_playback_rate()); | |
| 563 EXPECT_EQ(2.0f, loader_playback_rate()); | |
| 564 | |
| 565 // Read so far ahead to cause the loader to get recreated. | |
| 566 BufferedResourceLoader* old_loader = loader(); | |
| 567 ExpectCreateResourceLoader(); | |
| 568 ReadAt(kFarReadPosition); | |
| 569 Respond(response_generator_->Generate206(kFarReadPosition)); | |
| 570 | |
| 571 // Verify loader changed but still has same playback rate. | |
| 572 EXPECT_NE(old_loader, loader()); | |
| 573 | |
| 574 EXPECT_TRUE(data_source_->loading()); | |
| 575 EXPECT_CALL(*this, ReadCallback(media::DataSource::kReadError)); | |
| 576 Stop(); | |
| 577 } | |
| 578 | |
| 579 TEST_F(BufferedDataSourceTest, Http_Read) { | |
| 580 InitializeWith206Response(); | |
| 581 | |
| 582 ReadAt(0); | |
| 583 | |
| 584 // Receive first half of the read. | |
| 585 EXPECT_CALL(host_, AddBufferedByteRange(0, (kDataSize / 2) - 1)); | |
| 586 ReceiveData(kDataSize / 2); | |
| 587 | |
| 588 // Receive last half of the read. | |
| 589 EXPECT_CALL(*this, ReadCallback(kDataSize)); | |
| 590 EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize - 1)); | |
| 591 ReceiveData(kDataSize / 2); | |
| 592 | |
| 593 EXPECT_TRUE(data_source_->downloading()); | |
| 594 Stop(); | |
| 595 } | |
| 596 | |
| 597 TEST_F(BufferedDataSourceTest, Http_Read_Seek) { | |
| 598 InitializeWith206Response(); | |
| 599 | |
| 600 // Read a bit from the beginning. | |
| 601 ReadAt(0); | |
| 602 EXPECT_CALL(*this, ReadCallback(kDataSize)); | |
| 603 EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize - 1)); | |
| 604 ReceiveData(kDataSize); | |
| 605 | |
| 606 // Simulate a seek by reading a bit beyond kDataSize. | |
| 607 ReadAt(kDataSize * 2); | |
| 608 | |
| 609 // We receive data leading up to but not including our read. | |
| 610 EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize * 2 - 1)); | |
| 611 ReceiveData(kDataSize); | |
| 612 | |
| 613 // We now receive the rest of the data for our read. | |
| 614 EXPECT_CALL(*this, ReadCallback(kDataSize)); | |
| 615 EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize * 3 - 1)); | |
| 616 ReceiveData(kDataSize); | |
| 617 | |
| 618 EXPECT_TRUE(data_source_->downloading()); | |
| 619 Stop(); | |
| 620 } | |
| 621 | |
| 622 TEST_F(BufferedDataSourceTest, File_Read) { | |
| 623 InitializeWithFileResponse(); | |
| 624 | |
| 625 ReadAt(0); | |
| 626 | |
| 627 // Receive first half of the read but no buffering update. | |
| 628 ReceiveData(kDataSize / 2); | |
| 629 | |
| 630 // Receive last half of the read but no buffering update. | |
| 631 EXPECT_CALL(*this, ReadCallback(kDataSize)); | |
| 632 ReceiveData(kDataSize / 2); | |
| 633 | |
| 634 Stop(); | |
| 635 } | |
| 636 | |
| 637 TEST_F(BufferedDataSourceTest, Http_FinishLoading) { | |
| 638 InitializeWith206Response(); | |
| 639 | |
| 640 EXPECT_TRUE(data_source_->downloading()); | |
| 641 FinishLoading(); | |
| 642 EXPECT_FALSE(data_source_->downloading()); | |
| 643 | |
| 644 Stop(); | |
| 645 } | |
| 646 | |
| 647 TEST_F(BufferedDataSourceTest, File_FinishLoading) { | |
| 648 InitializeWithFileResponse(); | |
| 649 | |
| 650 EXPECT_FALSE(data_source_->downloading()); | |
| 651 FinishLoading(); | |
| 652 EXPECT_FALSE(data_source_->downloading()); | |
| 653 | |
| 654 Stop(); | |
| 655 } | |
| 656 | |
| 657 } // namespace webkit_media | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 18123002:
Migrate webkit/renderer/media/ to content/renderer/media/. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src