media/blink/buffered_data_source.cc

   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 "media/blink/buffered_data_source.h"
   6
   7 #include "base/bind.h"
   8 #include "base/callback_helpers.h"
   9 #include "base/location.h"
  10 #include "base/single_thread_task_runner.h"
  11 #include "media/base/media_log.h"
  12 #include "net/base/net_errors.h"
  13
  14 using blink::WebFrame;
  15
  16 namespace {
  17
  18 // BufferedDataSource has an intermediate buffer, this value governs the initial
  19 // size of that buffer. It is set to 32KB because this is a typical read size
  20 // of FFmpeg.
  21 const int kInitialReadBufferSize = 32768;
  22
  23 // Number of cache misses or read failures we allow for a single Read() before
  24 // signaling an error.
  25 const int kLoaderRetries = 3;
  26
  27 // The number of milliseconds to wait before retrying a failed load.
  28 const int kLoaderFailedRetryDelayMs = 250;
  29
  30 }  // namespace
  31
  32 namespace media {
  33
  34 class BufferedDataSource::ReadOperation {
  35  public:
  36   ReadOperation(int64 position, int size, uint8* data,
  37                 const DataSource::ReadCB& callback);
  38   ~ReadOperation();
  39
  40   // Runs |callback_| with the given |result|, deleting the operation
  41   // afterwards.
  42   static void Run(scoped_ptr<ReadOperation> read_op, int result);
  43
  44   // State for the number of times this read operation has been retried.
  45   int retries() { return retries_; }
  46   void IncrementRetries() { ++retries_; }
  47
  48   int64 position() { return position_; }
  49   int size() { return size_; }
  50   uint8* data() { return data_; }
  51
  52  private:
  53   int retries_;
  54
  55   const int64 position_;
  56   const int size_;
  57   uint8* data_;
  58   DataSource::ReadCB callback_;
  59
  60   DISALLOW_IMPLICIT_CONSTRUCTORS(ReadOperation);
  61 };
  62
  63 BufferedDataSource::ReadOperation::ReadOperation(
  64     int64 position, int size, uint8* data,
  65     const DataSource::ReadCB& callback)
  66     : retries_(0),
  67       position_(position),
  68       size_(size),
  69       data_(data),
  70       callback_(callback) {
  71   DCHECK(!callback_.is_null());
  72 }
  73
  74 BufferedDataSource::ReadOperation::~ReadOperation() {
  75   DCHECK(callback_.is_null());
  76 }
  77
  78 // static
  79 void BufferedDataSource::ReadOperation::Run(
  80     scoped_ptr<ReadOperation> read_op, int result) {
  81   base::ResetAndReturn(&read_op->callback_).Run(result);
  82 }
  83
  84 BufferedDataSource::BufferedDataSource(
  85     const GURL& url,
  86     BufferedResourceLoader::CORSMode cors_mode,
  87     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
  88     WebFrame* frame,
  89     MediaLog* media_log,
  90     BufferedDataSourceHost* host,
  91     const DownloadingCB& downloading_cb)
  92     : url_(url),
  93       cors_mode_(cors_mode),
  94       total_bytes_(kPositionNotSpecified),
  95       streaming_(false),
  96       frame_(frame),
  97       intermediate_read_buffer_(kInitialReadBufferSize),
  98       render_task_runner_(task_runner),
  99       stop_signal_received_(false),
 100       media_has_played_(false),
 101       preload_(AUTO),
 102       bitrate_(0),
 103       playback_rate_(0.0),
 104       media_log_(media_log),
 105       host_(host),
 106       downloading_cb_(downloading_cb),
 107       weak_factory_(this) {
 108   weak_ptr_ = weak_factory_.GetWeakPtr();
 109   DCHECK(host_);
 110   DCHECK(!downloading_cb_.is_null());
 111   DCHECK(render_task_runner_->BelongsToCurrentThread());
 112 }
 113
 114 BufferedDataSource::~BufferedDataSource() {
 115   DCHECK(render_task_runner_->BelongsToCurrentThread());
 116 }
 117
 118 // A factory method to create BufferedResourceLoader using the read parameters.
 119 // This method can be overridden to inject mock BufferedResourceLoader object
 120 // for testing purpose.
 121 BufferedResourceLoader* BufferedDataSource::CreateResourceLoader(
 122     int64 first_byte_position, int64 last_byte_position) {
 123   DCHECK(render_task_runner_->BelongsToCurrentThread());
 124
 125   BufferedResourceLoader::DeferStrategy strategy = preload_ == METADATA ?
 126       BufferedResourceLoader::kReadThenDefer :
 127       BufferedResourceLoader::kCapacityDefer;
 128
 129   return new BufferedResourceLoader(url_,
 130                                     cors_mode_,
 131                                     first_byte_position,
 132                                     last_byte_position,
 133                                     strategy,
 134                                     bitrate_,
 135                                     playback_rate_,
 136                                     media_log_.get());
 137 }
 138
 139 void BufferedDataSource::Initialize(const InitializeCB& init_cb) {
 140   DCHECK(render_task_runner_->BelongsToCurrentThread());
 141   DCHECK(!init_cb.is_null());
 142   DCHECK(!loader_.get());
 143
 144   init_cb_ = init_cb;
 145
 146   if (url_.SchemeIsHTTPOrHTTPS()) {
 147     // Do an unbounded range request starting at the beginning.  If the server
 148     // responds with 200 instead of 206 we'll fall back into a streaming mode.
 149     loader_.reset(CreateResourceLoader(0, kPositionNotSpecified));
 150   } else {
 151     // For all other protocols, assume they support range request. We fetch
 152     // the full range of the resource to obtain the instance size because
 153     // we won't be served HTTP headers.
 154     loader_.reset(CreateResourceLoader(kPositionNotSpecified,
 155                                        kPositionNotSpecified));
 156   }
 157
 158   base::WeakPtr<BufferedDataSource> weak_this = weak_factory_.GetWeakPtr();
 159   loader_->Start(
 160       base::Bind(&BufferedDataSource::StartCallback, weak_this),
 161       base::Bind(&BufferedDataSource::LoadingStateChangedCallback, weak_this),
 162       base::Bind(&BufferedDataSource::ProgressCallback, weak_this),
 163       frame_);
 164 }
 165
 166 void BufferedDataSource::SetPreload(Preload preload) {
 167   DCHECK(render_task_runner_->BelongsToCurrentThread());
 168   preload_ = preload;
 169 }
 170
 171 bool BufferedDataSource::HasSingleOrigin() {
 172   DCHECK(render_task_runner_->BelongsToCurrentThread());
 173   DCHECK(init_cb_.is_null() && loader_.get())
 174       << "Initialize() must complete before calling HasSingleOrigin()";
 175   return loader_->HasSingleOrigin();
 176 }
 177
 178 bool BufferedDataSource::DidPassCORSAccessCheck() const {
 179   return loader_.get() && loader_->DidPassCORSAccessCheck();
 180 }
 181
 182 void BufferedDataSource::Abort() {
 183   DCHECK(render_task_runner_->BelongsToCurrentThread());
 184   {
 185     base::AutoLock auto_lock(lock_);
 186     StopInternal_Locked();
 187   }
 188   StopLoader();
 189   frame_ = NULL;
 190 }
 191
 192 void BufferedDataSource::MediaPlaybackRateChanged(float playback_rate) {
 193   DCHECK(render_task_runner_->BelongsToCurrentThread());
 194   DCHECK(loader_.get());
 195
 196   if (playback_rate < 0.0f)
 197     return;
 198
 199   playback_rate_ = playback_rate;
 200   loader_->SetPlaybackRate(playback_rate);
 201 }
 202
 203 void BufferedDataSource::MediaIsPlaying() {
 204   DCHECK(render_task_runner_->BelongsToCurrentThread());
 205   media_has_played_ = true;
 206   UpdateDeferStrategy(false);
 207 }
 208
 209 void BufferedDataSource::MediaIsPaused() {
 210   DCHECK(render_task_runner_->BelongsToCurrentThread());
 211   UpdateDeferStrategy(true);
 212 }
 213
 214 /////////////////////////////////////////////////////////////////////////////
 215 // DataSource implementation.
 216 void BufferedDataSource::Stop() {
 217   {
 218     base::AutoLock auto_lock(lock_);
 219     StopInternal_Locked();
 220   }
 221
 222   render_task_runner_->PostTask(
 223       FROM_HERE,
 224       base::Bind(&BufferedDataSource::StopLoader, weak_factory_.GetWeakPtr()));
 225 }
 226
 227 void BufferedDataSource::SetBitrate(int bitrate) {
 228   render_task_runner_->PostTask(FROM_HERE,
 229                          base::Bind(&BufferedDataSource::SetBitrateTask,
 230                                     weak_factory_.GetWeakPtr(),
 231                                     bitrate));
 232 }
 233
 234 void BufferedDataSource::Read(
 235     int64 position, int size, uint8* data,
 236     const DataSource::ReadCB& read_cb) {
 237   DVLOG(1) << "Read: " << position << " offset, " << size << " bytes";
 238   DCHECK(!read_cb.is_null());
 239
 240   {
 241     base::AutoLock auto_lock(lock_);
 242     DCHECK(!read_op_);
 243
 244     if (stop_signal_received_) {
 245       read_cb.Run(kReadError);
 246       return;
 247     }
 248
 249     read_op_.reset(new ReadOperation(position, size, data, read_cb));
 250   }
 251
 252   render_task_runner_->PostTask(
 253       FROM_HERE,
 254       base::Bind(&BufferedDataSource::ReadTask, weak_factory_.GetWeakPtr()));
 255 }
 256
 257 bool BufferedDataSource::GetSize(int64* size_out) {
 258   if (total_bytes_ != kPositionNotSpecified) {
 259     *size_out = total_bytes_;
 260     return true;
 261   }
 262   *size_out = 0;
 263   return false;
 264 }
 265
 266 bool BufferedDataSource::IsStreaming() {
 267   return streaming_;
 268 }
 269
 270 /////////////////////////////////////////////////////////////////////////////
 271 // Render thread tasks.
 272 void BufferedDataSource::ReadTask() {
 273   DCHECK(render_task_runner_->BelongsToCurrentThread());
 274   ReadInternal();
 275 }
 276
 277 void BufferedDataSource::StopInternal_Locked() {
 278   lock_.AssertAcquired();
 279   if (stop_signal_received_)
 280     return;
 281
 282   stop_signal_received_ = true;
 283
 284   // Initialize() isn't part of the DataSource interface so don't call it in
 285   // response to Stop().
 286   init_cb_.Reset();
 287
 288   if (read_op_)
 289     ReadOperation::Run(read_op_.Pass(), kReadError);
 290 }
 291
 292 void BufferedDataSource::StopLoader() {
 293   DCHECK(render_task_runner_->BelongsToCurrentThread());
 294
 295   if (loader_)
 296     loader_->Stop();
 297 }
 298
 299 void BufferedDataSource::SetBitrateTask(int bitrate) {
 300   DCHECK(render_task_runner_->BelongsToCurrentThread());
 301   DCHECK(loader_.get());
 302
 303   bitrate_ = bitrate;
 304   loader_->SetBitrate(bitrate);
 305 }
 306
 307 // This method is the place where actual read happens, |loader_| must be valid
 308 // prior to make this method call.
 309 void BufferedDataSource::ReadInternal() {
 310   DCHECK(render_task_runner_->BelongsToCurrentThread());
 311   int64 position = 0;
 312   int size = 0;
 313   {
 314     base::AutoLock auto_lock(lock_);
 315     if (stop_signal_received_)
 316       return;
 317
 318     position = read_op_->position();
 319     size = read_op_->size();
 320   }
 321
 322   // First we prepare the intermediate read buffer for BufferedResourceLoader
 323   // to write to.
 324   if (static_cast<int>(intermediate_read_buffer_.size()) < size)
 325     intermediate_read_buffer_.resize(size);
 326
 327   // Perform the actual read with BufferedResourceLoader.
 328   DCHECK(!intermediate_read_buffer_.empty());
 329   loader_->Read(position,
 330                 size,
 331                 &intermediate_read_buffer_[0],
 332                 base::Bind(&BufferedDataSource::ReadCallback,
 333                            weak_factory_.GetWeakPtr()));
 334 }
 335
 336
 337 /////////////////////////////////////////////////////////////////////////////
 338 // BufferedResourceLoader callback methods.
 339 void BufferedDataSource::StartCallback(
 340     BufferedResourceLoader::Status status) {
 341   DCHECK(render_task_runner_->BelongsToCurrentThread());
 342   DCHECK(loader_.get());
 343
 344   bool init_cb_is_null = false;
 345   {
 346     base::AutoLock auto_lock(lock_);
 347     init_cb_is_null = init_cb_.is_null();
 348   }
 349   if (init_cb_is_null) {
 350     loader_->Stop();
 351     return;
 352   }
 353
 354   // All responses must be successful. Resources that are assumed to be fully
 355   // buffered must have a known content length.
 356   bool success = status == BufferedResourceLoader::kOk &&
 357                  (!assume_fully_buffered() ||
 358                   loader_->instance_size() != kPositionNotSpecified);
 359
 360   if (success) {
 361     total_bytes_ = loader_->instance_size();
 362     streaming_ =
 363         !assume_fully_buffered() &&
 364         (total_bytes_ == kPositionNotSpecified || !loader_->range_supported());
 365
 366     media_log_->SetDoubleProperty("total_bytes",
 367                                   static_cast<double>(total_bytes_));
 368     media_log_->SetBooleanProperty("streaming", streaming_);
 369   } else {
 370     loader_->Stop();
 371   }
 372
 373   // TODO(scherkus): we shouldn't have to lock to signal host(), see
 374   // http://crbug.com/113712 for details.
 375   base::AutoLock auto_lock(lock_);
 376   if (stop_signal_received_)
 377     return;
 378
 379   if (success) {
 380     if (total_bytes_ != kPositionNotSpecified) {
 381       host_->SetTotalBytes(total_bytes_);
 382       if (assume_fully_buffered())
 383         host_->AddBufferedByteRange(0, total_bytes_);
 384     }
 385
 386     media_log_->SetBooleanProperty("single_origin", loader_->HasSingleOrigin());
 387     media_log_->SetBooleanProperty("passed_cors_access_check",
 388                                    loader_->DidPassCORSAccessCheck());
 389     media_log_->SetBooleanProperty("range_header_supported",
 390                                    loader_->range_supported());
 391   }
 392
 393   base::ResetAndReturn(&init_cb_).Run(success);
 394 }
 395
 396 void BufferedDataSource::PartialReadStartCallback(
 397     BufferedResourceLoader::Status status) {
 398   DCHECK(render_task_runner_->BelongsToCurrentThread());
 399   DCHECK(loader_.get());
 400
 401   if (status == BufferedResourceLoader::kOk) {
 402     // Once the request has started successfully, we can proceed with
 403     // reading from it.
 404     ReadInternal();
 405     return;
 406   }
 407
 408   // Stop the resource loader since we have received an error.
 409   loader_->Stop();
 410
 411   // TODO(scherkus): we shouldn't have to lock to signal host(), see
 412   // http://crbug.com/113712 for details.
 413   base::AutoLock auto_lock(lock_);
 414   if (stop_signal_received_)
 415     return;
 416   ReadOperation::Run(read_op_.Pass(), kReadError);
 417 }
 418
 419 void BufferedDataSource::ReadCallback(
 420     BufferedResourceLoader::Status status,
 421     int bytes_read) {
 422   DCHECK(render_task_runner_->BelongsToCurrentThread());
 423
 424   // TODO(scherkus): we shouldn't have to lock to signal host(), see
 425   // http://crbug.com/113712 for details.
 426   base::AutoLock auto_lock(lock_);
 427   if (stop_signal_received_)
 428     return;
 429
 430   if (status != BufferedResourceLoader::kOk) {
 431     // Stop the resource load if it failed.
 432     loader_->Stop();
 433
 434     if (read_op_->retries() < kLoaderRetries) {
 435       // Allow some resiliency against sporadic network failures or intentional
 436       // cancellations due to a system suspend / resume.  Here we treat failed
 437       // reads as a cache miss so long as we haven't exceeded max retries.
 438       if (status == BufferedResourceLoader::kFailed) {
 439         render_task_runner_->PostDelayedTask(
 440             FROM_HERE, base::Bind(&BufferedDataSource::ReadCallback,
 441                                   weak_factory_.GetWeakPtr(),
 442                                   BufferedResourceLoader::kCacheMiss, 0),
 443             base::TimeDelta::FromMilliseconds(kLoaderFailedRetryDelayMs));
 444         return;
 445       }
 446
 447       read_op_->IncrementRetries();
 448
 449       // Recreate a loader starting from where we last left off until the
 450       // end of the resource.
 451       loader_.reset(CreateResourceLoader(
 452           read_op_->position(), kPositionNotSpecified));
 453
 454       base::WeakPtr<BufferedDataSource> weak_this = weak_factory_.GetWeakPtr();
 455       loader_->Start(
 456           base::Bind(&BufferedDataSource::PartialReadStartCallback, weak_this),
 457           base::Bind(&BufferedDataSource::LoadingStateChangedCallback,
 458                      weak_this),
 459           base::Bind(&BufferedDataSource::ProgressCallback, weak_this),
 460           frame_);
 461       return;
 462     }
 463
 464     ReadOperation::Run(read_op_.Pass(), kReadError);
 465     return;
 466   }
 467
 468   if (bytes_read > 0) {
 469     DCHECK(!intermediate_read_buffer_.empty());
 470     memcpy(read_op_->data(), &intermediate_read_buffer_[0], bytes_read);
 471   } else if (bytes_read == 0 && total_bytes_ == kPositionNotSpecified) {
 472     // We've reached the end of the file and we didn't know the total size
 473     // before. Update the total size so Read()s past the end of the file will
 474     // fail like they would if we had known the file size at the beginning.
 475     total_bytes_ = loader_->instance_size();
 476
 477     if (total_bytes_ != kPositionNotSpecified) {
 478       host_->SetTotalBytes(total_bytes_);
 479       host_->AddBufferedByteRange(loader_->first_byte_position(),
 480                                   total_bytes_);
 481     }
 482   }
 483   ReadOperation::Run(read_op_.Pass(), bytes_read);
 484 }
 485
 486 void BufferedDataSource::LoadingStateChangedCallback(
 487     BufferedResourceLoader::LoadingState state) {
 488   DCHECK(render_task_runner_->BelongsToCurrentThread());
 489
 490   if (assume_fully_buffered())
 491     return;
 492
 493   bool is_downloading_data;
 494   switch (state) {
 495     case BufferedResourceLoader::kLoading:
 496       is_downloading_data = true;
 497       break;
 498     case BufferedResourceLoader::kLoadingDeferred:
 499     case BufferedResourceLoader::kLoadingFinished:
 500       is_downloading_data = false;
 501       break;
 502
 503     // TODO(scherkus): we don't signal network activity changes when loads
 504     // fail to preserve existing behaviour when deferring is toggled, however
 505     // we should consider changing DownloadingCB to also propagate loading
 506     // state. For example there isn't any signal today to notify the client that
 507     // loading has failed (we only get errors on subsequent reads).
 508     case BufferedResourceLoader::kLoadingFailed:
 509       return;
 510   }
 511
 512   downloading_cb_.Run(is_downloading_data);
 513 }
 514
 515 void BufferedDataSource::ProgressCallback(int64 position) {
 516   DCHECK(render_task_runner_->BelongsToCurrentThread());
 517
 518   if (assume_fully_buffered())
 519     return;
 520
 521   // TODO(scherkus): we shouldn't have to lock to signal host(), see
 522   // http://crbug.com/113712 for details.
 523   base::AutoLock auto_lock(lock_);
 524   if (stop_signal_received_)
 525     return;
 526
 527   host_->AddBufferedByteRange(loader_->first_byte_position(), position);
 528 }
 529
 530 void BufferedDataSource::UpdateDeferStrategy(bool paused) {
 531   // No need to aggressively buffer when we are assuming the resource is fully
 532   // buffered.
 533   if (assume_fully_buffered()) {
 534     loader_->UpdateDeferStrategy(BufferedResourceLoader::kCapacityDefer);
 535     return;
 536   }
 537
 538   // If the playback has started (at which point the preload value is ignored)
 539   // and we're paused, then try to load as much as possible (the loader will
 540   // fall back to kCapacityDefer if it knows the current response won't be
 541   // useful from the cache in the future).
 542   if (media_has_played_ && paused && loader_->range_supported()) {
 543     loader_->UpdateDeferStrategy(BufferedResourceLoader::kNeverDefer);
 544     return;
 545   }
 546
 547   // If media is currently playing or the page indicated preload=auto or the
 548   // the server does not support the byte range request or we do not want to go
 549   // too far ahead of the read head, use threshold strategy to enable/disable
 550   // deferring when the buffer is full/depleted.
 551   loader_->UpdateDeferStrategy(BufferedResourceLoader::kCapacityDefer);
 552 }
 553
 554 }  // namespace media