Fix a browser crash that occurs if the extension unpacker process crashes...

chrome/browser/extensions/extensions_service.cc

 // Copyright (c) 2009 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 "chrome/browser/extensions/extensions_service.h"
 
 #include "base/file_util.h"
 #include "base/gfx/png_encoder.h"
 #include "base/scoped_handle.h"
 #include "base/scoped_temp_dir.h"
@@ skipping 80 matching lines @@
 // process.  Results are sent back to this class, which we route to the
 // ExtensionServiceBackend.
 class ExtensionsServiceBackend::UnpackerClient
     : public UtilityProcessHost::Client {
  public:
   UnpackerClient(ExtensionsServiceBackend* backend,
                  const FilePath& extension_path,
                  const std::string& expected_id,
                  bool from_external)
     : backend_(backend), extension_path_(extension_path),
-      expected_id_(expected_id), from_external_(from_external) {
+      expected_id_(expected_id), from_external_(from_external),
+      got_response_(false) {
   }
 
   // Starts the unpack task.  We call back to the backend when the task is done,
   // or a problem occurs.
   void Start() {
     AddRef();  // balanced in OnUnpackExtensionReply()
 
     // TODO(mpcomplete): handle multiple installs
     FilePath temp_dir = backend_->install_directory_.AppendASCII(
         kUnpackExtensionDir);
@@ skipping 24 matching lines @@
                                    unpacker.decoded_images());
       } else {
         OnUnpackExtensionFailed(unpacker.error_message());
       }
     }
   }
 
  private:
   // UtilityProcessHost::Client
   virtual void OnProcessCrashed() {
-    OnUnpackExtensionFailed("Chrome crashed while trying to install");
+    // Don't report crashes if they happen after we got a response.
+    if (got_response_)
+      return;
+
+    OnUnpackExtensionFailed("Chrome crashed while trying to install.");
   }
 
   virtual void OnUnpackExtensionSucceeded(
       const DictionaryValue& manifest,
       const std::vector< Tuple2<SkBitmap, FilePath> >& images) {
     // The extension was unpacked to the temp dir inside our unpacking dir.
     FilePath extension_dir = temp_extension_path_.DirName().AppendASCII(
         ExtensionsServiceBackend::kTempExtensionName);
     backend_->OnExtensionUnpacked(extension_path_, extension_dir,
                                   expected_id_, from_external_,
                                   manifest, images);
     Cleanup();
   }
 
   virtual void OnUnpackExtensionFailed(const std::string& error_message) {
     backend_->ReportExtensionInstallError(extension_path_, error_message);
     Cleanup();
   }
 
   // Cleans up our temp directory.
   void Cleanup() {
+    if (got_response_)
+      return;
+
+    got_response_ = true;
     file_util::Delete(temp_extension_path_.DirName(), true);
     Release();  // balanced in Run()
   }
 
   // Starts the utility process that unpacks our extension.
   void StartProcessOnIOThread(ResourceDispatcherHost* rdh,
                               MessageLoop* file_loop) {
     UtilityProcessHost* host = new UtilityProcessHost(rdh, this, file_loop);
     host->StartExtensionUnpacker(temp_extension_path_);
   }
 
   scoped_refptr<ExtensionsServiceBackend> backend_;
 
   // The path to the crx file that we're installing.
   FilePath extension_path_;
 
   // The path to the copy of the crx file in the temporary directory where we're
   // unpacking it.
   FilePath temp_extension_path_;
 
   // The ID we expect this extension to have, if any.
   std::string expected_id_;
 
   // True if this is being installed from an external source.
   bool from_external_;
+
+  // True if we got a response from the utility process and have cleaned up
+  // already.
+  bool got_response_;
 };
 
 ExtensionsService::ExtensionsService(Profile* profile,
                                      MessageLoop* frontend_loop,
                                      MessageLoop* backend_loop,
                                      const std::string& registry_path)
     : prefs_(profile->GetPrefs()),
       backend_loop_(backend_loop),
       install_directory_(profile->GetPath().AppendASCII(kInstallDirectoryName)),
       backend_(new ExtensionsServiceBackend(
@@ skipping 746 matching lines @@
 
 bool ExtensionsServiceBackend::ShouldInstall(const std::string& id,
                                              const std::string& version) {
   FilePath dir(install_directory_.AppendASCII(id.c_str()));
   std::string current_version;
   if (ReadCurrentVersion(dir, &current_version)) {
     return CheckCurrentVersion(version, current_version, dir);
   }
   return true;
 }