Move WebMediaPlayerImpl and its dependencies to media/blink.

media/blink/webmediaplayer_impl.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_WEBMEDIAPLAYER_IMPL_H_
-#define CONTENT_RENDERER_MEDIA_WEBMEDIAPLAYER_IMPL_H_
+#ifndef MEDIA_BLINK_WEBMEDIAPLAYER_IMPL_H_
+#define MEDIA_BLINK_WEBMEDIAPLAYER_IMPL_H_
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
+#include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/thread.h"
-#include "content/renderer/media/buffered_data_source_host_impl.h"
-#include "content/renderer/media/video_frame_compositor.h"
 #include "media/base/audio_renderer_sink.h"
+#include "media/base/media_export.h"
 // TODO(xhwang): Remove when we remove prefixed EME implementation.
 #include "media/base/media_keys.h"
 #include "media/base/pipeline.h"
 #include "media/base/text_track.h"
+#include "media/blink/buffered_data_source.h"
+#include "media/blink/buffered_data_source_host_impl.h"
+#include "media/blink/video_frame_compositor.h"
 #include "media/filters/skcanvas_video_renderer.h"
-#include "skia/ext/platform_canvas.h"
 #include "third_party/WebKit/public/platform/WebAudioSourceProvider.h"
 #include "third_party/WebKit/public/platform/WebContentDecryptionModuleResult.h"
 #include "third_party/WebKit/public/platform/WebGraphicsContext3D.h"
 #include "third_party/WebKit/public/platform/WebMediaPlayer.h"
 #include "third_party/WebKit/public/platform/WebMediaPlayerClient.h"
 #include "url/gurl.h"
 
 namespace blink {
 class WebLocalFrame;
 }
 
 namespace base {
 class SingleThreadTaskRunner;
 }
 
 namespace cc_blink {
 class WebLayerImpl;
 }
 
 namespace media {
 class AudioHardwareConfig;
 class ChunkDemuxer;
+class EncryptedMediaPlayerSupport;
 class GpuVideoAcceleratorFactories;
 class MediaLog;
-}
-
-
-namespace content {
-class BufferedDataSource;
-class EncryptedMediaPlayerSupport;
 class VideoFrameCompositor;
 class WebAudioSourceProviderImpl;
 class WebMediaPlayerDelegate;
 class WebMediaPlayerParams;
 class WebTextTrackImpl;
 
 // The canonical implementation of blink::WebMediaPlayer that's backed by
-// media::Pipeline. Handles normal resource loading, Media Source, and
+// Pipeline. Handles normal resource loading, Media Source, and
 // Encrypted Media.
-class WebMediaPlayerImpl
-    : public blink::WebMediaPlayer,
+class MEDIA_EXPORT WebMediaPlayerImpl
+    : public NON_EXPORTED_BASE(blink::WebMediaPlayer),
       public base::SupportsWeakPtr<WebMediaPlayerImpl> {
  public:
   // Constructs a WebMediaPlayer implementation using Chromium's media stack.
   // |delegate| may be null.
   WebMediaPlayerImpl(blink::WebLocalFrame* frame,
                      blink::WebMediaPlayerClient* client,
                      base::WeakPtr<WebMediaPlayerDelegate> delegate,
                      const WebMediaPlayerParams& params);
   virtual ~WebMediaPlayerImpl();
 
@@ skipping 84 matching lines @@
   // TODO(jrummell): Remove this method once Blink updated to use the other
   // two methods.
   virtual void setContentDecryptionModule(
       blink::WebContentDecryptionModule* cdm);
   virtual void setContentDecryptionModule(
       blink::WebContentDecryptionModule* cdm,
       blink::WebContentDecryptionModuleResult result);
   virtual void setContentDecryptionModuleSync(
       blink::WebContentDecryptionModule* cdm);
 
-  void OnPipelineSeeked(bool time_changed, media::PipelineStatus status);
+  void OnPipelineSeeked(bool time_changed, PipelineStatus status);
   void OnPipelineEnded();
-  void OnPipelineError(media::PipelineStatus error);
-  void OnPipelineMetadata(media::PipelineMetadata metadata);
-  void OnPipelineBufferingStateChanged(media::BufferingState buffering_state);
+  void OnPipelineError(PipelineStatus error);
+  void OnPipelineMetadata(PipelineMetadata metadata);
+  void OnPipelineBufferingStateChanged(BufferingState buffering_state);
   void OnDemuxerOpened();
-  void OnAddTextTrack(const media::TextTrackConfig& config,
-                      const media::AddTextTrackDoneCB& done_cb);
+  void OnAddTextTrack(const TextTrackConfig& config,
+                      const AddTextTrackDoneCB& done_cb);
 
  private:
   // Called after |defer_load_cb_| has decided to allow the load. If
   // |defer_load_cb_| is null this is called immediately.
   void DoLoad(LoadType load_type,
               const blink::WebURL& url,
               CORSMode cors_mode);
 
   // Called after asynchronous initialization of a data source completed.
   void DataSourceInitialized(bool success);
 
   // Called when the data source is downloading or paused.
   void NotifyDownloading(bool is_downloading);
 
-  // Creates a media::Renderer that will be used by the |pipeline_|.
-  scoped_ptr<media::Renderer> CreateRenderer();
+  // Creates a Renderer that will be used by the |pipeline_|.
+  scoped_ptr<Renderer> CreateRenderer();
 
   // Finishes starting the pipeline due to a call to load().
   void StartPipeline();
 
   // Helpers that set the network/ready state and notifies the client if
   // they've changed.
   void SetNetworkState(blink::WebMediaPlayer::NetworkState state);
   void SetReadyState(blink::WebMediaPlayer::ReadyState state);
 
   // Gets the duration value reported by the pipeline.
   double GetPipelineDuration() const;
 
   // Callbacks from |pipeline_| that are forwarded to |client_|.
   void OnDurationChanged();
   void OnNaturalSizeChanged(gfx::Size size);
   void OnOpacityChanged(bool opaque);
 
   // Called by VideoRendererImpl on its internal thread with the new frame to be
   // painted.
-  void FrameReady(const scoped_refptr<media::VideoFrame>& frame);
+  void FrameReady(const scoped_refptr<VideoFrame>& frame);
 
   // Returns the current video frame from |compositor_|. Blocks until the
   // compositor can return the frame.
-  scoped_refptr<media::VideoFrame> GetCurrentFrameFromCompositor();
+  scoped_refptr<VideoFrame> GetCurrentFrameFromCompositor();
 
   blink::WebLocalFrame* frame_;
 
   // TODO(hclam): get rid of these members and read from the pipeline directly.
   blink::WebMediaPlayer::NetworkState network_state_;
   blink::WebMediaPlayer::ReadyState ready_state_;
 
   // Preload state for when |data_source_| is created after setPreload().
   BufferedDataSource::Preload preload_;
 
   // Task runner for posting tasks on Chrome's main thread. Also used
   // for DCHECKs so methods calls won't execute in the wrong thread.
   const scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
 
   scoped_refptr<base::SingleThreadTaskRunner> media_task_runner_;
-  scoped_refptr<media::MediaLog> media_log_;
-  media::Pipeline pipeline_;
+  scoped_refptr<MediaLog> media_log_;
+  Pipeline pipeline_;
 
   // The LoadType passed in the |load_type| parameter of the load() call.
   LoadType load_type_;
 
   // Cache of metadata for answering hasAudio(), hasVideo(), and naturalSize().
-  media::PipelineMetadata pipeline_metadata_;
+  PipelineMetadata pipeline_metadata_;
 
   // Whether the video is known to be opaque or not.
   bool opaque_;
 
   // Playback state.
   //
   // TODO(scherkus): we have these because Pipeline favours the simplicity of a
   // single "playback rate" over worrying about paused/stopped etc...  It forces
   // all clients to manage the pause+playback rate externally, but is that
   // really a bad thing?
@@ skipping 21 matching lines @@
   // changes.
   bool should_notify_time_changed_;
 
   blink::WebMediaPlayerClient* client_;
 
   base::WeakPtr<WebMediaPlayerDelegate> delegate_;
 
   base::Callback<void(const base::Closure&)> defer_load_cb_;
 
   // Factories for supporting video accelerators. May be null.
-  scoped_refptr<media::GpuVideoAcceleratorFactories> gpu_factories_;
+  scoped_refptr<GpuVideoAcceleratorFactories> gpu_factories_;
 
   // Routes audio playback to either AudioRendererSink or WebAudio.
   scoped_refptr<WebAudioSourceProviderImpl> audio_source_provider_;
 
   bool supports_save_;
 
   // These two are mutually exclusive:
   //   |data_source_| is used for regular resource loads.
   //   |chunk_demuxer_| is used for Media Source resource loads.
   //
   // |demuxer_| will contain the appropriate demuxer based on which resource
   // load strategy we're using.
   scoped_ptr<BufferedDataSource> data_source_;
-  scoped_ptr<media::Demuxer> demuxer_;
-  media::ChunkDemuxer* chunk_demuxer_;
+  scoped_ptr<Demuxer> demuxer_;
+  ChunkDemuxer* chunk_demuxer_;
 
   BufferedDataSourceHostImpl buffered_data_source_host_;
 
   // Video rendering members.
   scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner_;
   VideoFrameCompositor* compositor_;  // Deleted on |compositor_task_runner_|.
-  media::SkCanvasVideoRenderer skcanvas_video_renderer_;
+  SkCanvasVideoRenderer skcanvas_video_renderer_;
 
   // The compositor layer for displaying the video content when using composited
   // playback.
   scoped_ptr<cc_blink::WebLayerImpl> video_weblayer_;
 
   // Text track objects get a unique index value when they're created.
   int text_track_index_;
 
   scoped_ptr<EncryptedMediaPlayerSupport> encrypted_media_support_;
 
   const media::AudioHardwareConfig& audio_hardware_config_;

[scherkus (not reviewing), 2014/09/04 23:00:36]

remove media::

[acolwell GONE FROM CHROMIUM, 2014/09/05 00:23:44]

Done.

 
   DISALLOW_COPY_AND_ASSIGN(WebMediaPlayerImpl);
 };
 
-}  // namespace content
+}  // namespace media
 
-#endif  // CONTENT_RENDERER_MEDIA_WEBMEDIAPLAYER_IMPL_H_
+#endif  // MEDIA_BLINK_WEBMEDIAPLAYER_IMPL_H_