Call NotifyDemuxerReady() only once while keys are added.

webkit/renderer/media/android/media_source_delegate.cc

 // 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.
 
 #include "webkit/renderer/media/android/media_source_delegate.h"
 
 #include "base/message_loop/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"
@@ skipping 51 matching lines @@
                                          int player_id,
                                          media::MediaLog* media_log)
     : weak_this_(this),
       proxy_(proxy),
       player_id_(player_id),
       media_log_(media_log),
       demuxer_(NULL),
       audio_params_(new MediaPlayerHostMsg_ReadFromDemuxerAck_Params),
       video_params_(new MediaPlayerHostMsg_ReadFromDemuxerAck_Params),
       seeking_(false),
+      key_added_(false),
       access_unit_size_(0) {
 }
 
 MediaSourceDelegate::~MediaSourceDelegate() {
   DVLOG(1) << "MediaSourceDelegate::~MediaSourceDelegate() : " << player_id_;
   DCHECK(!chunk_demuxer_);
   DCHECK(!demuxer_);
 }
 
 void MediaSourceDelegate::Destroy() {
@@ skipping 242 matching lines @@
 }
 
 void MediaSourceDelegate::OnDemuxerInitDone(
     media::PipelineStatus status) {
   DVLOG(1) << "MediaSourceDelegate::OnDemuxerInitDone(" << status << ") : "
            << player_id_;
   if (status != media::PIPELINE_OK) {
     OnDemuxerError(status);
     return;
   }
-  NotifyDemuxerReady("");
+  if (CanNotifyDemuxerReady())
+    NotifyDemuxerReady("");
 }
 
 void MediaSourceDelegate::OnDemuxerStopDone() {
   DVLOG(1) << "MediaSourceDelegate::OnDemuxerStopDone() : " << player_id_;
   chunk_demuxer_.reset();
   delete this;
 }
 
 void MediaSourceDelegate::OnMediaConfigRequest() {
-  NotifyDemuxerReady("");
+  if (CanNotifyDemuxerReady())
+    NotifyDemuxerReady("");
+}
+
+void MediaSourceDelegate::NotifyKeyAdded(const std::string& key_system) {
+  // TODO(kjyoun): Enhance logic to detect when to call NotifyDemuxerReady()
+  // For now, we calls it when the first key is added.
+  if (key_added_)
+    return;
+  key_added_ = true;
+  if (CanNotifyDemuxerReady())
+    NotifyDemuxerReady(key_system);
+}
+
+bool MediaSourceDelegate::CanNotifyDemuxerReady() {
+  if (key_added_)
+    return true;
+  DemuxerStream* audio_stream = demuxer_->GetStream(DemuxerStream::AUDIO);
+  if (audio_stream && audio_stream->audio_decoder_config().is_encrypted())
+    return false;
+  DemuxerStream* video_stream = demuxer_->GetStream(DemuxerStream::VIDEO);
+  if (video_stream && video_stream->video_decoder_config().is_encrypted())
+    return false;
+  return true;
 }
 
 void MediaSourceDelegate::NotifyDemuxerReady(const std::string& key_system) {
-  if (!demuxer_)
-    return;
+  DCHECK(demuxer_);
   MediaPlayerHostMsg_DemuxerReady_Params params;
   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 = 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());
   }
   params.duration_ms = 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)
+  if (proxy_)
     proxy_->DemuxerReady(player_id_, params);
 }
 
 int MediaSourceDelegate::GetDurationMs() {
   if (!chunk_demuxer_)
     return -1;
 
   double duration_ms = chunk_demuxer_->GetDuration() * 1000;
   if (duration_ms > std::numeric_limits<int32>::max()) {
     LOG(WARNING) << "Duration from ChunkDemuxer is too large; probably "
@@ skipping 22 matching lines @@
 }
 
 scoped_ptr<media::TextTrack> MediaSourceDelegate::OnAddTextTrack(
     media::TextKind kind,
     const std::string& label,
     const std::string& language) {
   return scoped_ptr<media::TextTrack>();
 }
 
 }  // namespace webkit_media