Retry requests that has timed out in BufferedDataSource

webkit/glue/media/buffered_data_source.h

 // 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.
 
 #ifndef WEBKIT_GLUE_MEDIA_BUFFERED_DATA_SOURCE_H_
 #define WEBKIT_GLUE_MEDIA_BUFFERED_DATA_SOURCE_H_
 
 #include <string>
 
 #include "base/lock.h"
 #include "base/scoped_ptr.h"
+#include "base/timer.h"
 #include "base/condition_variable.h"
 #include "googleurl/src/gurl.h"
 #include "media/base/factory.h"
 #include "media/base/filters.h"
 #include "media/base/media_format.h"
 #include "media/base/pipeline.h"
 #include "media/base/seekable_buffer.h"
 #include "net/base/completion_callback.h"
 #include "net/base/file_stream.h"
 #include "webkit/glue/media/media_resource_loader_bridge_factory.h"
@@ skipping 154 matching lines @@
       MessageLoop* render_loop,
       webkit_glue::MediaResourceLoaderBridgeFactory* bridge_factory);
   virtual ~BufferedDataSource();
 
   // A factory method to create a BufferedResourceLoader based on the read
   // parameters. We can override this file to object a mock
   // BufferedResourceLoader for testing.
   virtual BufferedResourceLoader* CreateLoader(int64 first_byte_position,
                                                int64 last_byte_position);
 
+  // Gets the number of milliseconds to declare a request timeout since
+  // the request was made. This method is made virtual so as to inject a
+  // different number for testing purpose.
+  virtual base::TimeDelta GetTimeoutMilliseconds();
+
  private:
   friend class media::FilterFactoryImpl2<
       BufferedDataSource,
       MessageLoop*,
       webkit_glue::MediaResourceLoaderBridgeFactory*>;
 
   // Posted to perform initialization on render thread.
   void InitializeTask();
 
   // Task posted to perform resource loading and actual reading on the render
   // thread.
   void ReadTask(int64 position, int read_size,
                 uint8* read_buffer,
                 media::DataSource::ReadCallback* read_callback);
 
   // Task posted when Stop() is called.
   void StopTask();
 
   // Reset |loader_| with |loader| and starts it. This task is posted from
   // callback method from the current buffered resource loader.
   void SwapLoaderTask(BufferedResourceLoader* loader);
 
+  // This task monitors the current active read request. If the current read
+  // request has timed out, this task will destroy the current loader and
+  // creates a new to accomodate the read request.
+  void WatchDogTask();
+
   // The method that performs actual read. This method can only be executed on
   // the render thread.
   void ReadInternal();
 
   // Calls |read_callback_| and reset all read parameters.
   void DoneRead(int error);
 
   // Calls |initialize_callback_| and reset it.
   void DoneInitialization();
 
@@ skipping 27 matching lines @@
   scoped_ptr<webkit_glue::MediaResourceLoaderBridgeFactory> bridge_factory_;
 
   // A downloader object for loading the media resource.
   scoped_ptr<BufferedResourceLoader> loader_;
 
   // Read parameters received from the Read() method call.
   scoped_ptr<media::DataSource::ReadCallback> read_callback_;
   int64 read_position_;
   int read_size_;
   uint8* read_buffer_;
+  base::Time read_submitted_time_;
+  int read_attempts_;
 
   // This buffer is intermediate, we use it for BufferedResourceLoader to write
   // to. And when read in BufferedResourceLoader is done, we copy data from
   // this buffer to |read_buffer_|. The reason for an additional copy is that
   // we don't own |read_buffer_|. But since the read operation is asynchronous,
   // |read_buffer| can be destroyed at any time, so we only copy into
   // |read_buffer| in the final step when it is safe.
   // Memory is allocated for this member during initialization of this object
   // because we want buffer to be passed into BufferedResourceLoader to be
   // always non-null. And by initializing this member with a default size we can
   // avoid creating zero-sized buffered if the first read has zero size.
   scoped_array<uint8> intermediate_read_buffer_;
   int intermediate_read_buffer_size_;
 
   // The message loop of the render thread.
   MessageLoop* render_loop_;
 
   // Filter callbacks.
   scoped_ptr<media::FilterCallback> initialize_callback_;
 
   // Protects |stopped_|.
   Lock lock_;
 
   // Stop signal to suppressing activities.
   bool stopped_;
 
+  // This timer is to run the WatchDogTask repeatedly. We use a timer instead
+  // of doing PostDelayedTask() reduce the extra reference held by the message
+  // loop. The RepeatingTimer does PostDelayedTask() internally, by using it
+  // the message loop doesn't hold a reference for the watch dog task.
+  base::RepeatingTimer<BufferedDataSource> watch_dog_timer_;
+
   DISALLOW_COPY_AND_ASSIGN(BufferedDataSource);
 };
 
 }  // namespace webkit_glue
 
 #endif  // WEBKIT_GLUE_MEDIA_BUFFERED_DATA_SOURCE_H_