Refactoring BufferedDataSource to work with WebURLLoader instead of a MediaResourceLoaderBridge.

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 "webkit/glue/media/media_resource_loader_bridge_factory.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;
+}
+
 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.
+// 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_glue::ResourceLoaderBridge::Peer {
+    public WebKit::WebURLLoaderClient {
  public:
   typedef Callback0::Type NetworkEventCallback;
 
-  // |bridge_factory| - Factory to create a ResourceLoaderBridge.
   // |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(
-      webkit_glue::MediaResourceLoaderBridgeFactory* bridge_factory,
-      const GURL& url,
-      int64 first_byte_position,
-      int64 last_byte_position);
+  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);
+                     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.
@@ skipping 26 matching lines @@
   // 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_glue::ResourceLoaderBridge::Peer implementations.
-  virtual void OnUploadProgress(uint64 position, uint64 size) {}
-  virtual bool OnReceivedRedirect(
-      const GURL& new_url,
-      const webkit_glue::ResourceResponseInfo& info,
-      bool* has_new_first_party_for_cookies,
-      GURL* new_first_party_for_cookies);
-  virtual void OnReceivedResponse(
-      const webkit_glue::ResourceResponseInfo& info,
-      bool content_filtered);
-  virtual void OnDownloadedData(int len) {}
-  virtual void OnReceivedData(const char* data, int len);
-  virtual void OnCompletedRequest(
-      const URLRequestStatus& status,
-      const std::string& security_info,
-      const base::Time& completion_time);
+  // 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 ResourceResponseInfo& info);
+  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();
@@ skipping 11 matching lines @@
 
   // 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_;
+  // 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_;
-  scoped_ptr<webkit_glue::ResourceLoaderBridge> bridge_;
   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_glue::MediaResourceLoaderBridgeFactory* bridge_factory);
+  BufferedDataSource(MessageLoop* render_loop,
+                     WebKit::WebFrame* frame);
 
   virtual ~BufferedDataSource();
 
   // media::MediaFilter implementation.
   virtual void Initialize(const std::string& url,
                           media::FilterCallback* callback);
   virtual bool IsUrlSupported(const std::string& url);
   virtual void Stop(media::FilterCallback* callback);
   virtual void SetPlaybackRate(float playback_rate);
 
@@ skipping 98 matching lines @@
   // need to protect it.
   int64 total_bytes_;
 
   // True if this data source is considered loaded.
   bool loaded_;
 
   // This value will be true if this data source can only support streaming.
   // i.e. range request is not supported.
   bool streaming_;
 
+  // A webframe for loading.
+  WebKit::WebFrame* frame_;
+
   // True if the media resource has a single origin.
   bool single_origin_;
 
-  // A factory object to produce ResourceLoaderBridge.
-  scoped_ptr<webkit_glue::MediaResourceLoaderBridgeFactory> bridge_factory_;
-
   // A resource loader for the media resource.
   scoped_refptr<BufferedResourceLoader> loader_;
 
   // True if network is active.
   bool network_activity_;
 
   // Callback method from the pipeline for initialization.
   scoped_ptr<media::FilterCallback> initialize_callback_;
 
   // Read parameters received from the Read() method call.
@@ skipping 44 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_