Apps on NTP should be in order of installation

chrome/browser/extensions/extension_service.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/extension_service.h"
 
 #include <algorithm>
 #include <set>
 
 #include "base/basictypes.h"
@@ skipping 535 matching lines @@
   }
 }
 
 bool ExtensionService::UpdateExtension(
     const std::string& id,
     const FilePath& extension_path,
     const GURL& download_url,
     CrxInstaller** out_crx_installer) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  PendingExtensionInfo pending_extension_info;
-  bool is_pending_extension = pending_extension_manager_.GetById(
-      id, &pending_extension_info);
+  const PendingExtensionInfo* pending_extension_info =
+      pending_extension_manager()->GetById(id);
 
   const Extension* extension =
       GetExtensionByIdInternal(id, true, true, false);
-  if (!is_pending_extension && !extension) {
+  if (!pending_extension_info && !extension) {
     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.
     if (!BrowserThread::PostTask(
             BrowserThread::FILE, FROM_HERE,
             base::Bind(
                 &extension_file_util::DeleteFile, extension_path, false)))
       NOTREACHED();
 
     return false;
   }
 
   // We want a silent install only for non-pending extensions and
   // pending extensions that have install_silently set.
   ExtensionInstallPrompt* client =
-      (!is_pending_extension || pending_extension_info.install_silently()) ?
+      (!pending_extension_info || pending_extension_info->install_silently()) ?
       NULL : new ExtensionInstallPrompt(profile_);
 
   scoped_refptr<CrxInstaller> installer(CrxInstaller::Create(this, client));
   installer->set_expected_id(id);
-  if (is_pending_extension)
-    installer->set_install_source(pending_extension_info.install_source());
-  else if (extension)
+  if (pending_extension_info) {
+    installer->set_install_source(pending_extension_info->install_source());
+    if (pending_extension_info->install_silently())
+      installer->set_allow_silent_install(true);
+  } else if (extension) {
     installer->set_install_source(extension->location());
-  if (pending_extension_info.install_silently())
-    installer->set_allow_silent_install(true);
+  }
   // If the extension was installed from or has migrated to the webstore, or
   // if the extension came from sync and its auto-update URL is from the
   // webstore, treat it as a webstore install. Note that we ignore some older
   // extensions with blank auto-update URLs because we are mostly concerned
   // with restrictions on NaCl extensions, which are newer.
   int creation_flags = Extension::NO_FLAGS;
   if ((extension && extension->from_webstore()) ||
       (extension && extension->UpdatesFromGallery()) ||
-      (!extension && pending_extension_info.is_from_sync() &&
+      (!extension && pending_extension_info->is_from_sync() &&
        extension_urls::IsWebstoreUpdateUrl(
-           pending_extension_info.update_url()))) {
+           pending_extension_info->update_url()))) {
     creation_flags |= Extension::FROM_WEBSTORE;
   }
 
   // Bookmark apps being updated is kind of a contradiction, but that's because
   // we mark the default apps as bookmark apps, and they're hosted in the web
   // store, thus they can get updated. See http://crbug.com/101605 for more
   // details.
   if (extension && extension->from_bookmark())
     creation_flags |= Extension::FROM_BOOKMARK;
 
@@ skipping 1480 matching lines @@
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Ensure extension is deleted unless we transfer ownership.
   scoped_refptr<const Extension> scoped_extension(extension);
   const std::string& id = extension->id();
   // Extensions installed by policy can't be disabled. So even if a previous
   // installation disabled the extension, make sure it is now enabled.
   bool initial_enable =
       !extension_prefs_->IsExtensionDisabled(id) ||
       system_->management_policy()->MustRemainEnabled(extension, NULL);
-  PendingExtensionInfo pending_extension_info;
-  if (pending_extension_manager()->GetById(id, &pending_extension_info)) {
-    pending_extension_manager()->Remove(id);
+  const PendingExtensionInfo* pending_extension_info = NULL;
+  if ((pending_extension_info = pending_extension_manager()->GetById(id))) {
+    if (!pending_extension_info->ShouldAllowInstall(*extension)) {
+      pending_extension_manager()->Remove(id);
 
-    if (!pending_extension_info.ShouldAllowInstall(*extension)) {
       LOG(WARNING)
           << "ShouldAllowInstall() returned false for "
           << id << " of type " << extension->GetType()
           << " and update URL " << extension->update_url().spec()
           << "; not installing";
 
       content::NotificationService::current()->Notify(
           chrome::NOTIFICATION_EXTENSION_INSTALL_NOT_ALLOWED,
           content::Source<Profile>(profile_),
           content::Details<const Extension>(extension));
 
       // Delete the extension directory since we're not going to
       // load it.
       if (!BrowserThread::PostTask(
               BrowserThread::FILE, FROM_HERE,
               base::Bind(&extension_file_util::DeleteFile,
                          extension->path(), true)))
         NOTREACHED();
       return;
     }
+
+    pending_extension_manager()->Remove(id);
   } else {
     // We explicitly want to re-enable an uninstalled external
     // extension; if we're here, that means the user is manually
     // installing the extension.
     if (IsExternalExtensionUninstalled(id)) {
       initial_enable = true;
     }
   }
 
   // Do not record the install histograms for upgrades.
@@ skipping 411 matching lines @@
 
   // To coexist with certain unit tests that don't have a work-thread message
   // loop available at ExtensionService shutdown, we lazy-initialize this
   // object so that those cases neither create nor destroy an
   // APIResourceController.
   if (!api_resource_controller_.get()) {
     api_resource_controller_.reset(new extensions::APIResourceController());
   }
   return api_resource_controller_.get();
 }