Merge 21982 - Retry requests that has timed out in BufferedDataSource...

webkit/glue/media/buffered_data_source.cc

 // Copyright (c) 2009 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 "base/compiler_specific.h"
 #include "base/message_loop.h"
 #include "base/process_util.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "chrome/common/extensions/url_pattern.h"
@@ skipping 31 matching lines @@
 // number of bytes, we should determine this value from typical connection speed
 // and amount of time for a suitable wait. Now I just make a guess for this
 // number to be 2MB.
 // TODO(hclam): determine a better value for this.
 const int kForwardWaitThreshold = 2 * kMegabyte;
 
 // Defines how long we should wait for more data before we declare a connection
 // timeout and start a new request.
 // TODO(hclam): Use this value when retry is implemented.
 // TODO(hclam): Set it to 5s, calibrate this value later.
-const int kDataTransferTimeoutSeconds = 5;
+const int kTimeoutMilliseconds = 5000;
 
 // Defines how many times we should try to read from a buffered resource loader
 // before we declare a read error. After each failure of read from a buffered
 // resource loader, a new one is created to be read.
 // TODO(hclam): Use this value when retry is implemented.
 const int kReadTrials = 3;
 
 // 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.
@@ skipping 377 matching lines @@
 // for testing purpose.
 BufferedResourceLoader* BufferedDataSource::CreateLoader(
     int64 first_byte_position, int64 last_byte_position) {
   DCHECK(MessageLoop::current() == render_loop_);
 
   return new BufferedResourceLoader(bridge_factory_.get(), url_,
                                     first_byte_position,
                                     last_byte_position);
 }
 
+// This method simply returns kTimeoutMilliseconds. The purpose of this
+// method is to be overidded so as to provide a different timeout value
+// for testing purpose.
+base::TimeDelta BufferedDataSource::GetTimeoutMilliseconds() {
+  return base::TimeDelta::FromMilliseconds(kTimeoutMilliseconds);
+}
+
 /////////////////////////////////////////////////////////////////////////////
 // BufferedDataSource, media::MediaFilter implementation
 void BufferedDataSource::Initialize(const std::string& url,
                                     media::FilterCallback* callback) {
   DCHECK(callback);
   initialize_callback_.reset(callback);
 
   // Saves the url.
   url_ = GURL(url);
 
@@ skipping 43 matching lines @@
 bool BufferedDataSource::IsSeekable() {
   return total_bytes_ != kPositionNotSpecified;
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // BufferedDataSource, render thread tasks
 void BufferedDataSource::InitializeTask() {
   DCHECK(MessageLoop::current() == render_loop_);
   DCHECK(!loader_.get());
 
+  // Kick starts the watch dog task that will handle connection timeout.
+  // We run the watch dog 2 times faster the actual timeout so as to catch
+  // the timeout more accurately.
+  watch_dog_timer_.Start(
+      GetTimeoutMilliseconds() / 2,
+      this,
+      &BufferedDataSource::WatchDogTask);
+
   // Creates a new resource loader with the full range.
   loader_.reset(CreateLoader(-1, -1));
 
   // And then start the resource request.
   loader_->Start(NewCallback(this,
                              &BufferedDataSource::InitializeStartCallback));
 }
 
 void BufferedDataSource::ReadTask(
      int64 position, int read_size, uint8* buffer,
      media::DataSource::ReadCallback* read_callback) {
   DCHECK(MessageLoop::current() == render_loop_);
   DCHECK(!read_callback_.get());
   DCHECK(read_callback);
 
   // Saves the read parameters.
   read_position_ = position;
   read_size_ = read_size;
   read_callback_.reset(read_callback);
   read_buffer_ = buffer;
+  read_submitted_time_ = base::Time::Now();
+  read_attempts_ = 0;
 
   // Call to read internal to perform the actual read.
   ReadInternal();
 }
 
 void BufferedDataSource::StopTask() {
   DCHECK(MessageLoop::current() == render_loop_);
 
+  // Stop the watch dog.
+  watch_dog_timer_.Stop();
+
   // We just need to stop the loader, so it stops activity.
   if (loader_.get()) {
     loader_->Stop();
     loader_.reset();
   }
+
+  // Reset the parameters of the current read request.
+  read_callback_.reset();
+  read_position_ = 0;
+  read_size_ = 0;
+  read_buffer_ = 0;
+  read_submitted_time_ = base::Time();
+  read_attempts_ = 0;
 }
 
 void BufferedDataSource::SwapLoaderTask(BufferedResourceLoader* loader) {
   DCHECK(MessageLoop::current() == render_loop_);
   DCHECK(loader);
 
   loader_.reset(loader);
   loader_->Start(NewCallback(this,
                              &BufferedDataSource::PartialReadStartCallback));
 }
 
+void BufferedDataSource::WatchDogTask() {
+  DCHECK(MessageLoop::current() == render_loop_);
+
+  // We only care if there is an active read request.
+  if (!read_callback_.get())
+    return;
+
+  DCHECK(loader_.get());
+  base::TimeDelta delta = base::Time::Now() - read_submitted_time_;
+  if (delta < GetTimeoutMilliseconds())
+    return;
+  
+  // TODO(hclam): Maybe raise an error here. But if an error is reported
+  // the whole pipeline may get destroyed...
+  if (read_attempts_ >= kReadTrials)
+    return;
+
+  ++read_attempts_;
+  read_submitted_time_ = base::Time::Now();
+
+  // Stops the current loader and swap in a new resource loader and
+  // retry the request.
+  loader_->Stop();
+  SwapLoaderTask(CreateLoader(read_position_, -1));
+}
+
 // This method is the place where actual read happens, |loader_| must be valid
 // prior to make this method call.
 void BufferedDataSource::ReadInternal() {
   DCHECK(MessageLoop::current() == render_loop_);
   DCHECK(loader_.get());
 
   // First we prepare the intermediate read buffer for BufferedResourceLoader
   // to write to.
   if (read_size_ > intermediate_read_buffer_size_) {
     intermediate_read_buffer_.reset(new uint8[read_size_]);
@@ skipping 158 matching lines @@
 
     // TODO(hclam): It may be bad to access host() here.
     host()->SetError(media::PIPELINE_ERROR_NETWORK);
 
     // Stops the laoder.
     loader_->Stop();
   }
 }
 
 }  // namespace webkit_glue