Added support for pending extensions to ExtensionsService and

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"
 #include "base/string16.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "base/values.h"
+#include "base/version.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_thread.h"
 #include "chrome/browser/debugger/devtools_manager.h"
 #include "chrome/browser/extensions/crx_installer.h"
 #include "chrome/browser/extensions/extension_accessibility_api.h"
 #include "chrome/browser/extensions/extension_bookmarks_module.h"
 #include "chrome/browser/extensions/extension_browser_event_router.h"
 #include "chrome/browser/extensions/extension_data_deleter.h"
 #include "chrome/browser/extensions/extension_dom_ui.h"
 #include "chrome/browser/extensions/extension_history_api.h"
@@ skipping 65 matching lines @@
   // independent of the manifest in our prefs.
   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)
+    : update_url(update_url),
+      version(version),
+      is_theme(is_theme),
+      install_silently(install_silently) {}
+
+PendingExtensionInfo::PendingExtensionInfo()
+    : update_url(),
+      version(),
+      is_theme(false),
+      install_silently(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(),
                       extension_urls::kMiniGalleryDownloadPrefix, false) &&
@@ skipping 86 matching lines @@
 
 void ExtensionsService::InstallExtension(const FilePath& extension_path) {
   scoped_refptr<CrxInstaller> installer(
       new CrxInstaller(install_directory_,
                        this,  // frontend
                        NULL));  // no client (silent install)
   installer->set_allow_privilege_increase(true);
   installer->InstallCrx(extension_path);
 }
 
+namespace {
+  // TODO(akalin): Put this somewhere where both crx_installer.cc and
+  // this file can use it.
+  void DeleteFileHelper(const FilePath& path, bool recursive) {
+    DCHECK(ChromeThread::CurrentlyOn(ChromeThread::FILE));
+    file_util::Delete(path, recursive);
+  }
+}  // namespace
+
 void ExtensionsService::UpdateExtension(const std::string& id,
                                         const FilePath& extension_path,
                                         const GURL& download_url) {
-  if (!GetExtensionByIdInternal(id, true, true)) {
-    LOG(WARNING) << "Will not update extension " << id << " because it is not "
-                 << "installed";
+  PendingExtensionMap::const_iterator it = pending_extensions_.find(id);
+  if ((it == pending_extensions_.end()) &&
+      !GetExtensionByIdInternal(id, true, true)) {
+    LOG(WARNING) << "Will not update extension " << id
+                 << " because it is not installed or pending";
+    // Delete extension_path since we're not creating a CrxInstaller
+    // that would do it for us.
+    ChromeThread::PostTask(
+        ChromeThread::FILE, FROM_HERE,
+        NewRunnableFunction(&DeleteFileHelper, extension_path, false));
     return;
   }
 
+  // We want a silent install only for non-pending extensions and
+  // pending extensions that have install_silently set.
+  ExtensionInstallUI* client =
+      ((it == pending_extensions_.end()) || it->second.install_silently) ?
+      NULL : new ExtensionInstallUI(profile_);
+
   scoped_refptr<CrxInstaller> installer(
       new CrxInstaller(install_directory_,
                        this,  // frontend
-                       NULL));  // no client (silent install)
+                       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) {
+  if (GetExtensionByIdInternal(id, true, true)) {
+    return;
+  }
+  AddPendingExtensionInternal(id, update_url, version,
+                              is_theme, install_silently);
+}
+
+void ExtensionsService::AddPendingExtensionInternal(
+    const std::string& id, const GURL& update_url,
+    const Version& version, bool is_theme, bool install_silently) {
+  pending_extensions_[id] =
+      PendingExtensionInfo(update_url, version, is_theme, install_silently);
+}
+
 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
     // later.
     ExtensionProcessManager* manager = profile_->GetExtensionProcessManager();
@@ skipping 580 matching lines @@
   for (size_t i = 0; i < extensions_.size(); ++i) {
     if (!extensions_[i]->IsTheme())
       extension_ids.insert(extensions_[i]->id());
   }
 
   child_process_logging::SetActiveExtensions(extension_ids);
 }
 
 void ExtensionsService::OnExtensionInstalled(Extension* extension,
                                              bool allow_privilege_increase) {
+  PendingExtensionMap::iterator it =
+      pending_extensions_.find(extension->id());
+  if (it != pending_extensions_.end() &&
+      (it->second.is_theme != extension->IsTheme())) {
+    LOG(WARNING) << "Not installing pending extension " << extension->id()
+                 << " with is_theme = " << extension->IsTheme()
+                 << "; 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;
+  }
+
   extension_prefs_->OnExtensionInstalled(extension);
 
   // If the extension is a theme, tell the profile (and therefore ThemeProvider)
   // to apply it.
   if (extension->IsTheme()) {
     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);
+  }
 }
 
 void ExtensionsService::OnExtensionOverinstallAttempted(const std::string& id) {
   Extension* extension = GetExtensionById(id, false);
   if (extension && extension->IsTheme()) {
     NotificationService::current()->Notify(
         NotificationType::THEME_INSTALLED,
         Source<Profile>(profile_),
         Details<Extension>(extension));
   } else {
@@ skipping 308 matching lines @@
   // Finish installing on UI thread.
   ChromeThread::PostTask(
       ChromeThread::UI, FROM_HERE,
       NewRunnableMethod(
           frontend_,
           &ExtensionsService::ContinueLoadAllExtensions,
           extensions_to_reload,
           start_time,
           true));
 }