Migrate webkit/renderer/media/ to content/renderer/media/.

content/renderer/media/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.
 
 // Delegate calls from WebCore::MediaPlayerPrivate to Chrome's video player.
 // It contains Pipeline which is the actual media player pipeline, it glues
 // the media player pipeline, data source, audio renderer and renderer.
 // Pipeline would creates multiple threads and access some public methods
 // of this class, so we need to be extra careful about concurrent access of
 // methods and members.
 //
 // Other issues:
 // During tear down of the whole browser or a tab, the DOM tree may not be
 // destructed nicely, and there will be some dangling media threads trying to
 // the main thread, so we need this class to listen to destruction event of the
 // main thread and cleanup the media threads when the even is received. Also
 // at destruction of this class we will need to unhook it from destruction event
 // list of the main thread.
 
-#ifndef WEBKIT_RENDERER_MEDIA_WEBMEDIAPLAYER_IMPL_H_
-#define WEBKIT_RENDERER_MEDIA_WEBMEDIAPLAYER_IMPL_H_
+#ifndef CONTENT_RENDERER_MEDIA_WEBMEDIAPLAYER_IMPL_H_
+#define CONTENT_RENDERER_MEDIA_WEBMEDIAPLAYER_IMPL_H_
 
 #include <string>
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/thread.h"
 #include "cc/layers/video_frame_provider.h"
+#include "content/common/content_export.h"
 #include "googleurl/src/gurl.h"
 #include "media/base/audio_renderer_sink.h"
 #include "media/base/decryptor.h"
 #include "media/base/media_keys.h"
 #include "media/base/pipeline.h"
 #include "media/base/text_track.h"
 #include "media/filters/gpu_video_decoder.h"
 #include "media/filters/skcanvas_video_renderer.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/WebKit/public/platform/WebGraphicsContext3D.h"
@@ skipping 15 matching lines @@
 namespace media {
 class ChunkDemuxer;
 class FFmpegDemuxer;
 class MediaLog;
 }
 
 namespace webkit {
 class WebLayerImpl;
 }
 
-namespace webkit_media {
-
+namespace content {
 class BufferedDataSource;
+class MediaPlayerLoadDelegate;
 class MediaStreamClient;
 class WebAudioSourceProviderImpl;
+class WebTextTrackImpl;
+}
+
+namespace content {
 class WebMediaPlayerDelegate;
 class WebMediaPlayerParams;
-class WebTextTrackImpl;
 
-class WebMediaPlayerImpl
+class CONTENT_EXPORT WebMediaPlayerImpl
     : public WebKit::WebMediaPlayer,
       public cc::VideoFrameProvider,
       public base::MessageLoop::DestructionObserver,
       public base::SupportsWeakPtr<WebMediaPlayerImpl> {
  public:
   // Constructs a WebMediaPlayer implementation using Chromium's media stack.
   //
   // |delegate| may be null.
   WebMediaPlayerImpl(
       WebKit::WebFrame* frame,
@@ skipping 113 matching lines @@
   void OnNeedKey(const std::string& type,
                  const std::string& session_id,
                  scoped_ptr<uint8[]> init_data,
                  int init_data_size);
   scoped_ptr<media::TextTrack> OnTextTrack(media::TextKind kind,
                                            const std::string& label,
                                            const std::string& language);
   void SetOpaque(bool);
 
  private:
-  // Contains common logic used across the different types loading.
-  void LoadSetup(const WebKit::WebURL& url);
+  // Called after |load_delegate_| has decided to allow the load. If
+  // |load_delegate_| is NULL this is called immediately.
+  void ContinueLoad(const WebKit::WebURL& url,
+                    WebKit::WebMediaSource* media_source,
+                    CORSMode cors_mode);
 
   // Called after asynchronous initialization of a data source completed.
   void DataSourceInitialized(const GURL& gurl, bool success);
 
   // Called when the data source is downloading or paused.
   void NotifyDownloading(bool is_downloading);
 
   // Finishes starting the pipeline due to a call to load().
   //
   // A non-null |media_source| will construct a Media Source pipeline.
@@ skipping 76 matching lines @@
   double playback_rate_;
   base::TimeDelta paused_time_;
 
   // Seek gets pending if another seek is in progress. Only last pending seek
   // will have effect.
   bool pending_seek_;
   double pending_seek_seconds_;
 
   WebKit::WebMediaPlayerClient* client_;
 
+  MediaPlayerLoadDelegate* load_delegate_;
+
   base::WeakPtr<WebMediaPlayerDelegate> delegate_;
 
-  MediaStreamClient* media_stream_client_;
-
   scoped_refptr<media::MediaLog> media_log_;
 
   // Since accelerated compositing status is only known after the first layout,
   // we delay reporting it to UMA until that time.
   bool accelerated_compositing_reported_;
 
   bool incremented_externally_allocated_memory_;
 
   // Factories for supporting GpuVideoDecoder. May be null.
   scoped_refptr<media::GpuVideoDecoder::Factories> gpu_factories_;
 
   // Routes audio playback to either AudioRendererSink or WebAudio.
   scoped_refptr<WebAudioSourceProviderImpl> audio_source_provider_;
 
   bool is_local_source_;
   bool supports_save_;
 
   // The decryptor that manages decryption keys and decrypts encrypted frames.
-  scoped_ptr<ProxyDecryptor> decryptor_;
+  scoped_ptr<webkit_media::ProxyDecryptor> decryptor_;
 
   bool starting_;
 
   // 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_;
@@ skipping 22 matching lines @@
   // A pointer back to the compositor to inform it about state changes. This is
   // not NULL while the compositor is actively using this webmediaplayer.
   cc::VideoFrameProvider::Client* video_frame_provider_client_;
 
   // Text track objects get a unique index value when they're created.
   int text_track_index_;
 
   DISALLOW_COPY_AND_ASSIGN(WebMediaPlayerImpl);
 };
 
-}  // namespace webkit_media
+}  // namespace content
 
-#endif  // WEBKIT_RENDERER_MEDIA_WEBMEDIAPLAYER_IMPL_H_
+#endif  // CONTENT_RENDERER_MEDIA_WEBMEDIAPLAYER_IMPL_H_