Implement WebRTC in Chrome for TV

webkit/media/android/media_source_delegate.cc

 // Copyright (c) 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.
 
 #include "webkit/media/android/media_source_delegate.h"
 
 #include "base/message_loop_proxy.h"
 #include "base/strings/string_number_conversions.h"
 #include "media/base/android/demuxer_stream_player_params.h"
 #include "media/base/bind_to_loop.h"
 #include "media/base/demuxer_stream.h"
 #include "media/base/media_log.h"
 #include "media/filters/chunk_demuxer.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebString.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebMediaPlayerClient.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebMediaSource.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebRuntimeFeatures.h"
 #include "webkit/media/android/webmediaplayer_proxy_android.h"
 #include "webkit/media/crypto/key_systems.h"
 #include "webkit/media/crypto/proxy_decryptor.h"
 #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;
 
 namespace {
 
-// The size of the access unit to transfer in an IPC.
+// The size of the access unit to transfer in an IPC in case of MediaSource.
 // 16: approximately 250ms of content in 60 fps movies.
-const size_t kAccessUnitSize = 16;
+const size_t kAccessUnitSizeForMediaSource = 16;
 
 }  // namespace
 
 namespace webkit_media {
 
 #define BIND_TO_RENDER_LOOP(function) \
   media::BindToLoop(base::MessageLoopProxy::current(), \
                     base::Bind(function, weak_this_.GetWeakPtr()))
 
 #define BIND_TO_RENDER_LOOP_1(function, arg1) \
   media::BindToLoop(base::MessageLoopProxy::current(), \
                     base::Bind(function, weak_this_.GetWeakPtr(), arg1))
 
 #define BIND_TO_RENDER_LOOP_2(function, arg1, arg2) \
   media::BindToLoop(base::MessageLoopProxy::current(), \
                     base::Bind(function, weak_this_.GetWeakPtr(), arg1, arg2))
 
 #define BIND_TO_RENDER_LOOP_3(function, arg1, arg2, arg3) \
   media::BindToLoop(base::MessageLoopProxy::current(), \
                     base::Bind(function, \
                                weak_this_.GetWeakPtr(), arg1, arg2, arg3))
 
 static void LogMediaSourceError(const scoped_refptr<media::MediaLog>& media_log,
                                 const std::string& error) {
   media_log->AddEvent(media_log->CreateMediaSourceErrorEvent(error));
 }
 
-MediaSourceDelegate::MediaSourceDelegate(
+// KeyHandlingDemuxer ----------------------------------------------------------
+
+class KeyHandlingDemuxer : public media::Demuxer {
+ public:
+  typedef base::Callback<void(const std::string& key_system)> NotifyDemuxerCB;
+
+  KeyHandlingDemuxer();
+  virtual ~KeyHandlingDemuxer();
+
+  void InitializeDemuxer(media::Demuxer* demuxer);
+  void InitializeChunkDemuxer(WebKit::WebFrame* frame,
+                              WebKit::WebMediaPlayerClient* client,
+                              WebKit::WebMediaSource* media_source,
+                              scoped_refptr<media::MediaLog> media_log,
+                              const NotifyDemuxerCB& notify_demuxer_cb);
+  WebKit::WebMediaPlayer::MediaKeyException GenerateKeyRequest(
+      const WebKit::WebString& key_system,
+      const unsigned char* init_data,
+      unsigned init_data_length);
+  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);
+  WebKit::WebMediaPlayer::MediaKeyException CancelKeyRequest(
+      const WebKit::WebString& key_system,
+      const WebKit::WebString& session_id);
+  int GetDurationMs();
+  media::Demuxer* demuxer() { return demuxer_; }
+
+  // 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;
+
+ 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*);
+
+  media::Demuxer* demuxer_;
+
+  base::WeakPtrFactory<KeyHandlingDemuxer> 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_;
+};
+
+KeyHandlingDemuxer::KeyHandlingDemuxer()
+    : demuxer_(NULL), weak_this_(this), client_(NULL) {}
+
+KeyHandlingDemuxer::~KeyHandlingDemuxer() {}
+
+void KeyHandlingDemuxer::InitializeDemuxer(media::Demuxer* demuxer) {
+  DCHECK(!demuxer_);
+  demuxer_ = demuxer;
+}
+
+void KeyHandlingDemuxer::InitializeChunkDemuxer(
     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) {
+    WebKit::WebMediaSource* media_source,
+    scoped_refptr<media::MediaLog> media_log,
+    const NotifyDemuxerCB& notify_demuxer_cb) {
+  DCHECK(!demuxer_);
+  client_ = client;
+  media_log_ = media_log;
+  notify_demuxer_cb_ = notify_demuxer_cb;
+  chunk_demuxer_.reset(new media::ChunkDemuxer(
+      BIND_TO_RENDER_LOOP(&KeyHandlingDemuxer::OnDemuxerOpened),
+      BIND_TO_RENDER_LOOP_2(&KeyHandlingDemuxer::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(&MediaSourceDelegate::OnKeyAdded),
-        BIND_TO_RENDER_LOOP(&MediaSourceDelegate::OnKeyError),
-        BIND_TO_RENDER_LOOP(&MediaSourceDelegate::OnKeyMessage),
-        BIND_TO_RENDER_LOOP(&MediaSourceDelegate::OnNeedKey)));
+        BIND_TO_RENDER_LOOP(&KeyHandlingDemuxer::OnKeyAdded),
+        BIND_TO_RENDER_LOOP(&KeyHandlingDemuxer::OnKeyError),
+        BIND_TO_RENDER_LOOP(&KeyHandlingDemuxer::OnKeyMessage),
+        BIND_TO_RENDER_LOOP(&KeyHandlingDemuxer::OnNeedKey)));
     decryptor_->SetDecryptorReadyCB(
-        BIND_TO_RENDER_LOOP(&MediaSourceDelegate::OnDecryptorReady));
+        BIND_TO_RENDER_LOOP(&KeyHandlingDemuxer::OnDecryptorReady));
   }
 }
 
-MediaSourceDelegate::~MediaSourceDelegate() {}
-
-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;
-
-  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));
+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) {
+  if (!chunk_demuxer_)
+    chunk_demuxer_->StartWaitingForSeek();
+  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();
+}
+
+WebMediaPlayer::MediaKeyException KeyHandlingDemuxer::GenerateKeyRequest(
     const WebString& key_system,
     const unsigned char* init_data,
     size_t init_data_length) {
+  if (!decryptor_)
+    return WebKit::WebMediaPlayer::MediaKeyExceptionKeySystemNotSupported;
   if (!IsSupportedKeySystem(key_system))
     return WebMediaPlayer::MediaKeyExceptionKeySystemNotSupported;
 
   // We do not support run-time switching between key systems for now.
   if (current_key_system_.isEmpty())
     current_key_system_ = key_system;
   else if (key_system != current_key_system_)
     return WebMediaPlayer::MediaKeyExceptionInvalidPlayerState;
 
   DVLOG(1) << "generateKeyRequest: " << key_system.utf8().data() << ": "
            << std::string(reinterpret_cast<const char*>(init_data),
                           init_data_length);
 
   // TODO(xhwang): We assume all streams are from the same container (thus have
   // the same "type") for now. In the future, the "type" should be passed down
   // from the application.
   if (!decryptor_->GenerateKeyRequest(key_system.utf8(),
                                       init_data_type_,
                                       init_data, init_data_length)) {
     current_key_system_.reset();
     return WebMediaPlayer::MediaKeyExceptionKeySystemNotSupported;
   }
 
   return WebMediaPlayer::MediaKeyExceptionNoError;
 }
 
-WebMediaPlayer::MediaKeyException MediaSourceDelegate::AddKey(
+WebMediaPlayer::MediaKeyException KeyHandlingDemuxer::AddKey(
     const WebString& key_system,
     const unsigned char* key,
     size_t key_length,
     const unsigned char* init_data,
     size_t init_data_length,
     const WebString& session_id) {
+  if (!decryptor_)
+    return WebKit::WebMediaPlayer::MediaKeyExceptionKeySystemNotSupported;
   DCHECK(key);
   DCHECK_EQ(key_length, 16u);
 
   if (!IsSupportedKeySystem(key_system))
     return WebMediaPlayer::MediaKeyExceptionKeySystemNotSupported;
 
   if (current_key_system_.isEmpty() || key_system != current_key_system_)
     return WebMediaPlayer::MediaKeyExceptionInvalidPlayerState;
 
   DVLOG(1) << "addKey: " << key_system.utf8().data() << ": "
            << base::HexEncode(key, key_length) << ", "
            << base::HexEncode(init_data, std::max(init_data_length, 256u))
            << " [" << session_id.utf8().data() << "]";
 
   decryptor_->AddKey(key_system.utf8(), key, key_length,
                      init_data, init_data_length, session_id.utf8());
   return WebMediaPlayer::MediaKeyExceptionNoError;
 }
 
-WebMediaPlayer::MediaKeyException MediaSourceDelegate::CancelKeyRequest(
+WebMediaPlayer::MediaKeyException KeyHandlingDemuxer::CancelKeyRequest(
     const WebString& key_system,
     const WebString& session_id) {
+  if (!decryptor_)
+    return WebKit::WebMediaPlayer::MediaKeyExceptionKeySystemNotSupported;
   if (!IsSupportedKeySystem(key_system))
     return WebMediaPlayer::MediaKeyExceptionKeySystemNotSupported;
 
   if (current_key_system_.isEmpty() || key_system != current_key_system_)
     return WebMediaPlayer::MediaKeyExceptionInvalidPlayerState;
 
   decryptor_->CancelKeyRequest(key_system.utf8(), session_id.utf8());
   return WebMediaPlayer::MediaKeyExceptionNoError;
 }
 
+int KeyHandlingDemuxer::GetDurationMs() {
+  if (!chunk_demuxer_)
+    return -1;
+
+  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 KeyHandlingDemuxer::OnKeyError(const std::string& key_system,
+                                    const std::string& session_id,
+                                    media::Decryptor::KeyError error_code,
+                                    int system_code) {
+  if (!client_)
+    return;
+  client_->keyError(
+      WebString::fromUTF8(key_system),
+      WebString::fromUTF8(session_id),
+      static_cast<WebKit::WebMediaPlayerClient::MediaKeyErrorCode>(error_code),
+      system_code);
+}
+
+void KeyHandlingDemuxer::OnKeyMessage(const std::string& key_system,
+                                      const std::string& session_id,
+                                      const std::string& message,
+                                      const std::string& default_url) {
+  if (!client_)
+    return;
+  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 KeyHandlingDemuxer::OnKeyAdded(const std::string& key_system,
+                                    const std::string& session_id) {
+  if (!client_ || notify_demuxer_cb_.is_null())
+    return;
+  notify_demuxer_cb_.Run(key_system);
+  client_->keyAdded(WebString::fromUTF8(key_system),
+                    WebString::fromUTF8(session_id));
+}
+
+void KeyHandlingDemuxer::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 KeyHandlingDemuxer::OnDecryptorReady(media::Decryptor*) {}
+
+void KeyHandlingDemuxer::OnDemuxerOpened() {
+  DCHECK(media_source_);
+  media_source_->open(new WebMediaSourceClientImpl(
+      chunk_demuxer_.get(), base::Bind(&LogMediaSourceError, media_log_)));
+}
+
+// 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),
+      demuxer_(new KeyHandlingDemuxer),
+      audio_params_(new MediaPlayerHostMsg_ReadFromDemuxerAck_Params),
+      video_params_(new MediaPlayerHostMsg_ReadFromDemuxerAck_Params),
+      seeking_(false),
+      access_unit_size_(0) {
+}
+
+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_->InitializeChunkDemuxer(
+      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));
+  access_unit_size_ = kAccessUnitSizeForMediaSource;
+}
+
+void MediaSourceDelegate::InitializeMediaStream(media::Demuxer* demuxer) {
+  DCHECK(demuxer);
+  demuxer_->InitializeDemuxer(demuxer);
+  demuxer_->Initialize(this,
+      BIND_TO_RENDER_LOOP(&MediaSourceDelegate::OnDemuxerInitDone));
+  // When playing Media Stream, don't wait to accumulate multiple packets per
+  // IPC communication.
+  access_unit_size_ = 1;
+}
+
+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));
 }
 
 void MediaSourceDelegate::SetTotalBytes(int64 total_bytes) {
   NOTIMPLEMENTED();
 }
 
 void MediaSourceDelegate::AddBufferedByteRange(int64 start, int64 end) {
   NOTIMPLEMENTED();
 }
 
 void MediaSourceDelegate::AddBufferedTimeRange(base::TimeDelta start,
                                                base::TimeDelta end) {
   buffered_time_ranges_.Add(start, end);
 }
 
 void MediaSourceDelegate::SetDuration(base::TimeDelta duration) {
   // Do nothing
 }
 
 void MediaSourceDelegate::OnReadFromDemuxer(media::DemuxerStream::Type type,
                                             bool seek_done) {
   if (seeking_ && !seek_done)
       return;  // Drop the request during seeking.
   seeking_ = false;
 
   DCHECK(type == DemuxerStream::AUDIO || type == DemuxerStream::VIDEO);
+  // The access unit size should have been initialized properly at this stage.
+  DCHECK(access_unit_size_ > 0);
+
   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);
 }
 
 void MediaSourceDelegate::ReadFromDemuxerStream(
     DemuxerStream* stream,
     MediaPlayerHostMsg_ReadFromDemuxerAck_Params* params,
     size_t index) {
   stream->Read(BIND_TO_RENDER_LOOP_3(&MediaSourceDelegate::OnBufferReady,
                                      stream, params, index));
@@ skipping 97 matching lines @@
   if (status != media::PIPELINE_OK) {
     OnDemuxerError(status);
     return;
   }
   NotifyDemuxerReady("");
 }
 
 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();
     params.audio_codec = config.codec();
     params.audio_channels =
         media::ChannelLayoutToChannelCount(config.channel_layout());
     params.audio_sampling_rate = config.samples_per_second();
     params.is_audio_encrypted = config.is_encrypted();
     params.audio_extra_data = std::vector<uint8>(
         config.extra_data(), config.extra_data() + config.extra_data_size());
   }
-  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();
     params.video_codec = config.codec();
     params.video_size = config.natural_size();
     params.is_video_encrypted = config.is_encrypted();
     params.video_extra_data = std::vector<uint8>(
         config.extra_data(), config.extra_data() + config.extra_data_size());
   }
-  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 &&
                         !params.is_video_encrypted) || !key_system.empty();
   if (proxy_ && ready_to_send)
     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