Implement WebRTC in Chrome for TV

webkit/media/android/media_source_delegate.cc

Index: webkit/media/android/media_source_delegate.cc
diff --git a/webkit/media/android/media_source_delegate.cc b/webkit/media/android/media_source_delegate.cc
index dd87330b50d1396792f4f0283b190ec0f76f8fa4..096ec17e2a22005b1fad581eace925c5f99410e5 100644
--- a/webkit/media/android/media_source_delegate.cc
+++ b/webkit/media/android/media_source_delegate.cc
@@ -21,9 +21,11 @@
 #include "webkit/media/webmediaplayer_util.h"
 #include "webkit/media/webmediasourceclient_impl.h"
 
+using media::DemuxerHost;
 using media::DemuxerStream;
 using media::MediaPlayerHostMsg_DemuxerReady_Params;
 using media::MediaPlayerHostMsg_ReadFromDemuxerAck_Params;
+using media::PipelineStatusCB;
 using WebKit::WebMediaPlayer;
 using WebKit::WebString;
 
@@ -59,73 +61,197 @@ static void LogMediaSourceError(const scoped_refptr<media::MediaLog>& media_log,
   media_log->AddEvent(media_log->CreateMediaSourceErrorEvent(error));
 }
 
-MediaSourceDelegate::MediaSourceDelegate(
-    WebKit::WebFrame* frame,
-    WebKit::WebMediaPlayerClient* client,
-    WebMediaPlayerProxyAndroid* proxy,
-    int player_id,
-    media::MediaLog* media_log)
-    : weak_this_(this),
-      client_(client),
-      proxy_(proxy),
-      player_id_(player_id),
-      media_log_(media_log),
-      audio_params_(new MediaPlayerHostMsg_ReadFromDemuxerAck_Params),
-      video_params_(new MediaPlayerHostMsg_ReadFromDemuxerAck_Params),
-      seeking_(false) {
-  if (WebKit::WebRuntimeFeatures::isEncryptedMediaEnabled()) {
-    decryptor_.reset(new ProxyDecryptor(
-        client,
-        frame,
-        BIND_TO_RENDER_LOOP(&MediaSourceDelegate::OnKeyAdded),
-        BIND_TO_RENDER_LOOP(&MediaSourceDelegate::OnKeyError),
-        BIND_TO_RENDER_LOOP(&MediaSourceDelegate::OnKeyMessage),
-        BIND_TO_RENDER_LOOP(&MediaSourceDelegate::OnNeedKey)));
-    decryptor_->SetDecryptorReadyCB(
-        BIND_TO_RENDER_LOOP(&MediaSourceDelegate::OnDecryptorReady));
+// KeyHandlingDemuxer ----------------------------------------------------------
+
+class KeyHandlingDemuxer : public media::Demuxer {
+ public:
+  explicit KeyHandlingDemuxer(media::Demuxer* demuxer);
+  virtual ~KeyHandlingDemuxer();
+
+  virtual WebKit::WebMediaPlayer::MediaKeyException GenerateKeyRequest(
+      const WebKit::WebString& key_system,
+      const unsigned char* init_data,
+      unsigned init_data_length) {
+    return WebKit::WebMediaPlayer::MediaKeyExceptionKeySystemNotSupported;
   }
-}
+  virtual WebKit::WebMediaPlayer::MediaKeyException AddKey(
+      const WebKit::WebString& key_system,
+      const unsigned char* key,
+      unsigned key_length,
+      const unsigned char* init_data,
+      unsigned init_data_length,
+      const WebKit::WebString& session_id) {
+    return WebKit::WebMediaPlayer::MediaKeyExceptionKeySystemNotSupported;
+  }
+  virtual WebKit::WebMediaPlayer::MediaKeyException CancelKeyRequest(
+      const WebKit::WebString& key_system,
+      const WebKit::WebString& session_id) {
+    return WebKit::WebMediaPlayer::MediaKeyExceptionKeySystemNotSupported;
+  }
+  virtual int GetDurationMs() { return -1; }
 
-MediaSourceDelegate::~MediaSourceDelegate() {}
+  // media::Demuxer implementation
+  virtual void Initialize(DemuxerHost* host, const PipelineStatusCB& status_cb)
+      OVERRIDE;
+  virtual void SetPlaybackRate(float playback_rate) OVERRIDE;
+  virtual void Seek(base::TimeDelta time, const PipelineStatusCB& status_cb)
+      OVERRIDE;
+  virtual void Stop(const base::Closure& callback) OVERRIDE;
+  virtual void OnAudioRendererDisabled() OVERRIDE;
+  virtual DemuxerStream* GetStream(DemuxerStream::Type type) OVERRIDE;
+  virtual base::TimeDelta GetStartTime() const OVERRIDE;
 
-void MediaSourceDelegate::Initialize(
-    scoped_ptr<WebKit::WebMediaSource> media_source,
-    const UpdateNetworkStateCB& update_network_state_cb) {
-  DCHECK(media_source);
-  media_source_ = media_source.Pass();
-  update_network_state_cb_ = update_network_state_cb;
+  media::Demuxer* demuxer() { return demuxer_; }
 
-  chunk_demuxer_.reset(new media::ChunkDemuxer(
-      BIND_TO_RENDER_LOOP(&MediaSourceDelegate::OnDemuxerOpened),
-      BIND_TO_RENDER_LOOP_2(&MediaSourceDelegate::OnNeedKey, "", ""),
-      base::Bind(&LogMediaSourceError, media_log_)));
-  chunk_demuxer_->Initialize(this,
-      BIND_TO_RENDER_LOOP(&MediaSourceDelegate::OnDemuxerInitDone));
+ protected:
+  media::Demuxer* demuxer_;
+};
+
+KeyHandlingDemuxer::KeyHandlingDemuxer(media::Demuxer* demuxer)
+    : demuxer_(demuxer) {}
+
+KeyHandlingDemuxer::~KeyHandlingDemuxer() {}
+
+void KeyHandlingDemuxer::Initialize(DemuxerHost* host,
+                                    const PipelineStatusCB& status_cb) {
+  demuxer_->Initialize(host, status_cb);
 }
 
-const WebKit::WebTimeRanges& MediaSourceDelegate::Buffered() {
-  buffered_web_time_ranges_ =
-      ConvertToWebTimeRanges(buffered_time_ranges_);
-  return buffered_web_time_ranges_;
+void KeyHandlingDemuxer::SetPlaybackRate(float playback_rate) {
+  demuxer_->SetPlaybackRate(playback_rate);
 }
 
-size_t MediaSourceDelegate::DecodedFrameCount() const {
-  return statistics_.video_frames_decoded;
+void KeyHandlingDemuxer::Seek(base::TimeDelta time,
+                              const PipelineStatusCB& status_cb) {
+  demuxer_->Seek(time, status_cb);
 }
 
-size_t MediaSourceDelegate::DroppedFrameCount() const {
-  return statistics_.video_frames_dropped;
+void KeyHandlingDemuxer::Stop(const base::Closure& callback) {
+  demuxer_->Stop(callback);
 }
 
-size_t MediaSourceDelegate::AudioDecodedByteCount() const {
-  return statistics_.audio_bytes_decoded;
+void KeyHandlingDemuxer::OnAudioRendererDisabled() {
+  demuxer_->OnAudioRendererDisabled();
 }
 
-size_t MediaSourceDelegate::VideoDecodedByteCount() const {
-  return statistics_.video_bytes_decoded;
+DemuxerStream* KeyHandlingDemuxer::GetStream(
+    DemuxerStream::Type type) {
+  return demuxer_->GetStream(type);
 }
 
-WebMediaPlayer::MediaKeyException MediaSourceDelegate::GenerateKeyRequest(
+base::TimeDelta KeyHandlingDemuxer::GetStartTime() const {
+  return demuxer_->GetStartTime();
+}
+
+// KeyHandlingChunkDemuxer -----------------------------------------------------
+
+namespace {
+
+class KeyHandlingChunkDemuxer : public KeyHandlingDemuxer {
+ public:
+  typedef base::Callback<void(const std::string& key_system)> NotifyDemuxerCB;
+
+  KeyHandlingChunkDemuxer(WebKit::WebFrame* frame,
+                          WebKit::WebMediaPlayerClient* client,
+                          WebKit::WebMediaSource* media_source,
+                          scoped_refptr<media::MediaLog> media_log,
+                          NotifyDemuxerCB notify_demuxer_cb);
+  virtual ~KeyHandlingChunkDemuxer();
+
+  // KeyHandlingDemuxer
+  virtual WebKit::WebMediaPlayer::MediaKeyException GenerateKeyRequest(
+      const WebKit::WebString& key_system,
+      const unsigned char* init_data,
+      unsigned init_data_length) OVERRIDE;
+  virtual WebKit::WebMediaPlayer::MediaKeyException AddKey(
+      const WebKit::WebString& key_system,
+      const unsigned char* key,
+      unsigned key_length,
+      const unsigned char* init_data,
+      unsigned init_data_length,
+      const WebKit::WebString& session_id) OVERRIDE;
+  virtual WebKit::WebMediaPlayer::MediaKeyException CancelKeyRequest(
+      const WebKit::WebString& key_system,
+      const WebKit::WebString& session_id) OVERRIDE;
+  virtual int GetDurationMs() OVERRIDE;
+
+  // media::Demuxer
+  virtual void Seek(base::TimeDelta time, const PipelineStatusCB& status_cb)
+      OVERRIDE;
+
+ private:
+  // Callbacks for ChunkDemuxer & Decryptor.
+  void OnDemuxerOpened();
+  void OnKeyAdded(const std::string& key_system, const std::string& session_id);
+  void OnKeyError(const std::string& key_system,
+                  const std::string& session_id,
+                  media::Decryptor::KeyError error_code,
+                  int system_code);
+  void OnKeyMessage(const std::string& key_system,
+                    const std::string& session_id,
+                    const std::string& message,
+                    const std::string& default_url);
+  void OnNeedKey(const std::string& key_system,
+                 const std::string& type,
+                 const std::string& session_id,
+                 scoped_ptr<uint8[]> init_data,
+                 int init_data_size);
+  void OnDecryptorReady(media::Decryptor*);
+
+  base::WeakPtrFactory<KeyHandlingChunkDemuxer> weak_this_;
+  scoped_ptr<media::ChunkDemuxer> chunk_demuxer_;
+  WebKit::WebMediaPlayerClient* client_;
+  scoped_refptr<media::MediaLog> media_log_;
+
+  // The decryptor that manages decryption keys and decrypts encrypted frames.
+  scoped_ptr<ProxyDecryptor> decryptor_;
+
+  // The currently selected key system. Empty string means that no key system
+  // has been selected.
+  WebKit::WebString current_key_system_;
+
+  // 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_;
+
+  NotifyDemuxerCB notify_demuxer_cb_;
+
+  scoped_ptr<WebKit::WebMediaSource> media_source_;
+};
+
+KeyHandlingChunkDemuxer::KeyHandlingChunkDemuxer(
+    WebKit::WebFrame* frame,
+    WebKit::WebMediaPlayerClient* client,
+    WebKit::WebMediaSource* media_source,
+    scoped_refptr<media::MediaLog> media_log,
+    NotifyDemuxerCB notify_demuxer_cb)
+    : KeyHandlingDemuxer(NULL),
+      weak_this_(this),
+      client_(client),
+      media_log_(media_log),
+      notify_demuxer_cb_(notify_demuxer_cb) {
+  chunk_demuxer_.reset(new media::ChunkDemuxer(
+      BIND_TO_RENDER_LOOP(&KeyHandlingChunkDemuxer::OnDemuxerOpened),
+      BIND_TO_RENDER_LOOP_2(&KeyHandlingChunkDemuxer::OnNeedKey, "", ""),
+      base::Bind(&LogMediaSourceError, media_log)));
+  demuxer_ = chunk_demuxer_.get();
+  media_source_.reset(media_source);
+  if (WebKit::WebRuntimeFeatures::isEncryptedMediaEnabled()) {
+    decryptor_.reset(new ProxyDecryptor(
+        client,
+        frame,
+        BIND_TO_RENDER_LOOP(&KeyHandlingChunkDemuxer::OnKeyAdded),
+        BIND_TO_RENDER_LOOP(&KeyHandlingChunkDemuxer::OnKeyError),
+        BIND_TO_RENDER_LOOP(&KeyHandlingChunkDemuxer::OnKeyMessage),
+        BIND_TO_RENDER_LOOP(&KeyHandlingChunkDemuxer::OnNeedKey)));
+    decryptor_->SetDecryptorReadyCB(
+        BIND_TO_RENDER_LOOP(&KeyHandlingChunkDemuxer::OnDecryptorReady));
+  }
+}
+
+KeyHandlingChunkDemuxer::~KeyHandlingChunkDemuxer() {}
+
+WebMediaPlayer::MediaKeyException KeyHandlingChunkDemuxer::GenerateKeyRequest(
     const WebString& key_system,
     const unsigned char* init_data,
     size_t init_data_length) {
@@ -155,7 +281,7 @@ WebMediaPlayer::MediaKeyException MediaSourceDelegate::GenerateKeyRequest(
   return WebMediaPlayer::MediaKeyExceptionNoError;
 }
 
-WebMediaPlayer::MediaKeyException MediaSourceDelegate::AddKey(
+WebMediaPlayer::MediaKeyException KeyHandlingChunkDemuxer::AddKey(
     const WebString& key_system,
     const unsigned char* key,
     size_t key_length,
@@ -181,7 +307,7 @@ WebMediaPlayer::MediaKeyException MediaSourceDelegate::AddKey(
   return WebMediaPlayer::MediaKeyExceptionNoError;
 }
 
-WebMediaPlayer::MediaKeyException MediaSourceDelegate::CancelKeyRequest(
+WebMediaPlayer::MediaKeyException KeyHandlingChunkDemuxer::CancelKeyRequest(
     const WebString& key_system,
     const WebString& session_id) {
   if (!IsSupportedKeySystem(key_system))
@@ -194,13 +320,184 @@ WebMediaPlayer::MediaKeyException MediaSourceDelegate::CancelKeyRequest(
   return WebMediaPlayer::MediaKeyExceptionNoError;
 }
 
+int KeyHandlingChunkDemuxer::GetDurationMs() {
+  double duration_ms = chunk_demuxer_->GetDuration() * 1000;
+  if (duration_ms > std::numeric_limits<int>::max()) {
+    LOG(WARNING) << "Duration from ChunkDemuxer is too large; probably "
+                    "something have gone wrong.";
+    return std::numeric_limits<int>::max();
+  }
+  return duration_ms;
+}
+
+void KeyHandlingChunkDemuxer::Seek(base::TimeDelta time,
+                                   const PipelineStatusCB& status_cb) {
+  chunk_demuxer_->StartWaitingForSeek();
+  chunk_demuxer_->Seek(time, status_cb);
+}
+
+void KeyHandlingChunkDemuxer::OnKeyError(const std::string& key_system,
+                                         const std::string& session_id,
+                                         media::Decryptor::KeyError error_code,
+                                         int system_code) {
+  client_->keyError(
+      WebString::fromUTF8(key_system),
+      WebString::fromUTF8(session_id),
+      static_cast<WebKit::WebMediaPlayerClient::MediaKeyErrorCode>(error_code),
+      system_code);
+}
+
+void KeyHandlingChunkDemuxer::OnKeyMessage(const std::string& key_system,
+                                           const std::string& session_id,
+                                           const std::string& message,
+                                           const std::string& default_url) {
+  const GURL default_url_gurl(default_url);
+  DLOG_IF(WARNING, !default_url.empty() && !default_url_gurl.is_valid())
+      << "Invalid URL in default_url: " << default_url;
+
+  client_->keyMessage(WebString::fromUTF8(key_system),
+                      WebString::fromUTF8(session_id),
+                      reinterpret_cast<const uint8*>(message.data()),
+                      message.size(),
+                      default_url_gurl);
+}
+
+void KeyHandlingChunkDemuxer::OnKeyAdded(const std::string& key_system,
+                                         const std::string& session_id) {
+  notify_demuxer_cb_.Run(key_system);
+  client_->keyAdded(WebString::fromUTF8(key_system),
+                    WebString::fromUTF8(session_id));
+}
+
+void KeyHandlingChunkDemuxer::OnNeedKey(const std::string& key_system,
+                                        const std::string& session_id,
+                                        const std::string& type,
+                                        scoped_ptr<uint8[]> init_data,
+                                        int init_data_size) {
+  // Do not fire NeedKey event if encrypted media is not enabled.
+  if (!decryptor_)
+    return;
+
+  CHECK(init_data_size >= 0);
+  DCHECK(init_data_type_.empty() || type.empty() || type == init_data_type_);
+  if (init_data_type_.empty())
+    init_data_type_ = type;
+
+  client_->keyNeeded(WebString::fromUTF8(key_system),
+                     WebString::fromUTF8(session_id),
+                     init_data.get(),
+                     init_data_size);
+}
+
+void KeyHandlingChunkDemuxer::OnDecryptorReady(media::Decryptor* decryptor) {}
+
+void KeyHandlingChunkDemuxer::OnDemuxerOpened() {
+  media_source_->open(new WebMediaSourceClientImpl(
+      chunk_demuxer_.get(), base::Bind(&LogMediaSourceError, media_log_)));
+}
+
+}  // anonymous namespace
+
+// MediaSourceDelegate ---------------------------------------------------------
+
+MediaSourceDelegate::MediaSourceDelegate(
+    WebMediaPlayerProxyAndroid* proxy,
+    int player_id,
+    const UpdateNetworkStateCB& update_network_state_cb)
+    : weak_this_(this),
+      proxy_(proxy),
+      player_id_(player_id),
+      update_network_state_cb_(update_network_state_cb),
+      audio_params_(new MediaPlayerHostMsg_ReadFromDemuxerAck_Params),
+      video_params_(new MediaPlayerHostMsg_ReadFromDemuxerAck_Params),
+      seeking_(false),
+      is_media_stream_(false) {
+}
+
+MediaSourceDelegate::~MediaSourceDelegate() {
+  if (!destroy_demuxer_cb_.is_null())
+    destroy_demuxer_cb_.Run(demuxer_->demuxer());
+}
+
+void MediaSourceDelegate::InitializeMediaSource(
+    WebKit::WebFrame* frame,
+    WebKit::WebMediaPlayerClient* client,
+    WebKit::WebMediaSource* media_source,
+    media::MediaLog* media_log) {
+  DCHECK(media_source);
+  demuxer_.reset(new KeyHandlingChunkDemuxer(
+      frame,
+      client,
+      media_source,
+      scoped_refptr<media::MediaLog>(media_log),
+      BIND_TO_RENDER_LOOP(&MediaSourceDelegate::NotifyDemuxerReady)));
+  demuxer_->Initialize(this,
+      BIND_TO_RENDER_LOOP(&MediaSourceDelegate::OnDemuxerInitDone));
+}
+
+void MediaSourceDelegate::InitializeMediaStream(
+    media::Demuxer* demuxer,
+    const DestroyDemuxerCB& destroy_demuxer_cb) {
+  DCHECK(demuxer);
+  is_media_stream_ = true;
+  destroy_demuxer_cb_ = destroy_demuxer_cb;
+  demuxer_.reset(new KeyHandlingDemuxer(demuxer));
+  demuxer_->Initialize(this,
+      BIND_TO_RENDER_LOOP(&MediaSourceDelegate::OnDemuxerInitDone));
+}
+
+const WebKit::WebTimeRanges& MediaSourceDelegate::Buffered() {
+  buffered_web_time_ranges_ =
+      ConvertToWebTimeRanges(buffered_time_ranges_);
+  return buffered_web_time_ranges_;
+}
+
+unsigned MediaSourceDelegate::DecodedFrameCount() const {
+  return statistics_.video_frames_decoded;
+}
+
+unsigned MediaSourceDelegate::DroppedFrameCount() const {
+  return statistics_.video_frames_dropped;
+}
+
+unsigned MediaSourceDelegate::AudioDecodedByteCount() const {
+  return statistics_.audio_bytes_decoded;;
+}
+
+unsigned MediaSourceDelegate::VideoDecodedByteCount() const {
+  return statistics_.video_bytes_decoded;
+}
+
+WebMediaPlayer::MediaKeyException MediaSourceDelegate::GenerateKeyRequest(
+    const WebString& key_system,
+    const unsigned char* init_data,
+    unsigned init_data_length) {
+  return demuxer_->GenerateKeyRequest(key_system, init_data, init_data_length);
+}
+
+WebMediaPlayer::MediaKeyException MediaSourceDelegate::AddKey(
+    const WebString& key_system,
+    const unsigned char* key,
+    unsigned key_length,
+    const unsigned char* init_data,
+    unsigned init_data_length,
+    const WebString& session_id) {
+  return demuxer_->AddKey(
+      key_system, key, key_length, init_data, init_data_length, session_id);
+}
+
+WebMediaPlayer::MediaKeyException MediaSourceDelegate::CancelKeyRequest(
+    const WebString& key_system,
+    const WebString& session_id) {
+  return demuxer_->CancelKeyRequest(key_system, session_id);
+}
+
 void MediaSourceDelegate::Seek(base::TimeDelta time) {
   seeking_ = true;
-  DCHECK(chunk_demuxer_);
-  if (!chunk_demuxer_)
+  DCHECK(demuxer_);
+  if (!demuxer_)
     return;
-  chunk_demuxer_->StartWaitingForSeek();
-  chunk_demuxer_->Seek(time,
+  demuxer_->Seek(time,
       BIND_TO_RENDER_LOOP(&MediaSourceDelegate::OnDemuxerError));
 }
 
@@ -228,11 +525,16 @@ void MediaSourceDelegate::OnReadFromDemuxer(media::DemuxerStream::Type type,
   seeking_ = false;
 
   DCHECK(type == DemuxerStream::AUDIO || type == DemuxerStream::VIDEO);
+
+  // When playing Media Stream, don't wait to accumulate multiple packets per
+  // IPC communication.
+  size_t access_unit_size = is_media_stream_ ? 1 : kAccessUnitSize;
+
   MediaPlayerHostMsg_ReadFromDemuxerAck_Params* params =
       type == DemuxerStream::AUDIO ? audio_params_.get() : video_params_.get();
   params->type = type;
-  params->access_units.resize(kAccessUnitSize);
-  DemuxerStream* stream = chunk_demuxer_->GetStream(type);
+  params->access_units.resize(access_unit_size);
+  DemuxerStream* stream = demuxer_->GetStream(type);
   DCHECK(stream != NULL);
   ReadFromDemuxerStream(stream, params, 0);
 }
@@ -350,7 +652,7 @@ void MediaSourceDelegate::OnDemuxerInitDone(
 void MediaSourceDelegate::NotifyDemuxerReady(
     const std::string& key_system) {
   MediaPlayerHostMsg_DemuxerReady_Params params;
-  DemuxerStream* audio_stream = chunk_demuxer_->GetStream(DemuxerStream::AUDIO);
+  DemuxerStream* audio_stream = demuxer_->GetStream(DemuxerStream::AUDIO);
   if (audio_stream) {
     const media::AudioDecoderConfig& config =
         audio_stream->audio_decoder_config();
@@ -360,7 +662,7 @@ void MediaSourceDelegate::NotifyDemuxerReady(
     params.audio_sampling_rate = config.samples_per_second();
     params.is_audio_encrypted = config.is_encrypted();
   }
-  DemuxerStream* video_stream = chunk_demuxer_->GetStream(DemuxerStream::VIDEO);
+  DemuxerStream* video_stream = demuxer_->GetStream(DemuxerStream::VIDEO);
   if (video_stream) {
     const media::VideoDecoderConfig& config =
         video_stream->video_decoder_config();
@@ -368,11 +670,7 @@ void MediaSourceDelegate::NotifyDemuxerReady(
     params.video_size = config.natural_size();
     params.is_video_encrypted = config.is_encrypted();
   }
-  double duration_ms = chunk_demuxer_->GetDuration() * 1000;
-  DCHECK(duration_ms >= 0);
-  if (duration_ms > std::numeric_limits<int>::max())
-    duration_ms = std::numeric_limits<int>::max();
-  params.duration_ms = duration_ms;
+  params.duration_ms = demuxer_->GetDurationMs();
   params.key_system = key_system;
 
   bool ready_to_send = (!params.is_audio_encrypted &&
@@ -381,64 +679,4 @@ void MediaSourceDelegate::NotifyDemuxerReady(
     proxy_->DemuxerReady(player_id_, params);
 }
 
-void MediaSourceDelegate::OnDemuxerOpened() {
-  media_source_->open(new WebMediaSourceClientImpl(
-      chunk_demuxer_.get(), base::Bind(&LogMediaSourceError, media_log_)));
-}
-
-void MediaSourceDelegate::OnKeyError(const std::string& key_system,
-                                     const std::string& session_id,
-                                     media::Decryptor::KeyError error_code,
-                                     int system_code) {
-  client_->keyError(
-      WebString::fromUTF8(key_system),
-      WebString::fromUTF8(session_id),
-      static_cast<WebKit::WebMediaPlayerClient::MediaKeyErrorCode>(error_code),
-      system_code);
-}
-
-void MediaSourceDelegate::OnKeyMessage(const std::string& key_system,
-                                       const std::string& session_id,
-                                       const std::string& message,
-                                       const std::string& default_url) {
-  const GURL default_url_gurl(default_url);
-  DLOG_IF(WARNING, !default_url.empty() && !default_url_gurl.is_valid())
-      << "Invalid URL in default_url: " << default_url;
-
-  client_->keyMessage(WebString::fromUTF8(key_system),
-                      WebString::fromUTF8(session_id),
-                      reinterpret_cast<const uint8*>(message.data()),
-                      message.size(),
-                      default_url_gurl);
-}
-
-void MediaSourceDelegate::OnKeyAdded(const std::string& key_system,
-                                     const std::string& session_id) {
-  NotifyDemuxerReady(key_system);
-  client_->keyAdded(WebString::fromUTF8(key_system),
-                    WebString::fromUTF8(session_id));
-}
-
-void MediaSourceDelegate::OnNeedKey(const std::string& key_system,
-                                    const std::string& session_id,
-                                    const std::string& type,
-                                    scoped_ptr<uint8[]> init_data,
-                                    int init_data_size) {
-  // Do not fire NeedKey event if encrypted media is not enabled.
-  if (!decryptor_)
-    return;
-
-  CHECK(init_data_size >= 0);
-  DCHECK(init_data_type_.empty() || type.empty() || type == init_data_type_);
-  if (init_data_type_.empty())
-    init_data_type_ = type;
-
-  client_->keyNeeded(WebString::fromUTF8(key_system),
-                     WebString::fromUTF8(session_id),
-                     init_data.get(),
-                     init_data_size);
-}
-
-void MediaSourceDelegate::OnDecryptorReady(media::Decryptor* decryptor) {}
-
 }  // namespace webkit_media