Remove Chrome for TV code.

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>
 
@@ skipping 40 matching lines @@
     const scoped_refptr<base::MessageLoopProxy>& media_loop,
     media::MediaLog* media_log)
     : main_loop_(base::MessageLoopProxy::current()),
       main_weak_factory_(this),
       main_weak_this_(main_weak_factory_.GetWeakPtr()),
       media_loop_(media_loop),
       media_weak_factory_(this),
       demuxer_client_(demuxer_client),
       demuxer_client_id_(demuxer_client_id),
       media_log_(media_log),
-      demuxer_(NULL),
       is_demuxer_ready_(false),
       audio_stream_(NULL),
       video_stream_(NULL),
       seeking_(false),
       doing_browser_seek_(false),
       browser_seek_time_(media::kNoTimestamp()),
       expecting_regular_seek_(false),
-#if defined(GOOGLE_TV)
-      key_added_(false),
-#endif
       access_unit_size_(0) {
   DCHECK(main_loop_->BelongsToCurrentThread());
 }
 
 MediaSourceDelegate::~MediaSourceDelegate() {
   DCHECK(main_loop_->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__ << " : " << demuxer_client_id_;
   DCHECK(!chunk_demuxer_);
-  DCHECK(!demuxer_);
   DCHECK(!demuxer_client_);
   DCHECK(!audio_decrypting_demuxer_stream_);
   DCHECK(!video_decrypting_demuxer_stream_);
   DCHECK(!audio_stream_);
   DCHECK(!video_stream_);
 }
 
 void MediaSourceDelegate::Destroy() {
   DCHECK(main_loop_->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__ << " : " << demuxer_client_id_;
 
-  if (!demuxer_) {
+  if (!chunk_demuxer_) {
     DCHECK(!demuxer_client_);
     delete this;
     return;
   }
 
   duration_change_cb_.Reset();
   update_network_state_cb_.Reset();
   media_source_opened_cb_.Reset();
 
   main_weak_factory_.InvalidateWeakPtrs();
   DCHECK(!main_weak_factory_.HasWeakPtrs());
 
-  if (chunk_demuxer_)
-    chunk_demuxer_->Shutdown();
+  chunk_demuxer_->Shutdown();
 
   // |this| will be transferred to the callback StopDemuxer() and
   // OnDemuxerStopDone(). They own |this| and OnDemuxerStopDone() will delete
   // it when called, hence using base::Unretained(this) is safe here.
   media_loop_->PostTask(FROM_HERE,
                         base::Bind(&MediaSourceDelegate::StopDemuxer,
                         base::Unretained(this)));
 }
 
 void MediaSourceDelegate::StopDemuxer() {
   DCHECK(media_loop_->BelongsToCurrentThread());
-  DCHECK(demuxer_);
+  DCHECK(chunk_demuxer_);
 
   demuxer_client_->RemoveDelegate(demuxer_client_id_);
   demuxer_client_ = NULL;
 
   audio_stream_ = NULL;
   video_stream_ = NULL;
   // TODO(xhwang): Figure out if we need to Reset the DDSs after Seeking or
   // before destroying them.
   audio_decrypting_demuxer_stream_.reset();
   video_decrypting_demuxer_stream_.reset();
 
   media_weak_factory_.InvalidateWeakPtrs();
   DCHECK(!media_weak_factory_.HasWeakPtrs());
 
   // The callback OnDemuxerStopDone() owns |this| and will delete it when
   // called. Hence using base::Unretained(this) is safe here.
-  demuxer_->Stop(base::Bind(&MediaSourceDelegate::OnDemuxerStopDone,
-                            base::Unretained(this)));
+  chunk_demuxer_->Stop(base::Bind(&MediaSourceDelegate::OnDemuxerStopDone,
+                                  base::Unretained(this)));
 }
 
 void MediaSourceDelegate::InitializeMediaSource(
     const MediaSourceOpenedCB& media_source_opened_cb,
     const media::Demuxer::NeedKeyCB& need_key_cb,
     const media::SetDecryptorReadyCB& set_decryptor_ready_cb,
     const UpdateNetworkStateCB& update_network_state_cb,
     const DurationChangeCB& duration_change_cb) {
   DCHECK(main_loop_->BelongsToCurrentThread());
   DCHECK(!media_source_opened_cb.is_null());
   media_source_opened_cb_ = media_source_opened_cb;
   need_key_cb_ = need_key_cb;
   set_decryptor_ready_cb_ = set_decryptor_ready_cb;
   update_network_state_cb_ = media::BindToCurrentLoop(update_network_state_cb);
   duration_change_cb_ = duration_change_cb;
   access_unit_size_ = kAccessUnitSizeForMediaSource;
 
   chunk_demuxer_.reset(new media::ChunkDemuxer(
       media::BindToCurrentLoop(base::Bind(
           &MediaSourceDelegate::OnDemuxerOpened, main_weak_this_)),
       media::BindToCurrentLoop(base::Bind(
           &MediaSourceDelegate::OnNeedKey, main_weak_this_)),
       base::Bind(&LogMediaSourceError, media_log_)));
-  demuxer_ = chunk_demuxer_.get();
 
   // |this| will be retained until StopDemuxer() is posted, so Unretained() is
   // safe here.
   media_loop_->PostTask(FROM_HERE,
                         base::Bind(&MediaSourceDelegate::InitializeDemuxer,
                         base::Unretained(this)));
 }
 
 void MediaSourceDelegate::InitializeDemuxer() {
   DCHECK(media_loop_->BelongsToCurrentThread());
   demuxer_client_->AddDelegate(demuxer_client_id_, this);
-  demuxer_->Initialize(this, base::Bind(&MediaSourceDelegate::OnDemuxerInitDone,
+  chunk_demuxer_->Initialize(this,
+                             base::Bind(&MediaSourceDelegate::OnDemuxerInitDone,
                                         media_weak_factory_.GetWeakPtr()),
-                       false);
+                             false);
 }
 
-#if defined(GOOGLE_TV)
-void MediaSourceDelegate::InitializeMediaStream(
-    media::Demuxer* demuxer,
-    const UpdateNetworkStateCB& update_network_state_cb) {
-  DCHECK(main_loop_->BelongsToCurrentThread());
-  DCHECK(demuxer);
-  demuxer_ = demuxer;
-  update_network_state_cb_ = media::BindToCurrentLoop(update_network_state_cb);
-  // When playing Media Stream, don't wait to accumulate multiple packets per
-  // IPC communication.
-  access_unit_size_ = 1;
-
-  // |this| will be retained until StopDemuxer() is posted, so Unretained() is
-  // safe here.
-  media_loop_->PostTask(FROM_HERE,
-                        base::Bind(&MediaSourceDelegate::InitializeDemuxer,
-                        base::Unretained(this)));
-}
-#endif
-
 const blink::WebTimeRanges& MediaSourceDelegate::Buffered() {
   buffered_web_time_ranges_ =
       ConvertToWebTimeRanges(buffered_time_ranges_);
   return buffered_web_time_ranges_;
 }
 
 size_t MediaSourceDelegate::DecodedFrameCount() const {
   return statistics_.video_frames_decoded;
 }
 
@@ skipping 99 matching lines @@
     chunk_demuxer_->CancelPendingSeek(internal_seek_time);
     chunk_demuxer_->StartWaitingForSeek(internal_seek_time);
   }
 
   SeekInternal(internal_seek_time);
 }
 
 void MediaSourceDelegate::SeekInternal(const base::TimeDelta& seek_time) {
   DCHECK(media_loop_->BelongsToCurrentThread());
   DCHECK(IsSeeking());
-  demuxer_->Seek(seek_time, base::Bind(
+  chunk_demuxer_->Seek(seek_time, base::Bind(
       &MediaSourceDelegate::OnDemuxerSeekDone,
       media_weak_factory_.GetWeakPtr()));
 }
 
 void MediaSourceDelegate::SetTotalBytes(int64 total_bytes) {
   NOTIMPLEMENTED();
 }
 
 void MediaSourceDelegate::AddBufferedByteRange(int64 start, int64 end) {
   NOTIMPLEMENTED();
@@ skipping 54 matching lines @@
     media::DemuxerStream::Type type,
     scoped_ptr<DemuxerData> data,
     size_t index,
     DemuxerStream::Status status,
     const scoped_refptr<media::DecoderBuffer>& buffer) {
   DCHECK(media_loop_->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__ << "(" << index << ", " << status << ", "
            << ((!buffer || buffer->end_of_stream()) ?
                -1 : buffer->timestamp().InMilliseconds())
            << ") : " << demuxer_client_id_;
-  DCHECK(demuxer_);
+  DCHECK(chunk_demuxer_);
 
   // No new OnReadFromDemuxer() will be called during seeking. So this callback
   // must be from previous OnReadFromDemuxer() call and should be ignored.
   if (IsSeeking()) {
     DVLOG(1) << __FUNCTION__ << ": Ignore previous read during seeking.";
     return;
   }
 
   bool is_audio = (type == DemuxerStream::AUDIO);
   if (status != DemuxerStream::kAborted &&
@@ skipping 42 matching lines @@
       if (is_audio) {
         statistics_.audio_bytes_decoded += buffer->data_size();
       } else {
         statistics_.video_bytes_decoded += buffer->data_size();
         statistics_.video_frames_decoded++;
       }
       data->access_units[index].timestamp = buffer->timestamp();
 
       data->access_units[index].data.assign(
           buffer->data(), buffer->data() + buffer->data_size());
-#if !defined(GOOGLE_TV)
       // Vorbis needs 4 extra bytes padding on Android. Check
       // NuMediaExtractor.cpp in Android source code.
       if (is_audio && media::kCodecVorbis ==
           audio_stream_->audio_decoder_config().codec()) {
         data->access_units[index].data.insert(
             data->access_units[index].data.end(), kVorbisPadding,
             kVorbisPadding + 4);
       }
-#endif
       if (buffer->decrypt_config()) {
         data->access_units[index].key_id = std::vector<char>(
             buffer->decrypt_config()->key_id().begin(),
             buffer->decrypt_config()->key_id().end());
         data->access_units[index].iv = std::vector<char>(
             buffer->decrypt_config()->iv().begin(),
             buffer->decrypt_config()->iv().end());
         data->access_units[index].subsamples =
             buffer->decrypt_config()->subsamples();
       }
@@ skipping 27 matching lines @@
 
 void MediaSourceDelegate::RemoveTextStream(
     media::DemuxerStream* /* text_stream */ ) {
   // TODO(matthewjheaney): remove text stream (http://crbug/322115).
   NOTIMPLEMENTED();
 }
 
 void MediaSourceDelegate::OnDemuxerInitDone(media::PipelineStatus status) {
   DCHECK(media_loop_->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__ << "(" << status << ") : " << demuxer_client_id_;
-  DCHECK(demuxer_);
+  DCHECK(chunk_demuxer_);
 
   if (status != media::PIPELINE_OK) {
     OnDemuxerError(status);
     return;
   }
 
-  audio_stream_ = demuxer_->GetStream(DemuxerStream::AUDIO);
-  video_stream_ = demuxer_->GetStream(DemuxerStream::VIDEO);
+  audio_stream_ = chunk_demuxer_->GetStream(DemuxerStream::AUDIO);
+  video_stream_ = chunk_demuxer_->GetStream(DemuxerStream::VIDEO);
 
   if (audio_stream_ && audio_stream_->audio_decoder_config().is_encrypted() &&
       !set_decryptor_ready_cb_.is_null()) {
     InitAudioDecryptingDemuxerStream();
     // InitVideoDecryptingDemuxerStream() will be called in
     // OnAudioDecryptingDemuxerStreamInitDone().
     return;
   }
 
   if (video_stream_ && video_stream_->video_decoder_config().is_encrypted() &&
@@ skipping 31 matching lines @@
   video_decrypting_demuxer_stream_->Initialize(
       video_stream_,
       base::Bind(&MediaSourceDelegate::OnVideoDecryptingDemuxerStreamInitDone,
                  media_weak_factory_.GetWeakPtr()));
 }
 
 void MediaSourceDelegate::OnAudioDecryptingDemuxerStreamInitDone(
     media::PipelineStatus status) {
   DCHECK(media_loop_->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__ << "(" << status << ") : " << demuxer_client_id_;
-  DCHECK(demuxer_);
+  DCHECK(chunk_demuxer_);
 
   if (status != media::PIPELINE_OK)
     audio_decrypting_demuxer_stream_.reset();
   else
     audio_stream_ = audio_decrypting_demuxer_stream_.get();
 
   if (video_stream_ && video_stream_->video_decoder_config().is_encrypted()) {
     InitVideoDecryptingDemuxerStream();
     return;
   }
 
   // Try to notify demuxer ready when audio DDS initialization finished and
   // video is not encrypted.
   is_demuxer_ready_ = true;
   if (CanNotifyDemuxerReady())
     NotifyDemuxerReady();
 }
 
 void MediaSourceDelegate::OnVideoDecryptingDemuxerStreamInitDone(
     media::PipelineStatus status) {
   DCHECK(media_loop_->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__ << "(" << status << ") : " << demuxer_client_id_;
-  DCHECK(demuxer_);
+  DCHECK(chunk_demuxer_);
 
   if (status != media::PIPELINE_OK)
     video_decrypting_demuxer_stream_.reset();
   else
     video_stream_ = video_decrypting_demuxer_stream_.get();
 
   // Try to notify demuxer ready when video DDS initialization finished.
   is_demuxer_ready_ = true;
   if (CanNotifyDemuxerReady())
     NotifyDemuxerReady();
@@ skipping 54 matching lines @@
   DVLOG(1) << __FUNCTION__ << " : " << demuxer_client_id_;
   main_loop_->PostTask(
       FROM_HERE,
       base::Bind(&MediaSourceDelegate::DeleteSelf, base::Unretained(this)));
 }
 
 void MediaSourceDelegate::DeleteSelf() {
   DCHECK(main_loop_->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__ << " : " << demuxer_client_id_;
   chunk_demuxer_.reset();
-  demuxer_ = NULL;
   delete this;
 }
 
 void MediaSourceDelegate::OnMediaConfigRequest() {
   DCHECK(media_loop_->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__ << " : " << demuxer_client_id_;
   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 (!media_loop_->BelongsToCurrentThread()) {
-    media_loop_->PostTask(FROM_HERE,
-        base::Bind(&MediaSourceDelegate::NotifyKeyAdded,
-                   base::Unretained(this), key_system));
-    return;
-  }
-  DVLOG(1) << __FUNCTION__ << " : " << demuxer_client_id_;
-  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(media_loop_->BelongsToCurrentThread());
-  // 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;
+  return is_demuxer_ready_;
 }
 
 void MediaSourceDelegate::NotifyDemuxerReady() {
   DCHECK(media_loop_->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__ << " : " << demuxer_client_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();
 
-#if defined(GOOGLE_TV)
-  configs->key_system = HasEncryptedStream() ? key_system_ : "";
-#endif
-
   if (demuxer_client_)
     demuxer_client_->DemuxerReady(demuxer_client_id_, *configs);
 }
 
 int MediaSourceDelegate::GetDurationMs() {
   DCHECK(media_loop_->BelongsToCurrentThread());
   if (!chunk_demuxer_)
     return -1;
 
   double duration_ms = chunk_demuxer_->GetDuration() * 1000;
@@ skipping 71 matching lines @@
   // current time have been garbage collected or removed by the web app, this is
   // unlikely. This may cause unexpected playback stall due to seek pending an
   // append for a GOP prior to the last GOP demuxed.
   // TODO(wolenetz): Remove the possibility for this seek to cause unexpected
   // player stall by replaying cached data since last keyframe in browser player
   // rather than issuing browser seek. See http://crbug.com/304234.
   return seek_time;
 }
 
 }  // namespace content