Delete now deprecated BufferedDataSource and friends.

media/blink/multibuffer_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 MEDIA_BLINK_MULTIBUFFER_DATA_SOURCE_H_
 #define MEDIA_BLINK_MULTIBUFFER_DATA_SOURCE_H_
 
 #include <stdint.h>
 
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/synchronization/lock.h"
 #include "media/base/data_source.h"
 #include "media/base/ranges.h"
-#include "media/blink/buffered_data_source.h"
 #include "media/blink/media_blink_export.h"
 #include "media/blink/url_index.h"
 #include "url/gurl.h"
 
 namespace base {
 class SingleThreadTaskRunner;
 }
 
 namespace media {
+class BufferedDataSourceHost;
 class MediaLog;
 class MultiBufferReader;
 
 // A data source capable of loading URLs and buffering the data using an
 // in-memory sliding window.
 //
 // MultibufferDataSource must be created and destroyed on the thread associated
 // with the |task_runner| passed in the constructor.
-class MEDIA_BLINK_EXPORT MultibufferDataSource
-    : NON_EXPORTED_BASE(public BufferedDataSourceInterface) {
+class MEDIA_BLINK_EXPORT MultibufferDataSource : public DataSource {
  public:
   typedef base::Callback<void(bool)> DownloadingCB;
 
+  // Used to specify video preload states. They are "hints" to the browser about
+  // how aggressively the browser should load and buffer data.
+  // Please see the HTML5 spec for the descriptions of these values:
+  // http://www.w3.org/TR/html5/video.html#attr-media-preload
+  //
+  // Enum values must match the values in blink::WebMediaPlayer::Preload and
+  // there will be assertions at compile time if they do not match.
+  enum Preload {
+    NONE,
+    METADATA,
+    AUTO,
+  };
+
+  // Enum values must match the values in
+  // blink::WebMediaPlayer::BufferingStrategy and there will be assertions at
+  // compile time if they do not match.
+  enum BufferingStrategy {
+    BUFFERING_STRATEGY_NORMAL,
+    BUFFERING_STRATEGY_AGGRESSIVE,
+  };
+
   // |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.
   MultibufferDataSource(
       const GURL& url,
       UrlData::CORSMode cors_mode,
       const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
       linked_ptr<UrlIndex> url_index,
       blink::WebFrame* frame,
       MediaLog* media_log,
       BufferedDataSourceHost* host,
       const DownloadingCB& downloading_cb);
   ~MultibufferDataSource() override;
 
   // Executes |init_cb| with the result of initialization when it has completed.
   //
   // Method called on the render thread.
-  void Initialize(const InitializeCB& init_cb) override;
+  typedef base::Callback<void(bool)> InitializeCB;
+  void Initialize(const InitializeCB& init_cb);
 
   // Adjusts the buffering algorithm based on the given preload value.
-  void SetPreload(Preload preload) override;
+  void SetPreload(Preload preload);
 
   // Adjusts the buffering algorithm based on the given buffering strategy
   // value.
-  void SetBufferingStrategy(BufferingStrategy buffering_strategy) override;
+  void SetBufferingStrategy(BufferingStrategy buffering_strategy);
 
   // 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() override;
+  bool HasSingleOrigin();
 
   // Returns true if the media resource passed a CORS access control check.
-  bool DidPassCORSAccessCheck() const override;
+  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() override;
+  void Abort();
 
   // Notifies changes in playback state for controlling media buffering
   // behavior.
-  void MediaPlaybackRateChanged(double playback_rate) override;
-  void MediaIsPlaying() override;
-  bool media_has_played() const override;
+  void MediaPlaybackRateChanged(double playback_rate);
+  void MediaIsPlaying();
+  bool media_has_played() const;
 
   // Returns true if the resource is local.
-  bool assume_fully_buffered() override;
+  bool assume_fully_buffered();
 
   // Cancels any open network connections once reaching the deferred state. If
   // |always_cancel| is false this is done only for preload=metadata, non-
   // streaming resources that have not started playback. If |always_cancel| is
   // true, all resource types will have their connections canceled. If already
   // deferred, connections will be immediately closed.
-  void OnBufferingHaveEnough(bool always_cancel) override;
+  void OnBufferingHaveEnough(bool always_cancel);
 
-  int64_t GetMemoryUsage() const override;
+  int64_t GetMemoryUsage() const;
 
-  GURL GetUrlAfterRedirects() const override;
+  GURL GetUrlAfterRedirects() const;
 
   // DataSource implementation.
   // Called from demuxer thread.
   void Stop() override;
 
   void Read(int64_t position,
             int size,
             uint8_t* data,
             const DataSource::ReadCB& read_cb) override;
   bool GetSize(int64_t* size_out) override;
@@ skipping 129 matching lines @@
   // reaching into this class from multiple threads to attain a WeakPtr.
   base::WeakPtr<MultibufferDataSource> weak_ptr_;
   base::WeakPtrFactory<MultibufferDataSource> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(MultibufferDataSource);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BLINK_MULTIBUFFER_DATA_SOURCE_H_