Improve retry support for media network loading.

media/blink/buffered_data_source.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/blink/buffered_data_source.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/single_thread_task_runner.h"
 #include "media/base/media_log.h"
 #include "net/base/net_errors.h"
 
 using blink::WebFrame;
 
 namespace {
 
 // BufferedDataSource has an intermediate buffer, this value governs the initial
 // size of that buffer. It is set to 32KB because this is a typical read size
 // of FFmpeg.
 const int kInitialReadBufferSize = 32768;
 
 // Number of cache misses or read failures we allow for a single Read() before
 // signaling an error.
-const int kLoaderRetries = 3;
+// total delay is:
+// (kLoaderPartialRetryDelayMs +
+//  kAdditionalDelayPerRetryMs * (kMaxRetries - 1) / 2) * kMaxretries = 29250 ms
+const int kLoaderRetries = 30;
 
 // The number of milliseconds to wait before retrying a failed load.
 const int kLoaderFailedRetryDelayMs = 250;
 
+// Each retry, add this many MS to the delay.
+const int kAdditionalDelayPerRetryMs = 50;
+
 }  // namespace
 
 namespace media {
 
 class BufferedDataSource::ReadOperation {
  public:
   ReadOperation(int64_t position,
                 int size,
                 uint8_t* data,
                 const DataSource::ReadCB& callback);
@@ skipping 441 matching lines @@
 
     if (read_op_->retries() < kLoaderRetries) {
       // Allow some resiliency against sporadic network failures or intentional
       // cancellations due to a system suspend / resume.  Here we treat failed
       // reads as a cache miss so long as we haven't exceeded max retries.
       if (status == BufferedResourceLoader::kFailed) {
         render_task_runner_->PostDelayedTask(
             FROM_HERE, base::Bind(&BufferedDataSource::ReadCallback,
                                   weak_factory_.GetWeakPtr(),
                                   BufferedResourceLoader::kCacheMiss, 0),
-            base::TimeDelta::FromMilliseconds(kLoaderFailedRetryDelayMs));
+            base::TimeDelta::FromMilliseconds(kLoaderFailedRetryDelayMs +
+                                              read_op_->retries() *
+                                                  kAdditionalDelayPerRetryMs));
         return;
       }
 
       read_op_->IncrementRetries();
 
       // Recreate a loader starting from where we last left off until the
       // end of the resource.
       loader_.reset(CreateResourceLoader(
           read_op_->position(), kPositionNotSpecified));
 
@@ skipping 95 matching lines @@
   }
 
   // If media is currently playing or the page indicated preload=auto or the
   // the server does not support the byte range request or we do not want to go
   // too far ahead of the read head, use threshold strategy to enable/disable
   // deferring when the buffer is full/depleted.
   loader_->UpdateDeferStrategy(BufferedResourceLoader::kCapacityDefer);
 }
 
 }  // namespace media