Install CRX updates one at a time.

chrome/browser/extensions/extension_updater.cc

 // Copyright (c) 2011 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/extension_updater.h"
 
 #include <algorithm>
 #include <set>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/file_util.h"
 #include "base/memory/scoped_handle.h"
 #include "base/metrics/histogram.h"
 #include "base/rand_util.h"
 #include "base/stl_util-inl.h"
 #include "base/string_number_conversions.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "base/threading/thread.h"
 #include "base/version.h"
 #include "crypto/sha2.h"
 #include "content/common/notification_service.h"
+#include "content/common/notification_source.h"
 #include "chrome/browser/browser_process.h"
+#include "chrome/browser/extensions/crx_installer.h"
 #include "chrome/browser/extensions/extension_error_reporter.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/utility_process_host.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_file_util.h"
@@ skipping 401 matching lines @@
       version("") {}
 
 ExtensionUpdater::ExtensionFetch::ExtensionFetch(const std::string& i,
                                                  const GURL& u,
                                                  const std::string& h,
                                                  const std::string& v)
     : id(i), url(u), package_hash(h), version(v) {}
 
 ExtensionUpdater::ExtensionFetch::~ExtensionFetch() {}
 
+ExtensionUpdater::FetchedCrxFile::FetchedCrxFile(const std::string& i,
+                                                 const FilePath& p,
+                                                 const GURL& u)
+    : id(i),
+      path(p),
+      download_url(u) {}
+
+ExtensionUpdater::FetchedCrxFile::FetchedCrxFile()
+    : id(""),
+      path(),
+      download_url() {}
+
+ExtensionUpdater::FetchedCrxFile::~FetchedCrxFile() {}
+
 ExtensionUpdater::ExtensionUpdater(ExtensionServiceInterface* service,
                                    ExtensionPrefs* extension_prefs,
                                    PrefService* prefs,
                                    Profile* profile,
                                    int frequency_seconds)
     : alive_(false),
       weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       service_(service), frequency_seconds_(frequency_seconds),
       method_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       will_check_soon_(false), extension_prefs_(extension_prefs),
-      prefs_(prefs), profile_(profile), blacklist_checks_enabled_(true) {
+      prefs_(prefs), profile_(profile), blacklist_checks_enabled_(true),
+      crx_install_is_running_(false) {
   Init();
 }
 
 void ExtensionUpdater::Init() {
   DCHECK_GE(frequency_seconds_, 5);
   DCHECK_LE(frequency_seconds_, kMaxUpdateFrequencySeconds);
 #ifdef NDEBUG
   // In Release mode we enforce that update checks don't happen too often.
   frequency_seconds_ = std::max(frequency_seconds_, kMinUpdateFrequencySeconds);
 #endif
@@ skipping 364 matching lines @@
     ExtensionFetch next = extensions_pending_.front();
     extensions_pending_.pop_front();
     FetchUpdatedExtension(next.id, next.url, next.package_hash, next.version);
   }
 }
 
 void ExtensionUpdater::OnCRXFileWritten(const std::string& id,
                                         const FilePath& path,
                                         const GURL& download_url) {
   DCHECK(alive_);
-  // The ExtensionService is now responsible for cleaning up the temp file
-  // at |path|.
-  service_->UpdateExtension(id, path, download_url);
-  in_progress_ids_.erase(id);
+
+  FetchedCrxFile fetched(id, path, download_url);
+  fetched_crx_files_.push(fetched);
+
+  MaybeUpdateCrxFile();
+}
+
+bool ExtensionUpdater::MaybeUpdateCrxFile() {
+  if (crx_install_is_running_) {
+    return false;
+  }
+
+  while (!fetched_crx_files_.empty() && !crx_install_is_running_) {
+    const FetchedCrxFile& crx_file = fetched_crx_files_.top();
+
+    // The ExtensionService is now responsible for cleaning up the temp file
+    // at |extension_file.path|.
+    Source<CrxInstaller> install_notification_source(NULL);
+    if (service_->UpdateExtension(crx_file.id,
+                                  crx_file.path,
+                                  crx_file.download_url,
+                                  &install_notification_source)) {
+      crx_install_is_running_ = true;
+
+      // Source parameter ensures that we only see the completion event for the
+      // the installer we started.
+      registrar_.Add(this,
+                     NotificationType::CRX_INSTALLER_DONE,
+                     install_notification_source);
+    }
+    in_progress_ids_.erase(crx_file.id);
+    fetched_crx_files_.pop();
+  }
+
+  // If an updater is running, it was started above.
+  return crx_install_is_running_;
+}
+
+void ExtensionUpdater::Observe(NotificationType type,
+                               const NotificationSource& source,
+                               const NotificationDetails& details) {
+  DCHECK(type == NotificationType::CRX_INSTALLER_DONE);
+
+  // No need to listen for CRX_INSTALLER_DONE anymore.
+  registrar_.Remove(this,
+                    NotificationType::CRX_INSTALLER_DONE,
+                    source);
+  crx_install_is_running_ = false;
+  // If any files are available to update, start one.
+  MaybeUpdateCrxFile();
 }
 
 void ExtensionUpdater::OnCRXFileWriteError(const std::string& id) {
   DCHECK(alive_);
   in_progress_ids_.erase(id);
 }
 
 void ExtensionUpdater::ScheduleNextCheck(const TimeDelta& target_delay) {
   DCHECK(alive_);
   DCHECK(!timer_.IsRunning());
@@ skipping 303 matching lines @@
   std::set<std::string>::const_iterator i;
   for (i = ids.begin(); i != ids.end(); ++i)
     in_progress_ids_.insert(*i);
 }
 
 void ExtensionUpdater::RemoveFromInProgress(const std::set<std::string>& ids) {
   std::set<std::string>::const_iterator i;
   for (i = ids.begin(); i != ids.end(); ++i)
     in_progress_ids_.erase(*i);
 }