Video Buffering: Caches data to disk when paused (resubmit)

webkit/glue/media/buffered_data_source.h

 // Copyright (c) 2010 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 <algorithm>
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #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"
 
 namespace webkit_glue {
-
 /////////////////////////////////////////////////////////////////////////////
 // BufferedResourceLoader
 // This class works inside demuxer thread and render thread. It contains a
 // resource loader bridge and does the actual resource loading. This object
 // does buffering internally, it defers the resource loading if buffer is
 // full and un-defers the resource loading if it is under buffered.
 class BufferedResourceLoader :
     public base::RefCountedThreadSafe<BufferedResourceLoader>,
     public webkit_glue::ResourceLoaderBridge::Peer {
  public:
@@ skipping 44 matching lines @@
                     uint8* buffer, net::CompletionCallback* callback);
 
   // Returns the position of the first byte buffered. Returns -1 if such value
   // is not available.
   virtual int64 GetBufferedFirstBytePosition();
 
   // Returns the position of the last byte buffered. Returns -1 if such value
   // is not available.
   virtual int64 GetBufferedLastBytePosition();
 
+  // Sets whether deferring data is allowed or disallowed.
+  virtual void SetAllowDefer(bool is_allowed);
+
   // Gets the content length in bytes of the instance after this loader has been
   // started. If this value is -1, then content length is unknown.
   virtual int64 content_length() { return content_length_; }
 
   // Gets the original size of the file requested. If this value is -1, then
   // the size is unknown.
   virtual int64 instance_size() { return instance_size_; }
 
   // Returns true if the response for this loader is a partial response.
   // It means a 206 response in HTTP/HTTPS protocol.
@@ skipping 21 matching lines @@
  protected:
   friend class base::RefCountedThreadSafe<BufferedResourceLoader>;
 
   // An empty constructor so mock classes can be constructed.
   BufferedResourceLoader() {
   }
 
   virtual ~BufferedResourceLoader();
 
  private:
+  friend class BufferedResourceLoaderTest;
 
   // Defer the resource loading if the buffer is full.
   void EnableDeferIfNeeded();
 
   // Disable defer loading if we are under-buffered.
   void DisableDeferIfNeeded();
 
   // Returns true if the current read request can be fulfilled by what is in
   // the buffer.
   bool CanFulfillRead();
@@ skipping 19 matching lines @@
   void NotifyNetworkEvent();
 
   bool HasPendingRead() { return read_callback_.get() != NULL; }
 
   // A sliding window of buffer.
   scoped_ptr<media::SeekableBuffer> buffer_;
 
   // True if resource loading was deferred.
   bool deferred_;
 
+  // True if resource loader is allowed to defer, false otherwise.
+  bool defer_allowed_;
+
   // True if resource loading has completed.
   bool completed_;
 
   // True if a range request was made.
   bool range_requested_;
 
   // True if response data received is a partial range.
   bool partial_response_;
 
   webkit_glue::MediaResourceLoaderBridgeFactory* bridge_factory_;
@@ skipping 41 matching lines @@
   }
 
   // media::FilterFactoryImpl2 implementation.
   static bool IsMediaFormatSupported(
       const media::MediaFormat& media_format);
 
   // media::MediaFilter implementation.
   virtual void Initialize(const std::string& url,
                           media::FilterCallback* callback);
   virtual void Stop(media::FilterCallback* callback);
+  virtual void SetPlaybackRate(float playback_rate);
 
   // media::DataSource implementation.
   // Called from demuxer thread.
   virtual void Read(int64 position, size_t size,
                     uint8* data,
                     media::DataSource::ReadCallback* read_callback);
   virtual bool GetSize(int64* size_out);
   virtual bool IsStreaming();
 
   const media::MediaFormat& media_format() {
@@ skipping 37 matching lines @@
   void CleanupTask();
 
   // Restart resource loading on render thread.
   void RestartLoadingTask();
 
   // 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 one to accommodate the read request.
   void WatchDogTask();
 
+  // This task uses the current playback rate with the previous playback rate
+  // to determine whether we are going from pause to play and play to pause,
+  // and signals the buffered resource loader accordingly.
+  void SetPlaybackRateTask(float playback_rate);
+
   // 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_Locked(int error);
 
   // Calls |initialize_callback_| and reset it.
   void DoneInitialization_Locked();
 
@@ skipping 79 matching lines @@
   Lock lock_;
 
   // Stop signal to suppressing activities. This variable is set on the pipeline
   // thread and read from the render thread.
   bool stop_signal_received_;
 
   // This variable is set by CleanupTask() that indicates this object is stopped
   // on the render thread.
   bool stopped_on_render_loop_;
 
+  // This variable is true when we are in a paused state and false when we
+  // are in a playing state.
+  bool media_is_paused_;
+
   // 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_