Fix 2 bugs related to remembering loaded unpacked extensions.

chrome/browser/extensions/extensions_service.cc

 // Copyright (c) 2010 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/basictypes.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/histogram.h"
@@ skipping 41 matching lines @@
 
 namespace errors = extension_manifest_errors;
 
 namespace {
 
 // Helper class to collect the IDs of every extension listed in the prefs.
 class InstalledExtensionSet {
  public:
   explicit InstalledExtensionSet(ExtensionPrefs* prefs) {
     scoped_ptr<ExtensionPrefs::ExtensionsInfo> info(
-        ExtensionPrefs::CollectExtensionsInfo(prefs));
+        prefs->GetInstalledExtensionsInfo());
 
     for (size_t i = 0; i < info->size(); ++i) {
       std::string version;
       const DictionaryValue* manifest = info->at(i)->extension_manifest.get();
       if (!manifest ||
           !manifest->GetString(extension_manifest_keys::kVersion, &version)) {
         // Without a version, the extension is invalid. Ignoring it here will
         // cause it to get garbage collected.
         continue;
       }
@@ skipping 167 matching lines @@
       if (devtools_cookie >= 0)
         orphaned_dev_tools_[extension_id] = devtools_cookie;
     }
 
     path = current_extension->path();
     UnloadExtension(extension_id);
   } else {
     path = unloaded_extension_paths_[extension_id];
   }
 
-  // We should always be able to remember the extension's path. If it's not in
-  // the map, someone failed to update |unloaded_extension_paths_|.
-  CHECK(!path.empty());
-
-  LoadExtension(path);
+  // Check the installed extensions to see if what we're reloading was already
+  // installed.
+  scoped_ptr<ExtensionInfo> installed_extension(
+      extension_prefs_->GetInstalledExtensionInfo(extension_id));
+  if (installed_extension.get() &&
+      installed_extension->extension_manifest.get()) {
+    LoadInstalledExtension(*installed_extension, false);
+  } else {
+    // We should always be able to remember the extension's path. If it's not in
+    // the map, someone failed to update |unloaded_extension_paths_|.
+    CHECK(!path.empty());
+    LoadExtension(path);
+  }
 }
 
 void ExtensionsService::UninstallExtension(const std::string& extension_id,
                                            bool external_uninstall) {
   Extension* extension = GetExtensionByIdInternal(extension_id, true, true);
 
   // Callers should not send us nonexistant extensions.
   DCHECK(extension);
 
   extension_prefs_->OnExtensionUninstalled(extension, external_uninstall);
@@ skipping 96 matching lines @@
 }
 
 void ExtensionsService::LoadAllExtensions() {
   base::TimeTicks start_time = base::TimeTicks::Now();
 
   // Load any component extensions.
   LoadComponentExtensions();
 
   // Load the previously installed extensions.
   scoped_ptr<ExtensionPrefs::ExtensionsInfo> info(
-      ExtensionPrefs::CollectExtensionsInfo(extension_prefs_.get()));
+      extension_prefs_->GetInstalledExtensionsInfo());
 
   // If any extensions need localization, we bounce them all to the file thread
   // for re-reading and localization.
   for (size_t i = 0; i < info->size(); ++i) {
     if (ShouldReloadExtensionManifest(*info->at(i))) {
       ChromeThread::PostTask(
         ChromeThread::FILE, FROM_HERE, NewRunnableMethod(
             backend_.get(),
             &ExtensionsServiceBackend::ReloadExtensionManifests,
             info.release(),  // Callee takes ownership of the memory.
@@ skipping 349 matching lines @@
 
         // To upgrade an extension in place, unload the old one and
         // then load the new one.
         UnloadExtension(old->id());
         old = NULL;
 
         if (!allow_silent_upgrade) {
           // Extension has changed permissions significantly. Disable it. We
           // send a notification below.
           extension_prefs_->SetExtensionState(extension, Extension::DISABLED);
-          extension_prefs_->SetShowInstallWarningOnEnable(extension, true);
+          extension_prefs_->SetDidExtensionEscalatePermissions(extension, true);
         }
       } else {
         // We already have the extension of the same or older version.
         std::string error_message("Duplicate extension load attempt: ");
         error_message += extension->id();
         LOG(WARNING) << error_message;
         ReportExtensionLoadError(extension->path(),
                                  error_message,
                                  NotificationType::EXTENSION_OVERINSTALL_ERROR,
                                  false);
@@ skipping 389 matching lines @@
   // Finish installing on UI thread.
   ChromeThread::PostTask(
       ChromeThread::UI, FROM_HERE,
       NewRunnableMethod(
           frontend_,
           &ExtensionsService::ContinueLoadAllExtensions,
           extensions_to_reload,
           start_time,
           true));
 }