Reworked ExtensionsService::AddPendingExtension().

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 55 matching lines @@
   if (info.extension_location == Extension::LOAD)
     return true;
 
   // Otherwise, reload the manifest it needs to be relocalized.
   return extension_l10n_util::ShouldRelocalizeManifest(info);
 }
 
 }  // namespace
 
 PendingExtensionInfo::PendingExtensionInfo(const GURL& update_url,
-                                           const Version& version,
                                            bool is_theme,
-                                           bool install_silently)
+                                           bool install_silently,
+                                           bool enable_on_install,
+                                           bool enable_incognito_on_install)
     : update_url(update_url),
-      version(version),
       is_theme(is_theme),
-      install_silently(install_silently) {}
+      install_silently(install_silently),
+      enable_on_install(enable_on_install),
+      enable_incognito_on_install(enable_incognito_on_install) {}
 
 PendingExtensionInfo::PendingExtensionInfo()
     : update_url(),
-      version(),
       is_theme(false),
-      install_silently(false) {}
+      install_silently(false),
+      enable_on_install(false),
+      enable_incognito_on_install(false) {}
 
 // ExtensionsService.
 
 const char* ExtensionsService::kInstallDirectoryName = "Extensions";
 const char* ExtensionsService::kCurrentVersionFileName = "Current Version";
 
 // static
 bool ExtensionsService::IsDownloadFromGallery(const GURL& download_url,
                                               const GURL& referrer_url) {
   if (StartsWithASCII(download_url.spec(),
@@ skipping 148 matching lines @@
                        client));
   installer->set_expected_id(id);
   installer->set_delete_source(true);
   installer->set_force_web_origin_to_download_url(true);
   installer->set_original_url(download_url);
   installer->InstallCrx(extension_path);
 }
 
 void ExtensionsService::AddPendingExtension(
     const std::string& id, const GURL& update_url,
-    const Version& version, bool is_theme, bool install_silently) {
+    bool is_theme, bool install_silently,
+    bool enable_on_install, bool enable_incognito_on_install) {
   if (GetExtensionByIdInternal(id, true, true)) {
     LOG(DFATAL) << "Trying to add pending extension " << id
                 << " which already exists";
     return;
   }
-  AddPendingExtensionInternal(id, update_url, version,
-                              is_theme, install_silently);
+  AddPendingExtensionInternal(
+      id, update_url, is_theme, install_silently,
+      enable_on_install, enable_incognito_on_install);
 }
 
 void ExtensionsService::AddPendingExtensionInternal(
     const std::string& id, const GURL& update_url,
-    const Version& version, bool is_theme, bool install_silently) {
+    bool is_theme, bool install_silently,
+    bool enable_on_install, bool enable_incognito_on_install) {
   pending_extensions_[id] =
-      PendingExtensionInfo(update_url, version, is_theme, install_silently);
+      PendingExtensionInfo(update_url, is_theme, install_silently,
+                           enable_on_install, enable_incognito_on_install);
 }
 
 void ExtensionsService::ReloadExtension(const std::string& extension_id) {
   FilePath path;
   Extension* current_extension = GetExtensionById(extension_id, false);
 
   // Unload the extension if it's loaded. It might not be loaded if it crashed.
   if (current_extension) {
     // If the extension has an inspector open for its background page, detach
     // the inspector and hang onto a cookie for it, so that we can reattach
@@ skipping 389 matching lines @@
                                               bool enabled) {
   extension_prefs_->SetIsIncognitoEnabled(extension->id(), enabled);
 
   // Broadcast unloaded and loaded events to update browser state.
   NotifyExtensionUnloaded(extension);
   NotifyExtensionLoaded(extension);
 }
 
 bool ExtensionsService::AllowFileAccess(const Extension* extension) {
   return (CommandLine::ForCurrentProcess()->HasSwitch(
-              switches::kDisableExtensionsFileAccessCheck) || 
+              switches::kDisableExtensionsFileAccessCheck) ||
           extension_prefs_->AllowFileAccess(extension->id()));
 }
 
 void ExtensionsService::SetAllowFileAccess(Extension* extension, bool allow) {
   extension_prefs_->SetAllowFileAccess(extension->id(), allow);
   NotificationService::current()->Notify(
       NotificationType::EXTENSION_USER_SCRIPTS_UPDATED,
       Source<Profile>(profile_),
       Details<Extension>(extension));
 }
@@ skipping 189 matching lines @@
   for (size_t i = 0; i < extensions_.size(); ++i) {
     if (!extensions_[i]->is_theme())
       extension_ids.insert(extensions_[i]->id());
   }
 
   child_process_logging::SetActiveExtensions(extension_ids);
 }
 
 void ExtensionsService::OnExtensionInstalled(Extension* extension,
                                              bool allow_privilege_increase) {
+  // Ensure extension is deleted unless we transfer ownership.
+  scoped_ptr<Extension> scoped_extension(extension);
+  Extension::State initial_state = Extension::DISABLED;
+  bool initial_enable_incognito = false;
   PendingExtensionMap::iterator it =
       pending_extensions_.find(extension->id());
-  if (it != pending_extensions_.end() &&
-      (it->second.is_theme != extension->is_theme())) {
-    LOG(WARNING) << "Not installing pending extension " << extension->id()
-                 << " with is_theme = " << extension->is_theme()
-                 << "; expected is_theme = " << it->second.is_theme;
-    // Delete the extension directory since we're not going to load
-    // it.
-    ChromeThread::PostTask(
-        ChromeThread::FILE, FROM_HERE,
-        NewRunnableFunction(&DeleteFileHelper, extension->path(), true));
-    delete extension;
-    return;
+  if (it != pending_extensions_.end()) {
+    // Set initial state from pending extension data.
+    if (it->second.is_theme != extension->is_theme()) {
+      LOG(WARNING)
+          << "Not installing pending extension " << extension->id()
+          << " with is_theme = " << extension->is_theme()
+          << "; expected is_theme = " << it->second.is_theme;
+      // Delete the extension directory since we're not going to
+      // load it.
+      ChromeThread::PostTask(
+          ChromeThread::FILE, FROM_HERE,
+          NewRunnableFunction(&DeleteFileHelper, extension->path(), true));
+      return;
+    }
+    if (it->second.is_theme) {
+      DCHECK(it->second.enable_on_install);
+      initial_state = Extension::ENABLED;
+      DCHECK(!it->second.enable_incognito_on_install);
+      initial_enable_incognito = false;
+    } else {
+      initial_state =
+          it->second.enable_on_install ?
+          Extension::ENABLED : Extension::DISABLED;
+      initial_enable_incognito =
+          it->second.enable_incognito_on_install;
+    }
+
+    pending_extensions_.erase(it);
+  } else {
+    // Make sure we don't enable a disabled extension.
+    Extension::State existing_state =
+        extension_prefs_->GetExtensionState(extension->id());
+    initial_state =
+        (existing_state == Extension::DISABLED) ?
+        Extension::DISABLED : Extension::ENABLED;
+    initial_enable_incognito = false;
   }
 
-  extension_prefs_->OnExtensionInstalled(extension);
+  extension_prefs_->OnExtensionInstalled(
+      extension, initial_state, initial_enable_incognito);
 
   // If the extension is a theme, tell the profile (and therefore ThemeProvider)
   // to apply it.
   if (extension->is_theme()) {
     NotificationService::current()->Notify(
         NotificationType::THEME_INSTALLED,
         Source<Profile>(profile_),
         Details<Extension>(extension));
   } else {
     NotificationService::current()->Notify(
         NotificationType::EXTENSION_INSTALLED,
         Source<Profile>(profile_),
         Details<Extension>(extension));
   }
 
-  // Also load the extension.
-  OnExtensionLoaded(extension, allow_privilege_increase);
-
-  // Erase any pending extension.
-  if (it != pending_extensions_.end()) {
-    pending_extensions_.erase(it);
-  }
-
   if (profile_->GetTemplateURLModel())
     profile_->GetTemplateURLModel()->RegisterExtensionKeyword(extension);
+
+  // Transfer ownership of |extension| to OnExtensionLoaded.
+  OnExtensionLoaded(scoped_extension.release(), allow_privilege_increase);
 }
 
 Extension* ExtensionsService::GetExtensionByIdInternal(const std::string& id,
                                                        bool include_enabled,
                                                        bool include_disabled) {
   std::string lowercase_id = StringToLowerASCII(id);
   if (include_enabled) {
     for (ExtensionList::const_iterator iter = extensions_.begin();
         iter != extensions_.end(); ++iter) {
       if ((*iter)->id() == lowercase_id)
@@ skipping 315 matching lines @@
   // Finish installing on UI thread.
   ChromeThread::PostTask(
       ChromeThread::UI, FROM_HERE,
       NewRunnableMethod(
           frontend_,
           &ExtensionsService::ContinueLoadAllExtensions,
           extensions_to_reload,
           start_time,
           true));
 }