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 38 matching lines @@
 // happens when creating a temp file or when writing to it. Knowing this
 // will require changes to URLFetcher.
 enum FileWriteResult {
   SUCCESS = 0,
   CANT_CREATE_OR_WRITE_TEMP_CRX,
   CANT_READ_CRX_FILE,
   NUM_FILE_WRITE_RESULTS
 };
 
 // Prototypes allow the functions to be defined in the order they run.
-void CheckThatCrxIsReadable(const FilePath& crx_path);
+void CheckThatCRXIsReadable(const FilePath& crx_path);
 void RecordFileUpdateHistogram(FileWriteResult file_write_result);
 
 // Record the result of writing a CRX file. Will be used to understand
 // high failure rates of CRX installs in the field.  If |success| is
 // true, |crx_path| should be set to the path to the CRX file.
-void RecordCrxWriteHistogram(bool success, const FilePath& crx_path) {
+void RecordCRXWriteHistogram(bool success, const FilePath& crx_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!success) {
     // We know there was an error writing the file.
     RecordFileUpdateHistogram(CANT_CREATE_OR_WRITE_TEMP_CRX);
 
   } else {
     // Test that the file can be read. Based on histograms in
     // SandboxExtensionUnpacker, we know that many CRX files
     // can not be read. Try reading.
     BrowserThread::PostTask(
         BrowserThread::FILE, FROM_HERE,
-        NewRunnableFunction(CheckThatCrxIsReadable, crx_path));
+        NewRunnableFunction(CheckThatCRXIsReadable, crx_path));
   }
 }
 
-void CheckThatCrxIsReadable(const FilePath& crx_path) {
+void CheckThatCRXIsReadable(const FilePath& crx_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   FileWriteResult file_write_result = SUCCESS;
 
   // Open the file in the same way
   // SandboxExtensionUnpacker::ValidateSigniture() will.
   ScopedStdioHandle file(file_util::OpenFile(crx_path, "rb"));
   if (!file.get()) {
     LOG(ERROR) << "Can't read CRX file written for update at path "
                << crx_path.value().c_str();
@@ skipping 319 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 325 matching lines @@
     const GURL& url,
     const net::URLRequestStatus& status,
     int response_code) {
 
   base::PlatformFileError error_code = base::PLATFORM_FILE_OK;
   if (source->FileErrorOccurred(&error_code)) {
     LOG(ERROR) << "Failed to write update CRX with id "
                << current_extension_fetch_.id << ". "
                << "Error code is "<< error_code;
 
-    RecordCrxWriteHistogram(false, FilePath());
+    RecordCRXWriteHistogram(false, FilePath());
     OnCRXFileWriteError(current_extension_fetch_.id);
 
   } else if (status.status() == net::URLRequestStatus::SUCCESS &&
       (response_code == 200 || url.SchemeIsFile())) {
     if (current_extension_fetch_.id == kBlacklistAppID) {
       std::string data;
       CHECK(source->GetResponseAsString(&data));
       ProcessBlacklist(data);
       in_progress_ids_.erase(current_extension_fetch_.id);
     } else {
       FilePath crx_path;
       // Take ownership of the file at |crx_path|.
       CHECK(source->GetResponseAsFilePath(true, &crx_path));
-      RecordCrxWriteHistogram(true, crx_path);
+      RecordCRXWriteHistogram(true, crx_path);
       OnCRXFileWritten(current_extension_fetch_.id, crx_path, url);
     }
   } else {
     // TODO(asargent) do things like exponential backoff, handling
     // 503 Service Unavailable / Retry-After headers, etc. here.
     // (http://crbug.com/12546).
     VLOG(1) << "Failed to fetch extension '" << url.possibly_invalid_spec()
             << "' response code:" << response_code;
   }
   extension_fetcher_.reset();
   current_extension_fetch_ = ExtensionFetch();
 
   // If there are any pending downloads left, start the next one.
   if (!extensions_pending_.empty()) {
     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);
+
+  MaybeInstallCRXFile();
+}
+
+bool ExtensionUpdater::MaybeInstallCRXFile() {
+  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|.
+    CrxInstaller* installer = NULL;
+    if (service_->UpdateExtension(crx_file.id,
+                                  crx_file.path,
+                                  crx_file.download_url,
+                                  &installer)) {
+      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,
+                     Source<CrxInstaller>(installer));
+    }
+    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.
+  MaybeInstallCRXFile();
 }
 
 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);
 }