Pepper: Fix renderer crash on plugin destruction.

components/nacl/renderer/ppb_nacl_private_impl.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 "components/nacl/renderer/ppb_nacl_private_impl.h"
 
 #include <numeric>
 #include <string>
 #include <vector>
 
@@ skipping 1517 matching lines @@
   DownloadFile(instance, url,
                base::Bind(&DidOpenManifestEntry, out_file_info, callback));
 }
 
 void SetPNaClStartTime(PP_Instance instance) {
   NexeLoadManager* load_manager = GetNexeLoadManager(instance);
   if (load_manager)
     load_manager->set_pnacl_start_time(base::Time::Now());
 }
 
+// PexeDownloader is responsible for deleting itself when the download
+// finishes.
 class PexeDownloader : public blink::WebURLLoaderClient {
  public:
   PexeDownloader(PP_Instance instance,
                  scoped_ptr<blink::WebURLLoader> url_loader,
                  const std::string& pexe_url,
                  int32_t pexe_opt_level,
                  const PPP_PexeStreamHandler* stream_handler,
                  void* stream_handler_user_data)
       : instance_(instance),
         url_loader_(url_loader.Pass()),
@@ skipping 47 matching lines @@
               last_modified_time,
               etag,
               has_no_store_header,
               base::Bind(&PexeDownloader::didGetNexeFd,
                          weak_factory_.GetWeakPtr()));
   }
 
   virtual void didGetNexeFd(int32_t pp_error,
                             bool cache_hit,
                             PP_FileHandle file_handle) {
+    if (!content::PepperPluginInstance::Get(instance_)) {
+      delete this;
+      return;
+    }
+
     HistogramEnumerate("NaCl.Perf.PNaClCache.IsHit", cache_hit, 2);
     if (cache_hit) {
       stream_handler_->DidCacheHit(stream_handler_user_data_, file_handle);
 
       // We delete the PexeDownloader at this point since we successfully got a
       // cached, translated nexe.
       delete this;
       return;
     }
     stream_handler_->DidCacheMiss(stream_handler_user_data_,
                                   expected_content_length_);
 
     // No translated nexe was found in the cache, so we should download the
     // file to start streaming it.
     url_loader_->setDefersLoading(false);
   }
 
   virtual void didReceiveData(blink::WebURLLoader* loader,
                               const char* data,
                               int data_length,
                               int encoded_data_length) {
-    // Stream the data we received to the stream callback.
-    stream_handler_->DidStreamData(stream_handler_user_data_,
-                                   data,
-                                   data_length);
+    if (content::PepperPluginInstance::Get(instance_)) {
+      // Stream the data we received to the stream callback.
+      stream_handler_->DidStreamData(stream_handler_user_data_,
+                                     data,
+                                     data_length);
+    }
   }
 
   virtual void didFinishLoading(blink::WebURLLoader* loader,
                                 double finish_time,
                                 int64_t total_encoded_data_length) {
     int32_t result = success_ ? PP_OK : PP_ERROR_FAILED;
-    stream_handler_->DidFinishStream(stream_handler_user_data_, result);
+
+    if (content::PepperPluginInstance::Get(instance_))
+      stream_handler_->DidFinishStream(stream_handler_user_data_, result);
     delete this;
   }
 
   virtual void didFail(blink::WebURLLoader* loader,
                        const blink::WebURLError& error) {
     success_ = false;
   }
 
   PP_Instance instance_;
   scoped_ptr<blink::WebURLLoader> url_loader_;
@@ skipping 86 matching lines @@
   &StreamPexe
 };
 
 }  // namespace
 
 const PPB_NaCl_Private* GetNaClPrivateInterface() {
   return &nacl_interface;
 }
 
 }  // namespace nacl