Changing constructor of BufferedDataSource to accept GURL and CORSMode

content/renderer/media/buffered_data_source.h

 // Copyright 2013 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 CONTENT_RENDERER_MEDIA_BUFFERED_DATA_SOURCE_H_
 #define CONTENT_RENDERER_MEDIA_BUFFERED_DATA_SOURCE_H_
 
 #include <string>
 
 #include "base/callback.h"
@@ skipping 32 matching lines @@
 
 // A data source capable of loading URLs and buffering the data using an
 // in-memory sliding window.
 //
 // BufferedDataSource must be created and initialized on the render thread
 // before being passed to other threads. It may be deleted on any thread.
 class CONTENT_EXPORT BufferedDataSource : public media::DataSource {
  public:
   typedef base::Callback<void(bool)> DownloadingCB;
 
-  // Buffered byte range changes will be reported to |host|. |downloading_cb|
-  // will be called whenever the downloading/paused state of the source changes.
-  BufferedDataSource(const scoped_refptr<base::MessageLoopProxy>& render_loop,
+  // |url| and |cors_mode| are passed to the object. Buffered byte range changes
+  // will be reported to |host|. |downloading_cb| will be called whenever the
+  // downloading/paused state of the source changes.
+  BufferedDataSource(const GURL& url,
+                     BufferedResourceLoader::CORSMode cors_mode,
+                     const scoped_refptr<base::MessageLoopProxy>& render_loop,
                      blink::WebFrame* frame,
                      media::MediaLog* media_log,
                      BufferedDataSourceHost* host,
                      const DownloadingCB& downloading_cb);
   virtual ~BufferedDataSource();
 
-  // Initialize this object using |url| and |cors_mode|, executing |init_cb|
-  // with the result of initialization when it has completed.
+  // Executes |init_cb| with the result of initialization when it has completed.
   //
   // Method called on the render thread.
   typedef base::Callback<void(bool)> InitializeCB;
-  void Initialize(
-      const GURL& url,
-      BufferedResourceLoader::CORSMode cors_mode,
-      const InitializeCB& init_cb);
+  void Initialize(const InitializeCB& init_cb);
 
   // Adjusts the buffering algorithm based on the given preload value.
   void SetPreload(Preload preload);
 
   // Returns true if the media resource has a single origin, false otherwise.
   // Only valid to call after Initialize() has completed.
   //
   // Method called on the render thread.
   bool HasSingleOrigin();
 
   // Returns true if the media resource passed a CORS access control check.
   bool DidPassCORSAccessCheck() const;
 
   // Cancels initialization, any pending loaders, and any pending read calls
   // from the demuxer. The caller is expected to release its reference to this
   // object and never call it again.
   //
   // Method called on the render thread.
   void Abort();
 
   // Notifies changes in playback state for controlling media buffering
   // behavior.
   void MediaPlaybackRateChanged(float playback_rate);
   void MediaIsPlaying();
   void MediaIsPaused();
 
+  // Returns true if the resource is local.
+  bool assume_fully_buffered() { return !url_.SchemeIsHTTPOrHTTPS(); }
+
   // media::DataSource implementation.
   // Called from demuxer thread.
   virtual void Stop(const base::Closure& closure) OVERRIDE;
 
   virtual void Read(int64 position, int size, uint8* data,
                     const media::DataSource::ReadCB& read_cb) OVERRIDE;
   virtual bool GetSize(int64* size_out) OVERRIDE;
   virtual bool IsStreaming() OVERRIDE;
   virtual void SetBitrate(int bitrate) OVERRIDE;
 
@@ skipping 43 matching lines @@
   // URL of the resource requested.
   GURL url_;
   // crossorigin attribute on the corresponding HTML media element, if any.
   BufferedResourceLoader::CORSMode cors_mode_;
 
   // The total size of the resource. Set during StartCallback() if the size is
   // known, otherwise it will remain kPositionNotSpecified until the size is
   // determined by reaching EOF.
   int64 total_bytes_;
 
-  // Some resources are assumed to be fully buffered (i.e., file://) so we don't
-  // need to report what |loader_| has buffered.
-  bool assume_fully_buffered_;
-
   // 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.
   blink::WebFrame* frame_;
 
   // A resource loader for the media resource.
   scoped_ptr<BufferedResourceLoader> loader_;
 
@@ skipping 50 matching lines @@
 
   // NOTE: Weak pointers must be invalidated before all other member variables.
   base::WeakPtrFactory<BufferedDataSource> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(BufferedDataSource);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_MEDIA_BUFFERED_DATA_SOURCE_H_