OLD | NEW |
1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "webkit/glue/media/buffered_data_source.h" | 5 #include "webkit/glue/media/buffered_data_source.h" |
6 | 6 |
7 #include "media/base/filter_host.h" | 7 #include "media/base/filter_host.h" |
8 #include "net/base/net_errors.h" | 8 #include "net/base/net_errors.h" |
9 #include "webkit/glue/media/web_data_source_factory.h" | 9 #include "webkit/glue/media/web_data_source_factory.h" |
| 10 #include "webkit/glue/media/defer_strategy.h" |
10 #include "webkit/glue/webkit_glue.h" | 11 #include "webkit/glue/webkit_glue.h" |
11 | 12 |
12 using WebKit::WebFrame; | 13 using WebKit::WebFrame; |
13 | 14 |
14 namespace webkit_glue { | 15 namespace webkit_glue { |
15 | 16 |
16 // Defines how long we should wait for more data before we declare a connection | 17 // Defines how long we should wait for more data before we declare a connection |
17 // timeout and start a new request. | 18 // timeout and start a new request. |
18 // TODO(hclam): Set it to 5s, calibrate this value later. | 19 // TODO(hclam): Set it to 5s, calibrate this value later. |
19 static const int kTimeoutMilliseconds = 5000; | 20 static const int kTimeoutMilliseconds = 5000; |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
57 read_position_(0), | 58 read_position_(0), |
58 read_size_(0), | 59 read_size_(0), |
59 read_buffer_(NULL), | 60 read_buffer_(NULL), |
60 read_attempts_(0), | 61 read_attempts_(0), |
61 intermediate_read_buffer_(new uint8[kInitialReadBufferSize]), | 62 intermediate_read_buffer_(new uint8[kInitialReadBufferSize]), |
62 intermediate_read_buffer_size_(kInitialReadBufferSize), | 63 intermediate_read_buffer_size_(kInitialReadBufferSize), |
63 render_loop_(render_loop), | 64 render_loop_(render_loop), |
64 stop_signal_received_(false), | 65 stop_signal_received_(false), |
65 stopped_on_render_loop_(false), | 66 stopped_on_render_loop_(false), |
66 media_is_paused_(true), | 67 media_is_paused_(true), |
| 68 media_has_played_(false), |
| 69 preload_(media::PRELOAD_METADATA), |
67 using_range_request_(true) { | 70 using_range_request_(true) { |
68 } | 71 } |
69 | 72 |
70 BufferedDataSource::~BufferedDataSource() { | 73 BufferedDataSource::~BufferedDataSource() { |
71 } | 74 } |
72 | 75 |
73 // A factory method to create BufferedResourceLoader using the read parameters. | 76 // A factory method to create BufferedResourceLoader using the read parameters. |
74 // This method can be overrided to inject mock BufferedResourceLoader object | 77 // This method can be overrided to inject mock BufferedResourceLoader object |
75 // for testing purpose. | 78 // for testing purpose. |
76 BufferedResourceLoader* BufferedDataSource::CreateResourceLoader( | 79 BufferedResourceLoader* BufferedDataSource::CreateResourceLoader( |
(...skipping 70 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
147 render_loop_->PostTask(FROM_HERE, | 150 render_loop_->PostTask(FROM_HERE, |
148 NewRunnableMethod(this, &BufferedDataSource::CleanupTask)); | 151 NewRunnableMethod(this, &BufferedDataSource::CleanupTask)); |
149 } | 152 } |
150 | 153 |
151 void BufferedDataSource::SetPlaybackRate(float playback_rate) { | 154 void BufferedDataSource::SetPlaybackRate(float playback_rate) { |
152 render_loop_->PostTask(FROM_HERE, | 155 render_loop_->PostTask(FROM_HERE, |
153 NewRunnableMethod(this, &BufferedDataSource::SetPlaybackRateTask, | 156 NewRunnableMethod(this, &BufferedDataSource::SetPlaybackRateTask, |
154 playback_rate)); | 157 playback_rate)); |
155 } | 158 } |
156 | 159 |
| 160 void BufferedDataSource::SetPreload(media::Preload preload) { |
| 161 render_loop_->PostTask(FROM_HERE, |
| 162 NewRunnableMethod(this, &BufferedDataSource::SetPreloadTask, |
| 163 preload)); |
| 164 } |
| 165 |
| 166 DeferStrategy* BufferedDataSource::ChooseDeferStrategy() { |
| 167 // If the user indicates preload=metadata, then just load exactly |
| 168 // what is needed for starting the pipeline and prerolling frames. |
| 169 if (preload_ == media::PRELOAD_METADATA && !media_has_played_) |
| 170 return ReadThenDeferStrategy::GetInstance(); |
| 171 |
| 172 // In general, we want to try to buffer the entire video when the video |
| 173 // is paused. But we don't want to do this if the video hasn't played yet |
| 174 // and preload!=auto. |
| 175 if (media_is_paused_ && |
| 176 (preload_ == media::PRELOAD_AUTO || media_has_played_)) { |
| 177 return NeverDeferStrategy::GetInstance(); |
| 178 } |
| 179 |
| 180 // When the video is playing, regardless of preload state, we buffer up |
| 181 // to a hard limit and enable/disable deferring when the buffer is |
| 182 // depleted/full. |
| 183 return ThresholdDeferStrategy::GetInstance(); |
| 184 } |
| 185 |
157 ///////////////////////////////////////////////////////////////////////////// | 186 ///////////////////////////////////////////////////////////////////////////// |
158 // media::DataSource implementation. | 187 // media::DataSource implementation. |
159 void BufferedDataSource::Read(int64 position, size_t size, uint8* data, | 188 void BufferedDataSource::Read(int64 position, size_t size, uint8* data, |
160 media::DataSource::ReadCallback* read_callback) { | 189 media::DataSource::ReadCallback* read_callback) { |
161 DCHECK(read_callback); | 190 DCHECK(read_callback); |
162 | 191 |
163 { | 192 { |
164 base::AutoLock auto_lock(lock_); | 193 base::AutoLock auto_lock(lock_); |
165 DCHECK(!read_callback_.get()); | 194 DCHECK(!read_callback_.get()); |
166 | 195 |
(...skipping 142 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
309 return; | 338 return; |
310 | 339 |
311 { | 340 { |
312 // If there's no outstanding read then return early. | 341 // If there's no outstanding read then return early. |
313 base::AutoLock auto_lock(lock_); | 342 base::AutoLock auto_lock(lock_); |
314 if (!read_callback_.get()) | 343 if (!read_callback_.get()) |
315 return; | 344 return; |
316 } | 345 } |
317 | 346 |
318 loader_ = CreateResourceLoader(read_position_, kPositionNotSpecified); | 347 loader_ = CreateResourceLoader(read_position_, kPositionNotSpecified); |
319 loader_->SetAllowDefer(!media_is_paused_); | 348 loader_->UpdateDeferStrategy(this); |
320 loader_->Start( | 349 loader_->Start( |
321 NewCallback(this, &BufferedDataSource::PartialReadStartCallback), | 350 NewCallback(this, &BufferedDataSource::PartialReadStartCallback), |
322 NewCallback(this, &BufferedDataSource::NetworkEventCallback), | 351 NewCallback(this, &BufferedDataSource::NetworkEventCallback), |
323 frame_); | 352 frame_); |
324 } | 353 } |
325 | 354 |
326 void BufferedDataSource::WatchDogTask() { | 355 void BufferedDataSource::WatchDogTask() { |
327 DCHECK(MessageLoop::current() == render_loop_); | 356 DCHECK(MessageLoop::current() == render_loop_); |
328 if (stopped_on_render_loop_) | 357 if (stopped_on_render_loop_) |
329 return; | 358 return; |
(...skipping 15 matching lines...) Expand all Loading... |
345 if (read_attempts_ >= kReadTrials) | 374 if (read_attempts_ >= kReadTrials) |
346 return; | 375 return; |
347 | 376 |
348 ++read_attempts_; | 377 ++read_attempts_; |
349 read_submitted_time_ = base::Time::Now(); | 378 read_submitted_time_ = base::Time::Now(); |
350 | 379 |
351 // Stops the current loader and creates a new resource loader and | 380 // Stops the current loader and creates a new resource loader and |
352 // retry the request. | 381 // retry the request. |
353 loader_->Stop(); | 382 loader_->Stop(); |
354 loader_ = CreateResourceLoader(read_position_, kPositionNotSpecified); | 383 loader_ = CreateResourceLoader(read_position_, kPositionNotSpecified); |
355 loader_->SetAllowDefer(!media_is_paused_); | 384 loader_->UpdateDeferStrategy(this); |
356 loader_->Start( | 385 loader_->Start( |
357 NewCallback(this, &BufferedDataSource::PartialReadStartCallback), | 386 NewCallback(this, &BufferedDataSource::PartialReadStartCallback), |
358 NewCallback(this, &BufferedDataSource::NetworkEventCallback), | 387 NewCallback(this, &BufferedDataSource::NetworkEventCallback), |
359 frame_); | 388 frame_); |
360 } | 389 } |
361 | 390 |
362 void BufferedDataSource::SetPlaybackRateTask(float playback_rate) { | 391 void BufferedDataSource::SetPlaybackRateTask(float playback_rate) { |
363 DCHECK(MessageLoop::current() == render_loop_); | 392 DCHECK(MessageLoop::current() == render_loop_); |
364 DCHECK(loader_.get()); | 393 DCHECK(loader_.get()); |
365 | 394 |
366 bool previously_paused = media_is_paused_; | 395 bool previously_paused = media_is_paused_; |
367 media_is_paused_ = (playback_rate == 0.0); | 396 media_is_paused_ = (playback_rate == 0.0); |
368 | 397 |
369 // Disallow deferring data when we are pausing, allow deferring data | 398 if (!media_has_played_ && previously_paused && !media_is_paused_) |
370 // when we resume playing. | 399 media_has_played_ = true; |
371 if (previously_paused && !media_is_paused_) { | 400 |
372 loader_->SetAllowDefer(true); | 401 loader_->UpdateDeferStrategy(this); |
373 } else if (!previously_paused && media_is_paused_) { | 402 } |
374 loader_->SetAllowDefer(false); | 403 |
375 } | 404 void BufferedDataSource::SetPreloadTask(media::Preload preload) { |
| 405 DCHECK(MessageLoop::current() == render_loop_); |
| 406 preload_ = preload; |
376 } | 407 } |
377 | 408 |
378 // This method is the place where actual read happens, |loader_| must be valid | 409 // This method is the place where actual read happens, |loader_| must be valid |
379 // prior to make this method call. | 410 // prior to make this method call. |
380 void BufferedDataSource::ReadInternal() { | 411 void BufferedDataSource::ReadInternal() { |
381 DCHECK(MessageLoop::current() == render_loop_); | 412 DCHECK(MessageLoop::current() == render_loop_); |
382 DCHECK(loader_); | 413 DCHECK(loader_); |
383 | 414 |
384 // First we prepare the intermediate read buffer for BufferedResourceLoader | 415 // First we prepare the intermediate read buffer for BufferedResourceLoader |
385 // to write to. | 416 // to write to. |
(...skipping 269 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
655 | 686 |
656 if (streaming_) { | 687 if (streaming_) { |
657 filter_host->SetStreaming(true); | 688 filter_host->SetStreaming(true); |
658 } else { | 689 } else { |
659 filter_host->SetTotalBytes(total_bytes_); | 690 filter_host->SetTotalBytes(total_bytes_); |
660 filter_host->SetBufferedBytes(buffered_bytes_); | 691 filter_host->SetBufferedBytes(buffered_bytes_); |
661 } | 692 } |
662 } | 693 } |
663 | 694 |
664 } // namespace webkit_glue | 695 } // namespace webkit_glue |
OLD | NEW |