EME: Handle NO_KEY and resume playback after key is added.

content/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 "content/renderer/media/android/media_source_delegate.h"
 
+#include <limits>
+#include <string>
+#include <vector>
+
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/strings/string_number_conversions.h"
 #include "content/renderer/media/android/webmediaplayer_proxy_android.h"
 #include "content/renderer/media/webmediaplayer_util.h"
 #include "content/renderer/media/webmediasource_impl.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"
@@ skipping 59 matching lines @@
 #endif
       proxy_(proxy),
       player_id_(player_id),
       media_log_(media_log),
       demuxer_(NULL),
       is_demuxer_ready_(false),
       audio_stream_(NULL),
       video_stream_(NULL),
       seeking_(false),
       last_seek_request_id_(0),
+#if defined(GOOGLE_TV)
       key_added_(false),
+#endif
       access_unit_size_(0) {
 }
 
 MediaSourceDelegate::~MediaSourceDelegate() {
   DCHECK(main_loop_->BelongsToCurrentThread());
   DVLOG(1) << "~MediaSourceDelegate() : " << player_id_;
   DCHECK(!chunk_demuxer_);
   DCHECK(!demuxer_);
   DCHECK(!audio_decrypting_demuxer_stream_);
   DCHECK(!video_decrypting_demuxer_stream_);
@@ skipping 528 matching lines @@
     media_loop_->PostTask(FROM_HERE,
         base::Bind(&MediaSourceDelegate::OnMediaConfigRequest,
                    base::Unretained(this)));
     return;
   }
 #endif
   if (CanNotifyDemuxerReady())
     NotifyDemuxerReady();
 }
 
+#if defined(GOOGLE_TV)
+// TODO(kjyoun): Enhance logic to detect when to call NotifyDemuxerReady()
+// For now, we call it when the first key is added. See http://crbug.com/255781
 void MediaSourceDelegate::NotifyKeyAdded(const std::string& key_system) {
-#if defined(GOOGLE_TV)
   if (!media_loop_->BelongsToCurrentThread()) {
     media_loop_->PostTask(FROM_HERE,
         base::Bind(&MediaSourceDelegate::NotifyKeyAdded,
                    base::Unretained(this), key_system));
     return;
   }
-#endif
   DVLOG(1) << "NotifyKeyAdded() : " << player_id_;
-  // TODO(kjyoun): Enhance logic to detect when to call NotifyDemuxerReady()
-  // For now, we calls it when the first key is added. See
-  // http://crbug.com/255781
   if (key_added_)
     return;
   key_added_ = true;
   key_system_ = key_system;
   if (!CanNotifyDemuxerReady())
     return;
   if (HasEncryptedStream())
     NotifyDemuxerReady();
 }
+#endif  // defined(GOOGLE_TV)
 
 bool MediaSourceDelegate::CanNotifyDemuxerReady() {
   DCHECK_BELONG_TO_MEDIA_LOOP();
   // This can happen when a key is added before the demuxer is initialized.
   // See NotifyKeyAdded().
   // TODO(kjyoun): Remove NotifyDemxuerReady() call from NotifyKeyAdded() so
   // that we can remove all is_demuxer_ready_/key_added_/key_system_ madness.
   // See http://crbug.com/255781
   if (!is_demuxer_ready_)
     return false;
+#if defined(GOOGLE_TV)
   if (HasEncryptedStream() && !key_added_)
     return false;
+#endif  // defined(GOOGLE_TV)
   return true;
 }
 
 void MediaSourceDelegate::NotifyDemuxerReady() {
   DCHECK_BELONG_TO_MEDIA_LOOP();
   DVLOG(1) << "NotifyDemuxerReady() : " << player_id_;
   DCHECK(CanNotifyDemuxerReady());
 
   scoped_ptr<DemuxerConfigs> configs(new DemuxerConfigs());
   if (audio_stream_) {
     media::AudioDecoderConfig config = audio_stream_->audio_decoder_config();
     configs->audio_codec = config.codec();
     configs->audio_channels =
         media::ChannelLayoutToChannelCount(config.channel_layout());
     configs->audio_sampling_rate = config.samples_per_second();
     configs->is_audio_encrypted = config.is_encrypted();
     configs->audio_extra_data = std::vector<uint8>(
         config.extra_data(), config.extra_data() + config.extra_data_size());
   }
   if (video_stream_) {
     media::VideoDecoderConfig config = video_stream_->video_decoder_config();
     configs->video_codec = config.codec();
     configs->video_size = config.natural_size();
     configs->is_video_encrypted = config.is_encrypted();
     configs->video_extra_data = std::vector<uint8>(
         config.extra_data(), config.extra_data() + config.extra_data_size());
   }
   configs->duration_ms = GetDurationMs();
-  configs->key_system = HasEncryptedStream() ? key_system_ : "";
 
 #if defined(GOOGLE_TV)
+  configs->key_system = HasEncryptedStream() ? key_system_ : "";
   send_demuxer_ready_cb_.Run(configs.Pass());
 #else
   SendDemuxerReady(configs.Pass());
 #endif
 }
 
 void MediaSourceDelegate::SendDemuxerReady(scoped_ptr<DemuxerConfigs> configs) {
   DCHECK(main_loop_->BelongsToCurrentThread());
   if (proxy_)
     proxy_->DemuxerReady(player_id_, *configs);
@@ skipping 51 matching lines @@
   base::AutoLock auto_lock(seeking_lock_);
   seeking_ = seeking;
 }
 
 bool MediaSourceDelegate::IsSeeking() const {
   base::AutoLock auto_lock(seeking_lock_);
   return seeking_;
 }
 
 }  // namespace content