Handle plugin instance crash in ContentDecryptorDelegate.

content/renderer/pepper/content_decryptor_delegate.cc

 // Copyright (c) 2012 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/pepper/content_decryptor_delegate.h"
 
 #include "base/callback_helpers.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/safe_numerics.h"
@@ skipping 237 matching lines @@
       plugin_decryption_interface_(plugin_decryption_interface),
       next_decryption_request_id_(1),
       pending_audio_decrypt_request_id_(0),
       pending_video_decrypt_request_id_(0),
       pending_audio_decoder_init_request_id_(0),
       pending_video_decoder_init_request_id_(0),
       pending_audio_decode_request_id_(0),
       pending_video_decode_request_id_(0),
       audio_samples_per_second_(0),
       audio_channel_count_(0),
-      weak_ptr_factory_(this) {
+      weak_ptr_factory_(this),
+      is_instance_crashed_(false) {
   weak_this_ = weak_ptr_factory_.GetWeakPtr();
 }
 
 ContentDecryptorDelegate::~ContentDecryptorDelegate() {
 }
 
 void ContentDecryptorDelegate::Initialize(const std::string& key_system) {
   DCHECK(!key_system.empty());
   DCHECK(key_system_.empty());
   key_system_ = key_system;
 
   plugin_decryption_interface_->Initialize(
       pp_instance_,
       StringVar::StringToPPVar(key_system_));
 }
 
 void ContentDecryptorDelegate::SetSessionEventCallbacks(
     const media::SessionCreatedCB& session_created_cb,
     const media::SessionMessageCB& session_message_cb,
     const media::SessionReadyCB& session_ready_cb,
     const media::SessionClosedCB& session_closed_cb,
     const media::SessionErrorCB& session_error_cb) {
   session_created_cb_ = session_created_cb;
   session_message_cb_ = session_message_cb;
   session_ready_cb_ = session_ready_cb;
   session_closed_cb_ = session_closed_cb;
   session_error_cb_ = session_error_cb;
 }
 
+void ContentDecryptorDelegate::InstanceCrashed() {
+  if (!pending_audio_decoder_init_cb_.is_null()) {
+    pending_audio_decoder_init_request_id_ = 0;
+    base::ResetAndReturn(&pending_audio_decoder_init_cb_).Run(false);
+  }
+
+  if (!pending_video_decoder_init_cb_.is_null()) {
+    pending_video_decoder_init_request_id_ = 0;
+    base::ResetAndReturn(&pending_video_decoder_init_cb_).Run(false);
+  }
+
+  if (!pending_audio_decrypt_cb_.is_null()) {
+    audio_input_resource_ = NULL;
+    pending_audio_decrypt_request_id_ = 0;
+    base::ResetAndReturn(&pending_audio_decrypt_cb_)
+        .Run(media::Decryptor::kError, NULL);
+  }
+
+  if (!pending_video_decrypt_cb_.is_null()) {
+    video_input_resource_ = NULL;
+    pending_video_decrypt_request_id_ = 0;
+    base::ResetAndReturn(&pending_video_decrypt_cb_)
+        .Run(media::Decryptor::kError, NULL);
+  }
+
+  if (!pending_audio_decode_cb_.is_null()) {
+    audio_input_resource_ = NULL;
+    pending_audio_decode_request_id_ = 0;
+    const media::Decryptor::AudioBuffers empty_frames;
+    base::ResetAndReturn(&pending_audio_decode_cb_)
+        .Run(media::Decryptor::kError, empty_frames);
+  }
+
+  if (!pending_video_decode_cb_.is_null()) {
+    video_input_resource_ = NULL;
+    pending_video_decode_request_id_ = 0;
+    base::ResetAndReturn(&pending_video_decode_cb_)
+        .Run(media::Decryptor::kError, NULL);
+  }
+
+  is_instance_crashed_ = true;
+}

[xhwang, 2013/12/28 01:00:28]

We have too many duplicate code about reqeust_id and callbacks. In another CL,
I'll clean them up a bit.

+
 bool ContentDecryptorDelegate::CreateSession(uint32 session_id,
                                              const std::string& type,
                                              const uint8* init_data,
                                              int init_data_length) {
+  if (is_instance_crashed_)
+    return false;
+
   PP_Var init_data_array =
       PpapiGlobals::Get()->GetVarTracker()->MakeArrayBufferPPVar(
           init_data_length, init_data);
 
   plugin_decryption_interface_->CreateSession(pp_instance_,
                                               session_id,
                                               StringVar::StringToPPVar(type),
                                               init_data_array);
   return true;
 }
 
 bool ContentDecryptorDelegate::UpdateSession(uint32 session_id,
                                              const uint8* response,
                                              int response_length) {
+  if (is_instance_crashed_)
+    return false;
+
   PP_Var response_array =
       PpapiGlobals::Get()->GetVarTracker()->MakeArrayBufferPPVar(
           response_length, response);
   plugin_decryption_interface_->UpdateSession(
       pp_instance_, session_id, response_array);
   return true;
 }
 
 bool ContentDecryptorDelegate::ReleaseSession(uint32 session_id) {
+  if (is_instance_crashed_)
+    return false;
+
   plugin_decryption_interface_->ReleaseSession(pp_instance_, session_id);
   return true;
 }
 
 // TODO(xhwang): Remove duplication of code in Decrypt(),
 // DecryptAndDecodeAudio() and DecryptAndDecodeVideo().
 bool ContentDecryptorDelegate::Decrypt(
     media::Decryptor::StreamType stream_type,
     const scoped_refptr<media::DecoderBuffer>& encrypted_buffer,
     const media::Decryptor::DecryptCB& decrypt_cb) {
   DVLOG(3) << "Decrypt() - stream_type: " << stream_type;
+
+  if (is_instance_crashed_)
+    return false;
+
   // |{audio|video}_input_resource_| is not being used by the plugin
   // now because there is only one pending audio/video decrypt request at any
   // time. This is enforced by the media pipeline.
   scoped_refptr<PPB_Buffer_Impl> encrypted_resource;
   if (!MakeMediaBufferResource(
           stream_type, encrypted_buffer, &encrypted_resource) ||
       !encrypted_resource.get()) {
     return false;
   }
   ScopedPPResource pp_resource(encrypted_resource.get());
@@ skipping 32 matching lines @@
   plugin_decryption_interface_->Decrypt(pp_instance_,
                                         pp_resource,
                                         &block_info);
   return true;
 }
 
 bool ContentDecryptorDelegate::CancelDecrypt(
     media::Decryptor::StreamType stream_type) {
   DVLOG(3) << "CancelDecrypt() - stream_type: " << stream_type;
 
+  if (is_instance_crashed_)
+    return false;
+
   media::Decryptor::DecryptCB decrypt_cb;
   switch (stream_type) {
     case media::Decryptor::kAudio:
       // Release the shared memory as it can still be in use by the plugin.
       // The next Decrypt() call will need to allocate a new shared memory
       // buffer.
       audio_input_resource_ = NULL;
       pending_audio_decrypt_request_id_ = 0;
       decrypt_cb = base::ResetAndReturn(&pending_audio_decrypt_cb_);
       break;
@@ skipping 12 matching lines @@
 
   if (!decrypt_cb.is_null())
     decrypt_cb.Run(media::Decryptor::kSuccess, NULL);
 
   return true;
 }
 
 bool ContentDecryptorDelegate::InitializeAudioDecoder(
     const media::AudioDecoderConfig& decoder_config,
     const media::Decryptor::DecoderInitCB& init_cb) {
+  if (is_instance_crashed_)
+    return false;
+
   PP_AudioDecoderConfig pp_decoder_config;
   pp_decoder_config.codec =
       MediaAudioCodecToPpAudioCodec(decoder_config.codec());
   pp_decoder_config.channel_count =
       media::ChannelLayoutToChannelCount(decoder_config.channel_layout());
   pp_decoder_config.bits_per_channel = decoder_config.bits_per_channel();
   pp_decoder_config.samples_per_second = decoder_config.samples_per_second();
   pp_decoder_config.request_id = next_decryption_request_id_++;
 
   audio_samples_per_second_ = pp_decoder_config.samples_per_second;
@@ skipping 15 matching lines @@
 
   plugin_decryption_interface_->InitializeAudioDecoder(pp_instance_,
                                                        &pp_decoder_config,
                                                        pp_resource);
   return true;
 }
 
 bool ContentDecryptorDelegate::InitializeVideoDecoder(
     const media::VideoDecoderConfig& decoder_config,
     const media::Decryptor::DecoderInitCB& init_cb) {
+  if (is_instance_crashed_)
+    return false;
+
   PP_VideoDecoderConfig pp_decoder_config;
   pp_decoder_config.codec =
       MediaVideoCodecToPpVideoCodec(decoder_config.codec());
   pp_decoder_config.profile =
       MediaVideoCodecProfileToPpVideoCodecProfile(decoder_config.profile());
   pp_decoder_config.format =
       MediaVideoFormatToPpDecryptedFrameFormat(decoder_config.format());
   pp_decoder_config.width = decoder_config.coded_size().width();
   pp_decoder_config.height = decoder_config.coded_size().height();
   pp_decoder_config.request_id = next_decryption_request_id_++;
@@ skipping 15 matching lines @@
   natural_size_ = decoder_config.natural_size();
 
   plugin_decryption_interface_->InitializeVideoDecoder(pp_instance_,
                                                        &pp_decoder_config,
                                                        pp_resource);
   return true;
 }
 
 bool ContentDecryptorDelegate::DeinitializeDecoder(
     media::Decryptor::StreamType stream_type) {
+  if (is_instance_crashed_)
+    return false;
+
   CancelDecode(stream_type);
 
   natural_size_ = gfx::Size();
 
   // TODO(tomfinegan): Add decoder deinitialize request tracking, and get
   // stream type from media stack.
   plugin_decryption_interface_->DeinitializeDecoder(
       pp_instance_, MediaDecryptorStreamTypeToPpStreamType(stream_type), 0);
   return true;
 }
 
 bool ContentDecryptorDelegate::ResetDecoder(
     media::Decryptor::StreamType stream_type) {
+  if (is_instance_crashed_)
+    return false;
+
   CancelDecode(stream_type);
 
   // TODO(tomfinegan): Add decoder reset request tracking.
   plugin_decryption_interface_->ResetDecoder(
       pp_instance_, MediaDecryptorStreamTypeToPpStreamType(stream_type), 0);
   return true;
 }
 
 bool ContentDecryptorDelegate::DecryptAndDecodeAudio(
     const scoped_refptr<media::DecoderBuffer>& encrypted_buffer,
     const media::Decryptor::AudioDecodeCB& audio_decode_cb) {
+  if (is_instance_crashed_)
+    return false;
+
   // |audio_input_resource_| is not being used by the plugin now
   // because there is only one pending audio decode request at any time.
   // This is enforced by the media pipeline.
   scoped_refptr<PPB_Buffer_Impl> encrypted_resource;
   if (!MakeMediaBufferResource(media::Decryptor::kAudio,
                                encrypted_buffer,
                                &encrypted_resource)) {
     return false;
   }
 
@@ skipping 24 matching lines @@
   plugin_decryption_interface_->DecryptAndDecode(pp_instance_,
                                                  PP_DECRYPTORSTREAMTYPE_AUDIO,
                                                  pp_resource,
                                                  &block_info);
   return true;
 }
 
 bool ContentDecryptorDelegate::DecryptAndDecodeVideo(
     const scoped_refptr<media::DecoderBuffer>& encrypted_buffer,
     const media::Decryptor::VideoDecodeCB& video_decode_cb) {
+  if (is_instance_crashed_)
+    return false;
+
   // |video_input_resource_| is not being used by the plugin now
   // because there is only one pending video decode request at any time.
   // This is enforced by the media pipeline.
   scoped_refptr<PPB_Buffer_Impl> encrypted_resource;
   if (!MakeMediaBufferResource(media::Decryptor::kVideo,
                                encrypted_buffer,
                                &encrypted_resource)) {
     return false;
   }
 
@@ skipping 510 matching lines @@
     frames->push_back(frame);
 
     cur += frame_size;
     bytes_left -= frame_size;
   } while (bytes_left > 0);
 
   return true;
 }
 
 }  // namespace content