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 238 matching lines @@
     : pp_instance_(pp_instance),
       plugin_decryption_interface_(plugin_decryption_interface),
       next_decryption_request_id_(1),
       audio_samples_per_second_(0),
       audio_channel_count_(0),
       weak_ptr_factory_(this) {
   weak_this_ = weak_ptr_factory_.GetWeakPtr();
 }
 
 ContentDecryptorDelegate::~ContentDecryptorDelegate() {
+  SatisfyAllPendingCallbacksOnError();
 }
 
-void ContentDecryptorDelegate::Initialize(const std::string& key_system) {
+void ContentDecryptorDelegate::Initialize(
+    const std::string& key_system,
+    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,
+    const base::Closure& fatal_plugin_error_cb) {
   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;
+  fatal_plugin_error_cb_ = fatal_plugin_error_cb;
+
+  plugin_decryption_interface_->Initialize(
+      pp_instance_, StringVar::StringToPPVar(key_system_));
+}
+
+void ContentDecryptorDelegate::InstanceCrashed() {
+  fatal_plugin_error_cb_.Run();
+  SatisfyAllPendingCallbacksOnError();
 }
 
 bool ContentDecryptorDelegate::CreateSession(uint32 session_id,
                                              const std::string& type,
                                              const uint8* init_data,
                                              int init_data_length) {
   PP_Var init_data_array =
       PpapiGlobals::Get()->GetVarTracker()->MakeArrayBufferPPVar(
           init_data_length, init_data);
 
@@ skipping 20 matching lines @@
   return true;
 }
 
 // TODO(xhwang): Remove duplication of code in Decrypt(),
 // DecryptAndDecodeAudio() and DecryptAndDecodeVideo().
 bool ContentDecryptorDelegate::Decrypt(
     Decryptor::StreamType stream_type,
     const scoped_refptr<media::DecoderBuffer>& encrypted_buffer,
     const Decryptor::DecryptCB& decrypt_cb) {
   DVLOG(3) << "Decrypt() - stream_type: " << stream_type;
+
   // |{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 683 matching lines @@
                                           frame_count));
     frames->push_back(frame);
 
     cur += frame_size;
     bytes_left -= frame_size;
   } while (bytes_left > 0);
 
   return true;
 }
 
+void ContentDecryptorDelegate::SatisfyAllPendingCallbacksOnError() {
+  if (!audio_decoder_init_cb_.is_null())
+    audio_decoder_init_cb_.ResetAndReturn().Run(false);
+
+  if (!video_decoder_init_cb_.is_null())
+    video_decoder_init_cb_.ResetAndReturn().Run(false);
+
+  audio_input_resource_ = NULL;
+  video_input_resource_ = NULL;
+
+  if (!audio_decrypt_cb_.is_null())
+    audio_decrypt_cb_.ResetAndReturn().Run(media::Decryptor::kError, NULL);
+
+  if (!video_decrypt_cb_.is_null())
+    video_decrypt_cb_.ResetAndReturn().Run(media::Decryptor::kError, NULL);
+
+  if (!audio_decode_cb_.is_null()) {
+    const media::Decryptor::AudioBuffers empty_frames;
+    audio_decode_cb_.ResetAndReturn().Run(media::Decryptor::kError,
+                                          empty_frames);
+  }
+
+  if (!video_decode_cb_.is_null())
+    video_decode_cb_.ResetAndReturn().Run(media::Decryptor::kError, NULL);
+}
+
 }  // namespace content