Separate DemuxerHost from DataSourceHost.

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 18 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;
 
-  // |downloading_cb| will be called whenever the downloading/paused state of
-  // the source changes.
+  // Buffered byte range changes will be reported to |host|. |downloading_cb|
+  // will be called whenever the downloading/paused state of the source changes.

[scherkus (not reviewing), 2014/03/28 20:54:09]

want to a TODO(sandersd) saying how |host| should be moved to content?

[sandersd (OOO until July 31), 2014/03/28 21:14:28]

Done.

   BufferedDataSource(const scoped_refptr<base::MessageLoopProxy>& render_loop,
                      blink::WebFrame* frame,
                      media::MediaLog* media_log,
+                     media::DataSourceHost* 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.
   //
   // Method called on the render thread.
   typedef base::Callback<void(bool)> InitializeCB;
   void Initialize(
       const GURL& url,
@@ skipping 20 matching lines @@
   void Abort();
 
   // Notifies changes in playback state for controlling media buffering
   // behavior.
   void MediaPlaybackRateChanged(float playback_rate);
   void MediaIsPlaying();
   void MediaIsPaused();
 
   // media::DataSource implementation.
   // Called from demuxer thread.
-  virtual void set_host(media::DataSourceHost* host) OVERRIDE;
   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;
 
  protected:
   // A factory method to create a BufferedResourceLoader based on the read
@@ skipping 27 matching lines @@
 
   // BufferedResourceLoader::Start() callback for subsequent loads (i.e.,
   // when accessing ranges that are outside initial buffered region).
   void PartialReadStartCallback(BufferedResourceLoader::Status status);
 
   // BufferedResourceLoader callbacks.
   void ReadCallback(BufferedResourceLoader::Status status, int bytes_read);
   void LoadingStateChangedCallback(BufferedResourceLoader::LoadingState state);
   void ProgressCallback(int64 position);
 
-  // Report a buffered byte range [start,end] or queue it for later
-  // reporting if set_host() hasn't been called yet.
-  void ReportOrQueueBufferedBytes(int64 start, int64 end);
-
-  void UpdateHostState_Locked();
-
   // Update |loader_|'s deferring strategy in response to a play/pause, or
   // change in playback rate.
   void UpdateDeferStrategy(bool paused);
 
   // 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
@@ skipping 52 matching lines @@
   // This variable holds the value of the preload attribute for the video
   // element.
   Preload preload_;
 
   // Bitrate of the content, 0 if unknown.
   int bitrate_;
 
   // Current playback rate.
   float playback_rate_;
 
-  // Buffered byte ranges awaiting set_host() being called to report to host().
-  media::Ranges<int64> queued_buffered_byte_ranges_;
+  scoped_refptr<media::MediaLog> media_log_;
 
-  scoped_refptr<media::MediaLog> media_log_;
+  // Host object to report buffered byte range changes to.
+  media::DataSourceHost* host_;
 
   DownloadingCB downloading_cb_;
 
   // 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_