Move WebMediaPlayerImpl and its dependencies to media/blink.

media/blink/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_
+#ifndef MEDIA_BLINK_BUFFERED_DATA_SOURCE_H_
+#define MEDIA_BLINK_BUFFERED_DATA_SOURCE_H_
 
 #include <string>
 
 #include "base/callback.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/synchronization/lock.h"
-#include "content/common/content_export.h"
-#include "content/renderer/media/buffered_resource_loader.h"
 #include "media/base/data_source.h"
+#include "media/base/media_export.h"
 #include "media/base/ranges.h"
+#include "media/blink/buffered_resource_loader.h"
 #include "url/gurl.h"
 
 namespace base {
 class SingleThreadTaskRunner;
 }
 
 namespace media {
 class MediaLog;
-}
 
-namespace content {
-
-class CONTENT_EXPORT BufferedDataSourceHost {
+class MEDIA_EXPORT BufferedDataSourceHost {
  public:
   // Notify the host of the total size of the media file.
   virtual void SetTotalBytes(int64 total_bytes) = 0;
 
   // Notify the host that byte range [start,end] has been buffered.
   // TODO(fischman): remove this method when demuxing is push-based instead of
   // pull-based.  http://crbug.com/131444
   virtual void AddBufferedByteRange(int64 start, int64 end) = 0;
 
  protected:
   virtual ~BufferedDataSourceHost() {};
 };
 
 // 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 {
+class MEDIA_EXPORT BufferedDataSource : public DataSource {
  public:
   // 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,
   };
   typedef base::Callback<void(bool)> DownloadingCB;
 
   // |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::SingleThreadTaskRunner>& task_runner,
       blink::WebFrame* frame,
-      media::MediaLog* media_log,
+      MediaLog* media_log,
       BufferedDataSourceHost* host,
       const DownloadingCB& downloading_cb);
   virtual ~BufferedDataSource();
 
   // 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 InitializeCB& init_cb);
 
@@ skipping 18 matching lines @@
 
   // 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.
+  // DataSource implementation.
   // Called from demuxer thread.
   virtual void Stop() OVERRIDE;
 
   virtual void Read(int64 position, int size, uint8* data,
-                    const media::DataSource::ReadCB& read_cb) OVERRIDE;
+                    const 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
   // parameters. We can override this file to object a mock
   // BufferedResourceLoader for testing.
   virtual BufferedResourceLoader* CreateResourceLoader(
       int64 first_byte_position, int64 last_byte_position);
@@ skipping 91 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_;
 
-  scoped_refptr<media::MediaLog> media_log_;
+  scoped_refptr<MediaLog> media_log_;
 
   // Host object to report buffered byte range changes to.
   BufferedDataSourceHost* 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
+}  // namespace media
 
-#endif  // CONTENT_RENDERER_MEDIA_BUFFERED_DATA_SOURCE_H_
+#endif  // MEDIA_BLINK_BUFFERED_DATA_SOURCE_H_