Apps on NTP should be in order of installation

chrome/browser/extensions/updater/extension_updater.cc

 // Copyright (c) 2012 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/updater/extension_updater.h"
 
 #include <algorithm>
 #include <set>
 #include <vector>
 
@@ skipping 245 matching lines @@
   return will_check_soon_;
 }
 
 void ExtensionUpdater::DoCheckSoon() {
   DCHECK(will_check_soon_);
   CheckNow();
   will_check_soon_ = false;
 }
 
 void ExtensionUpdater::AddToDownloader(const ExtensionSet* extensions,
-    const std::set<std::string>& pending_ids) {
-  for (ExtensionSet::const_iterator iter = extensions->begin();
-       iter != extensions->end(); ++iter) {
-    const Extension& extension = **iter;
+    const std::list<std::string>& pending_ids) {
+  for (ExtensionSet::const_iterator extension_iter = extensions->begin();
+       extension_iter != extensions->end(); ++extension_iter) {
+    const Extension& extension = **extension_iter;
     if (!Extension::IsAutoUpdateableLocation(extension.location())) {
       VLOG(2) << "Extension " << extension.id() << " is not auto updateable";
       continue;
     }
     // An extension might be overwritten by policy, and have its update url
     // changed. Make sure existing extensions aren't fetched again, if a
     // pending fetch for an extension with the same id already exists.
-    if (!ContainsKey(pending_ids, extension.id())) {
+    std::list<std::string>::const_iterator pending_id_iter = std::find(
+        pending_ids.begin(),

[Aaron Boodman, 2012/05/01 15:50:22]

Nit: no need to wrap so vigorously. These can go on the same line when they fit.

[mitchellwrosen, 2012/05/11 05:45:03]

Done.

+        pending_ids.end(),
+        extension.id());
+    if (pending_id_iter == pending_ids.end()) {
       if (downloader_->AddExtension(extension))
-        in_progress_ids_.insert(extension.id());
+        in_progress_ids_.push_back(extension.id());
     }
   }
 }
 
 void ExtensionUpdater::CheckNow() {
   VLOG(2) << "Starting update check";
   DCHECK(alive_);
   NotifyStarted();
 
   if (!downloader_.get()) {
     downloader_.reset(
         new ExtensionDownloader(this, profile_->GetRequestContext()));
   }
 
   // Add fetch records for extensions that should be fetched by an update URL.
   // These extensions are not yet installed. They come from group policy
   // and external install sources.
   const PendingExtensionManager* pending_extension_manager =
       service_->pending_extension_manager();
 
-  std::set<std::string> pending_ids;
+  std::list<std::string> pending_ids;
   pending_extension_manager->GetPendingIdsForUpdateCheck(&pending_ids);
 
-  std::set<std::string>::const_iterator iter;
+  std::list<std::string>::const_iterator iter;
   for (iter = pending_ids.begin(); iter != pending_ids.end(); ++iter) {
-    PendingExtensionInfo info;
-    bool found_id = pending_extension_manager->GetById(*iter, &info);
-    DCHECK(found_id);
-    if (!found_id)
-      continue;
-    if (!Extension::IsAutoUpdateableLocation(info.install_source())) {
+    const PendingExtensionInfo* info = pending_extension_manager->GetById(
+        *iter);
+    if (!Extension::IsAutoUpdateableLocation(info->install_source())) {
       VLOG(2) << "Extension " << *iter << " is not auto updateable";
       continue;
     }
-    if (downloader_->AddPendingExtension(*iter, info.update_url()))
-      in_progress_ids_.insert(*iter);
+    if (downloader_->AddPendingExtension(*iter, info->update_url()))
+      in_progress_ids_.push_back(*iter);
   }
 
   AddToDownloader(service_->extensions(), pending_ids);
   AddToDownloader(service_->disabled_extensions(), pending_ids);
 
   // Start a fetch of the blacklist if needed.
   if (blacklist_checks_enabled_) {
     ManifestFetchData::PingData ping_data;
     ping_data.rollcall_days =
         CalculatePingDays(extension_prefs_->BlacklistLastPingDay());
     downloader_->StartBlacklistUpdate(
         prefs_->GetString(kExtensionBlacklistUpdateVersion), ping_data);
   }
 
   // StartAllPending() will call OnExtensionUpdateCheckStarted() for each
   // extension that is going to be checked.
   downloader_->StartAllPending();
 
   NotifyIfFinished();
 }
 
 void ExtensionUpdater::OnExtensionDownloadFailed(const std::string& id,
                                                  Error error,
                                                  const PingResult& ping) {
   DCHECK(alive_);
   UpdatePingData(id, ping);
-  in_progress_ids_.erase(id);
+  in_progress_ids_.remove(id);
   NotifyIfFinished();
 }
 
 void ExtensionUpdater::OnExtensionDownloadFinished(const std::string& id,
                                                    const FilePath& path,
                                                    const GURL& download_url,
                                                    const std::string& version,
                                                    const PingResult& ping) {
   DCHECK(alive_);
   UpdatePingData(id, ping);
 
   VLOG(2) << download_url << " written to " << path.value();
 
   FetchedCRXFile fetched(id, path, download_url);
   fetched_crx_files_.push(fetched);
 
   // MaybeInstallCRXFile() removes extensions from |in_progress_ids_| after
   // starting the crx installer.
   MaybeInstallCRXFile();
 }
 
 void ExtensionUpdater::OnBlacklistDownloadFinished(
     const std::string& data,
     const std::string& package_hash,
     const std::string& version,
     const PingResult& ping) {
   DCHECK(alive_);
   UpdatePingData(ExtensionDownloader::kBlacklistAppID, ping);
-  in_progress_ids_.erase(ExtensionDownloader::kBlacklistAppID);
+  in_progress_ids_.remove(ExtensionDownloader::kBlacklistAppID);
   NotifyIfFinished();
 
   // Verify sha256 hash value.
   char sha256_hash_value[crypto::kSHA256Length];
   crypto::SHA256HashString(data, sha256_hash_value, crypto::kSHA256Length);
   std::string hash_in_hex = base::HexEncode(sha256_hash_value,
                                             crypto::kSHA256Length);
 
   if (package_hash != hash_in_hex) {
     NOTREACHED() << "Fetched blacklist checksum is not as expected. "
@@ skipping 79 matching lines @@
                                   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,
                      chrome::NOTIFICATION_CRX_INSTALLER_DONE,
                      content::Source<CrxInstaller>(installer));
     }
-    in_progress_ids_.erase(crx_file.id);
+    in_progress_ids_.remove(crx_file.id);
     fetched_crx_files_.pop();
   }
 
   NotifyIfFinished();
 }
 
 void ExtensionUpdater::Observe(int type,
                                const content::NotificationSource& source,
                                const content::NotificationDetails& details) {
   DCHECK(type == chrome::NOTIFICATION_CRX_INSTALLER_DONE);
@@ skipping 18 matching lines @@
   if (in_progress_ids_.empty()) {
     VLOG(1) << "Sending EXTENSION_UPDATING_FINISHED";
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_EXTENSION_UPDATING_FINISHED,
         content::Source<Profile>(profile_),
         content::NotificationService::NoDetails());
   }
 }
 
 }  // namespace extensions