Move EME code out of WebMediaPlayerImpl.

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.
 
 #ifndef CONTENT_RENDERER_MEDIA_WEBMEDIAPLAYER_IMPL_H_
 #define CONTENT_RENDERER_MEDIA_WEBMEDIAPLAYER_IMPL_H_
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.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/crypto/proxy_decryptor.h"
 #include "content/renderer/media/video_frame_compositor.h"
 #include "media/base/audio_renderer_sink.h"
-#include "media/base/decryptor.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/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"
 
-class RenderAudioSourceProvider;
-
 namespace blink {
-class WebContentDecryptionModule;
-class WebContentDecryptionModuleResult;
 class WebLocalFrame;
 }
 
 namespace base {
 class MessageLoopProxy;
 }
 
 namespace cc_blink {
 class WebLayerImpl;
 }
 
 namespace media {
 class ChunkDemuxer;
 class GpuVideoAcceleratorFactories;
 class MediaLog;
 }
 
 
 namespace content {
 class BufferedDataSource;
+class EncryptedMediaPlayerSupport;
 class VideoFrameCompositor;
 class WebAudioSourceProviderImpl;
-class WebContentDecryptionModuleImpl;
 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
 // Encrypted Media.
 class WebMediaPlayerImpl
     : public blink::WebMediaPlayer,
       public base::SupportsWeakPtr<WebMediaPlayerImpl> {
@@ skipping 99 matching lines @@
       blink::WebContentDecryptionModuleResult result);
   virtual void setContentDecryptionModuleSync(
       blink::WebContentDecryptionModule* cdm);
 
   void OnPipelineSeeked(bool time_changed, media::PipelineStatus status);
   void OnPipelineEnded();
   void OnPipelineError(media::PipelineStatus error);
   void OnPipelineMetadata(media::PipelineMetadata metadata);
   void OnPipelineBufferingStateChanged(media::BufferingState buffering_state);
   void OnDemuxerOpened();
-  void OnKeyAdded(const std::string& session_id);
-  void OnKeyError(const std::string& session_id,
-                  media::MediaKeys::KeyError error_code,
-                  uint32 system_code);
-  void OnKeyMessage(const std::string& session_id,
-                    const std::vector<uint8>& message,
-                    const GURL& destination_url);
-  void OnNeedKey(const std::string& type,
-                 const std::vector<uint8>& init_data);
   void OnAddTextTrack(const media::TextTrackConfig& config,
                       const media::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);
 
@@ skipping 10 matching lines @@
   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);
 
   // Lets V8 know that player uses extra resources not managed by V8.
   void IncrementExternallyAllocatedMemory();
 
-  // Actually do the work for generateKeyRequest/addKey so they can easily
-  // report results to UMA.
-  MediaKeyException GenerateKeyRequestInternal(const std::string& key_system,
-                                               const unsigned char* init_data,
-                                               unsigned init_data_length);
-  MediaKeyException AddKeyInternal(const std::string& key_system,
-                                   const unsigned char* key,
-                                   unsigned key_length,
-                                   const unsigned char* init_data,
-                                   unsigned init_data_length,
-                                   const std::string& session_id);
-  MediaKeyException CancelKeyRequestInternal(const std::string& key_system,
-                                             const std::string& session_id);
-
   // 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);
 
-  // Requests that this object notifies when a decryptor is ready through the
-  // |decryptor_ready_cb| provided.
-  // If |decryptor_ready_cb| is null, the existing callback will be fired with
-  // NULL immediately and reset.
-  void SetDecryptorReadyCB(const media::DecryptorReadyCB& decryptor_ready_cb);
-
   // Called when the ContentDecryptionModule has been attached to the
   // pipeline/decoders.
   void ContentDecryptionModuleAttached(
       blink::WebContentDecryptionModuleResult result,
       bool success);
 
   // Returns the current video frame from |compositor_|. Blocks until the
   // compositor can return the frame.
   scoped_refptr<media::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().
   content::Preload preload_;
 
   // Message loops 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::MessageLoopProxy> main_loop_;
 
   scoped_refptr<base::MessageLoopProxy> media_loop_;
   scoped_refptr<media::MediaLog> media_log_;
   media::Pipeline pipeline_;
 
-  // The currently selected key system. Empty string means that no key system
-  // has been selected.
-  std::string current_key_system_;
-
   // 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_;
 
   // Whether the video is known to be opaque or not.
   bool opaque_;
 
   // Playback state.
@@ skipping 43 matching lines @@
   //   |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_;
 
   BufferedDataSourceHostImpl buffered_data_source_host_;
 
-  // Temporary for EME v0.1. In the future the init data type should be passed
-  // through GenerateKeyRequest() directly from WebKit.
-  std::string init_data_type_;
-
   // Video rendering members.
   scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner_;
   VideoFrameCompositor* compositor_;  // Deleted on |compositor_task_runner_|.
   media::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_;
 
-  // Manages decryption keys and decrypts encrypted frames.
-  scoped_ptr<ProxyDecryptor> proxy_decryptor_;
-
-  // Non-owned pointer to the CDM. Updated via calls to
-  // setContentDecryptionModule().
-  WebContentDecryptionModuleImpl* web_cdm_;
-
-  media::DecryptorReadyCB decryptor_ready_cb_;
+  scoped_ptr<EncryptedMediaPlayerSupport> encrypted_media_support_;
 
   DISALLOW_COPY_AND_ASSIGN(WebMediaPlayerImpl);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_MEDIA_WEBMEDIAPLAYER_IMPL_H_