Separate BufferedDataSource and BufferedResourceLoader into two files.

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 <string>
 
 #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/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 "third_party/WebKit/WebKit/chromium/public/WebFrame.h"
-#include "third_party/WebKit/WebKit/chromium/public/WebURLLoader.h"
-#include "third_party/WebKit/WebKit/chromium/public/WebURLLoaderClient.h"
-#include "third_party/WebKit/WebKit/chromium/public/WebURLRequest.h"
-#include "webkit/glue/media/web_data_source.h"
-#include "webkit/glue/webmediaplayer_impl.h"
-
-namespace WebKit {
-class WebURLResponse;
-}
+#include "webkit/glue/media/buffered_resource_loader.h"

[scherkus (not reviewing), 2010/12/14 18:48:19]

nit: I don't think you actually need the header (I think you can get away with
forward declare)

[annacc, 2010/12/14 21:10:17]

Yes, it seems like that should be true, but the compiler complains. :(  Could it
be because it's used as a scoped_refptr?

[scherkus (not reviewing), 2010/12/15 16:00:36]

should be fine but let's not worry about it for now

 
 namespace webkit_glue {
 
-/////////////////////////////////////////////////////////////////////////////
-// BufferedResourceLoader
-// This class works inside demuxer thread and render thread. It contains a
-// WebURLLoader 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::WebURLLoaderClient {
- public:
-  typedef Callback0::Type NetworkEventCallback;
-
-  // |url| - URL for the resource to be loaded.
-  // |first_byte_position| - First byte to start loading from, -1 for not
-  // specified.
-  // |last_byte_position| - Last byte to be loaded, -1 for not specified.
-  BufferedResourceLoader(const GURL& url,
-                         int64 first_byte_position,
-                         int64 last_byte_position);
-
-  // Start the resource loading with the specified URL and range.
-  // This method operates in asynchronous mode. Once there's a response from the
-  // server, success or fail |callback| is called with the result.
-  // |callback| is called with the following values:
-  // - net::OK
-  //   The request has started successfully.
-  // - net::ERR_FAILED
-  //   The request has failed because of an error with the network.
-  // - net::ERR_INVALID_RESPONSE
-  //   An invalid response is received from the server.
-  // - (Anything else)
-  //   An error code that indicates the request has failed.
-  // |event_callback| is called when the response is completed, data is
-  // received, the request is suspended or resumed.
-  virtual void Start(net::CompletionCallback* callback,
-                     NetworkEventCallback* event_callback,
-                     WebKit::WebFrame* frame);
-
-  // Stop this loader, cancels and request and release internal buffer.
-  virtual void Stop();
-
-  // Reads the specified |read_size| from |position| into |buffer| and when
-  // the operation is done invoke |callback| with number of bytes read or an
-  // error code.
-  // |callback| is called with the following values:
-  // - (Anything greater than or equal 0)
-  //   Read was successful with the indicated number of bytes read.
-  // - net::ERR_FAILED
-  //   The read has failed because of an error with the network.
-  // - net::ERR_CACHE_MISS
-  //   The read was made too far away from the current buffered position.
-  virtual void Read(int64 position, int read_size,
-                    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.
-  virtual bool partial_response() { return partial_response_; }
-
-  // Returns true if network is currently active.
-  virtual bool network_activity() { return !completed_ && !deferred_; }
-
-  // Returns resulting URL.
-  virtual const GURL& url() { return url_; }
-
-  // Used to inject a mock used for unittests.
-  virtual void SetURLLoaderForTest(WebKit::WebURLLoader* mock_loader);
-
-  /////////////////////////////////////////////////////////////////////////////
-  // WebKit::WebURLLoaderClient implementations.
-  virtual void willSendRequest(
-      WebKit::WebURLLoader* loader,
-      WebKit::WebURLRequest& newRequest,
-      const WebKit::WebURLResponse& redirectResponse);
-  virtual void didSendData(
-      WebKit::WebURLLoader* loader,
-      unsigned long long bytesSent,
-      unsigned long long totalBytesToBeSent);
-  virtual void didReceiveResponse(
-      WebKit::WebURLLoader* loader,
-      const WebKit::WebURLResponse& response);
-  virtual void didDownloadData(
-      WebKit::WebURLLoader* loader,
-      int dataLength);
-  virtual void didReceiveData(
-      WebKit::WebURLLoader* loader,
-      const char* data,
-      int dataLength);
-  virtual void didReceiveCachedMetadata(
-      WebKit::WebURLLoader* loader,
-      const char* data, int dataLength);
-  virtual void didFinishLoading(
-      WebKit::WebURLLoader* loader,
-      double finishTime);
-  virtual void didFail(
-      WebKit::WebURLLoader* loader,
-      const WebKit::WebURLError&);
-
- protected:
-  friend class base::RefCountedThreadSafe<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();
-
-  // Returns true if the current read request will be fulfilled in the future.
-  bool WillFulfillRead();
-
-  // Method that does the actual read and calls the |read_callbac_|, assuming
-  // the request range is in |buffer_|.
-  void ReadInternal();
-
-  // If we have made a range request, verify the response from the server.
-  bool VerifyPartialResponse(const WebKit::WebURLResponse& response);
-
-  // Returns the value for a range request header using parameters
-  // |first_byte_position| and |last_byte_position|. Negative numbers other
-  // than -1 are not allowed for |first_byte_position| and |last_byte_position|.
-  // |first_byte_position| should always be less than or equal to
-  // |last_byte_position| if they are both not -1.
-  // Empty string is returned on invalid parameters.
-  std::string GenerateHeaders(int64 first_byte_position,
-                              int64 last_byte_position);
-
-  // Done with read. Invokes the read callback and reset parameters for the
-  // read request.
-  void DoneRead(int error);
-
-  // Done with start. Invokes the start callback and reset it.
-  void DoneStart(int error);
-
-  // Calls |event_callback_| in terms of a network event.
-  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_;
-
-  // Does the work of loading and sends data back to this client.
-  scoped_ptr<WebKit::WebURLLoader> url_loader_;
-
-  GURL url_;
-  int64 first_byte_position_;
-  int64 last_byte_position_;
-
-  // Callback method that listens to network events.
-  scoped_ptr<NetworkEventCallback> event_callback_;
-
-  // Members used during request start.
-  scoped_ptr<net::CompletionCallback> start_callback_;
-  int64 offset_;
-  int64 content_length_;
-  int64 instance_size_;
-
-  // Members used during a read operation. They should be reset after each
-  // read has completed or failed.
-  scoped_ptr<net::CompletionCallback> read_callback_;
-  int64 read_position_;
-  int read_size_;
-  uint8* read_buffer_;
-
-  // Offsets of the requested first byte and last byte in |buffer_|. They are
-  // written by VerifyRead().
-  int first_offset_;
-  int last_offset_;
-
-  // Used to ensure mocks for unittests are used instead of reset in Start().
-  bool keep_test_loader_;
-
-  DISALLOW_COPY_AND_ASSIGN(BufferedResourceLoader);
-};
-
 class BufferedDataSource : public WebDataSource {
  public:
   BufferedDataSource(MessageLoop* render_loop,
                      WebKit::WebFrame* frame);
 
   virtual ~BufferedDataSource();
 
   // media::Filter implementation.
   virtual void Initialize(const std::string& url,
                           media::FilterCallback* callback);
@@ skipping 171 matching lines @@
   // Keeps track of whether we used a Range header in the initialization
   // request.
   bool using_range_request_;
 
   DISALLOW_COPY_AND_ASSIGN(BufferedDataSource);
 };
 
 }  // namespace webkit_glue
 
 #endif  // WEBKIT_GLUE_MEDIA_BUFFERED_DATA_SOURCE_H_