Fix various MediaSource related crashes on Android.

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"
@@ skipping 70 matching lines @@
         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));
   }
 }
 
-MediaSourceDelegate::~MediaSourceDelegate() {}
+MediaSourceDelegate::~MediaSourceDelegate() {
+  DVLOG(1) << "MediaSourceDelegate::~MediaSourceDelegate() : " << player_id_;
+  DCHECK(!chunk_demuxer_);
+}
+
+void MediaSourceDelegate::Destroy() {
+  DVLOG(1) << "MediaSourceDelegate::Destroy() : " << player_id_;
+  if (!chunk_demuxer_) {
+    delete this;
+    return;
+  }
+
+  update_network_state_cb_.Reset();
+  media_source_.reset();
+  client_ = NULL;
+  proxy_ = NULL;
+
+  chunk_demuxer_->Stop(
+      BIND_TO_RENDER_LOOP(&MediaSourceDelegate::OnDemuxerStopDone));
+}
 
 void MediaSourceDelegate::Initialize(
     WebKit::WebMediaSource* media_source,
     const UpdateNetworkStateCB& update_network_state_cb) {
   DCHECK(media_source);
   media_source_.reset(media_source);
   update_network_state_cb_ = update_network_state_cb;
 
   chunk_demuxer_.reset(new media::ChunkDemuxer(
       BIND_TO_RENDER_LOOP(&MediaSourceDelegate::OnDemuxerOpened),
@@ skipping 90 matching lines @@
     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;
 }
 
 void MediaSourceDelegate::Seek(base::TimeDelta time) {
+  DVLOG(1) << "MediaSourceDelegate::Seek(" << time.InSecondsF() << ") : "
+           << player_id_;
   seeking_ = true;
   DCHECK(chunk_demuxer_);
   if (!chunk_demuxer_)
     return;
   chunk_demuxer_->StartWaitingForSeek();
   chunk_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) {
+  DVLOG(1) << "MediaSourceDelegate::OnReadFromDemuxer(" << type
+           << ", " << seek_done << ") : " << player_id_;
   if (seeking_ && !seek_done)
       return;  // Drop the request during seeking.
   seeking_ = false;
 
   DCHECK(type == DemuxerStream::AUDIO || type == DemuxerStream::VIDEO);
   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);
   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));
 }
 
 void MediaSourceDelegate::OnBufferReady(
     DemuxerStream* stream,
     MediaPlayerHostMsg_ReadFromDemuxerAck_Params* params,
     size_t index,
     DemuxerStream::Status status,
     const scoped_refptr<media::DecoderBuffer>& buffer) {
+  DVLOG(1) << "MediaSourceDelegate::OnBufferReady() : " << player_id_;
   DCHECK(status == DemuxerStream::kAborted ||
          index < params->access_units.size());
   bool is_audio = stream->type() == DemuxerStream::AUDIO;
   if (status != DemuxerStream::kAborted &&
       index >= params->access_units.size()) {
     LOG(ERROR) << "The internal state inconsistency onBufferReady: "
                << (is_audio ? "Audio" : "Video") << ", index " << index
                <<", size " << params->access_units.size()
                << ", status " << static_cast<int>(status);
     return;
@@ skipping 67 matching lines @@
       NOTREACHED();
   }
 
   if (proxy_)
     proxy_->ReadFromDemuxerAck(player_id_, *params);
   params->access_units.resize(0);
 }
 
 void MediaSourceDelegate::OnDemuxerError(
     media::PipelineStatus status) {
+  DVLOG(1) << "MediaSourceDelegate::OnDemuxerError(" << status << ") : "
+           << player_id_;
   if (status != media::PIPELINE_OK) {
     DCHECK(status == media::DEMUXER_ERROR_COULD_NOT_OPEN ||
            status == media::DEMUXER_ERROR_COULD_NOT_PARSE ||
            status == media::DEMUXER_ERROR_NO_SUPPORTED_STREAMS)
         << "Unexpected error from demuxer: " << static_cast<int>(status);
     if (!update_network_state_cb_.is_null())
       update_network_state_cb_.Run(WebMediaPlayer::NetworkStateFormatError);
   }
 }
 
 void MediaSourceDelegate::OnDemuxerInitDone(
     media::PipelineStatus status) {
+  DVLOG(1) << "MediaSourceDelegate::OnDemuxerInitDone(" << status << ") : "
+           << player_id_;
   if (status != media::PIPELINE_OK) {
     OnDemuxerError(status);
     return;
   }
   NotifyDemuxerReady("");
 }
 
+void MediaSourceDelegate::OnDemuxerStopDone() {
+  DVLOG(1) << "MediaSourceDelegate::OnDemuxerStopDone() : " << player_id_;
+  chunk_demuxer_.reset();
+  delete this;
+}
+
 void MediaSourceDelegate::NotifyDemuxerReady(const std::string& key_system) {
   MediaPlayerHostMsg_DemuxerReady_Params params;
   DemuxerStream* audio_stream = chunk_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();
@@ skipping 18 matching lines @@
   params.duration_ms = duration_ms;
   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() {
+  if (!media_source_)
+    return;
+
   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) {
+  if (!client_)
+    return;
+
   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;
 
+  if (!client_)
+    return;
+
   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) {
+  if (!client_)
+    return;
+
   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_)
+  if (!client_ || !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) {}
 
 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