Apps on NTP should be in order of installation

chrome/browser/extensions/extension_service_unittest.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_unittest.h"
 
 #include <algorithm>
 #include <set>
 #include <vector>
 
@@ skipping 2479 matching lines @@
   InitializeEmptyExtensionService();
 
   const std::string kFakeId(all_zero);
   const GURL kFakeUpdateURL("http:://fake.update/url");
   const bool kFakeInstallSilently(true);
 
   EXPECT_TRUE(service_->pending_extension_manager()->AddFromSync(
       kFakeId, kFakeUpdateURL, &IsExtension,
       kFakeInstallSilently));
 
-  PendingExtensionInfo pending_extension_info;
-  ASSERT_TRUE(service_->pending_extension_manager()->GetById(
-      kFakeId, &pending_extension_info));
-  EXPECT_EQ(kFakeUpdateURL, pending_extension_info.update_url());
-  EXPECT_EQ(&IsExtension, pending_extension_info.should_allow_install_);
-  EXPECT_EQ(kFakeInstallSilently, pending_extension_info.install_silently());
+  const PendingExtensionInfo* pending_extension_info;
+  ASSERT_TRUE((pending_extension_info = service_->pending_extension_manager()->
+      GetById(kFakeId)));
+  EXPECT_EQ(kFakeUpdateURL, pending_extension_info->update_url());
+  EXPECT_EQ(&IsExtension, pending_extension_info->should_allow_install_);
+  EXPECT_EQ(kFakeInstallSilently, pending_extension_info->install_silently());
 }
 
 namespace {
 const char kGoodId[] = "ldnnhddmnhbkjipkidpdiheffobcpfmf";
 const char kGoodUpdateURL[] = "http://good.update/url";
 const bool kGoodIsFromSync = true;
 const bool kGoodInstallSilently = true;
 }  // namespace
 
 // Test updating a pending extension.
@@ skipping 77 matching lines @@
 // but a sync update should not overwrite a non-sync update.
 TEST_F(ExtensionServiceTest, UpdatePendingExternalCrxWinsOverSync) {
   InitializeEmptyExtensionService();
 
   // Add a crx to be installed from the update mechanism.
   EXPECT_TRUE(service_->pending_extension_manager()->AddFromSync(
       kGoodId, GURL(kGoodUpdateURL), &IsExtension,
       kGoodInstallSilently));
 
   // Check that there is a pending crx, with is_from_sync set to true.
-  PendingExtensionInfo pending_extension_info;
-  ASSERT_TRUE(service_->pending_extension_manager()->GetById(
-      kGoodId, &pending_extension_info));
-  EXPECT_TRUE(pending_extension_info.is_from_sync());
+  const PendingExtensionInfo* pending_extension_info;
+  ASSERT_TRUE((pending_extension_info = service_->pending_extension_manager()->
+      GetById(kGoodId)));
+  EXPECT_TRUE(pending_extension_info->is_from_sync());
 
   // Add a crx to be updated, with the same ID, from a non-sync source.
   EXPECT_TRUE(service_->pending_extension_manager()->AddFromExternalUpdateUrl(
       kGoodId, GURL(kGoodUpdateURL), Extension::EXTERNAL_PREF_DOWNLOAD));
 
   // Check that there is a pending crx, with is_from_sync set to false.
-  ASSERT_TRUE(service_->pending_extension_manager()->GetById(
-      kGoodId, &pending_extension_info));
-  EXPECT_FALSE(pending_extension_info.is_from_sync());
+  ASSERT_TRUE((pending_extension_info = service_->pending_extension_manager()->
+      GetById(kGoodId)));
+  EXPECT_FALSE(pending_extension_info->is_from_sync());
   EXPECT_EQ(Extension::EXTERNAL_PREF_DOWNLOAD,
-            pending_extension_info.install_source());
+            pending_extension_info->install_source());
 
   // Add a crx to be installed from the update mechanism.
   EXPECT_FALSE(service_->pending_extension_manager()->AddFromSync(
       kGoodId, GURL(kGoodUpdateURL), &IsExtension,
       kGoodInstallSilently));
 
   // Check that the external, non-sync update was not overridden.
-  ASSERT_TRUE(service_->pending_extension_manager()->GetById(
-      kGoodId, &pending_extension_info));
-  EXPECT_FALSE(pending_extension_info.is_from_sync());
+  ASSERT_TRUE((pending_extension_info = service_->pending_extension_manager()->
+      GetById(kGoodId)));
+  EXPECT_FALSE(pending_extension_info->is_from_sync());
   EXPECT_EQ(Extension::EXTERNAL_PREF_DOWNLOAD,
-            pending_extension_info.install_source());
+            pending_extension_info->install_source());
 }
 
 // Updating a theme should fail if the updater is explicitly told that
 // the CRX is not a theme.
 TEST_F(ExtensionServiceTest, UpdatePendingCrxThemeMismatch) {
   InitializeEmptyExtensionService();
   EXPECT_TRUE(service_->pending_extension_manager()->AddFromSync(
       theme_crx, GURL(), &IsExtension, true));
 
   EXPECT_TRUE(service_->pending_extension_manager()->IsIdPending(theme_crx));
@@ skipping 2063 matching lines @@
   list[0] = sync_change;
 
 
   EXPECT_TRUE(service_->IsExtensionEnabled(good_crx));
   EXPECT_FALSE(service_->IsIncognitoEnabled(good_crx));
   service_->ProcessSyncChanges(FROM_HERE, list);
   EXPECT_TRUE(service_->updater()->WillCheckSoon());
   EXPECT_FALSE(service_->IsExtensionEnabled(good_crx));
   EXPECT_TRUE(service_->IsIncognitoEnabled(good_crx));
 
-  PendingExtensionInfo info;
-  EXPECT_TRUE(
-      service_->pending_extension_manager()->GetById(good_crx, &info));
-  EXPECT_EQ(ext_specifics->update_url(), info.update_url().spec());
-  EXPECT_TRUE(info.is_from_sync());
-  EXPECT_TRUE(info.install_silently());
-  EXPECT_EQ(Extension::INTERNAL, info.install_source());
+  const PendingExtensionInfo* info;
+  EXPECT_TRUE((info = service_->pending_extension_manager()->
+      GetById(good_crx)));
+  EXPECT_EQ(ext_specifics->update_url(), info->update_url().spec());
+  EXPECT_TRUE(info->is_from_sync());
+  EXPECT_TRUE(info->install_silently());
+  EXPECT_EQ(Extension::INTERNAL, info->install_source());
   // TODO(akalin): Figure out a way to test |info.ShouldAllowInstall()|.
 }
 
 TEST_F(ExtensionServiceTest, InstallPriorityExternalUpdateUrl) {
   InitializeEmptyExtensionService();
 
   FilePath path = data_dir_.AppendASCII("good.crx");
   InstallCRX(path, INSTALL_NEW);
   ValidatePrefKeyCount(1u);
   ValidateIntegerPref(good_crx, "state", Extension::ENABLED);
@@ skipping 202 matching lines @@
   InitializeEmptyExtensionService();
 
   PendingExtensionManager* pending = service_->pending_extension_manager();
   EXPECT_FALSE(pending->IsIdPending(kGoodId));
 
   // An external provider starts installing from a local crx.
   EXPECT_TRUE(
       service_->OnExternalExtensionFileFound(
           kGoodId, &kVersion123, kInvalidPathToCrx,
           Extension::EXTERNAL_PREF, kCreationFlags, kDontMarkAcknowledged));
-  PendingExtensionInfo info;
-  EXPECT_TRUE(pending->GetById(kGoodId, &info));
-  EXPECT_TRUE(info.version().IsValid());
-  EXPECT_TRUE(info.version().Equals(kVersion123));
+  const PendingExtensionInfo* info;
+  EXPECT_TRUE((info = pending->GetById(kGoodId)));
+  EXPECT_TRUE(info->version().IsValid());
+  EXPECT_TRUE(info->version().Equals(kVersion123));
 
   // Adding a newer version overrides the currently pending version.
   EXPECT_TRUE(
       service_->OnExternalExtensionFileFound(
           kGoodId, &kVersion124, kInvalidPathToCrx,
           Extension::EXTERNAL_PREF, kCreationFlags, kDontMarkAcknowledged));
-  EXPECT_TRUE(pending->GetById(kGoodId, &info));
-  EXPECT_TRUE(info.version().IsValid());
-  EXPECT_TRUE(info.version().Equals(kVersion124));
+  EXPECT_TRUE((info = pending->GetById(kGoodId)));
+  EXPECT_TRUE(info->version().IsValid());
+  EXPECT_TRUE(info->version().Equals(kVersion124));
 
   // Adding an older version fails.
   EXPECT_FALSE(
       service_->OnExternalExtensionFileFound(
           kGoodId, &kVersion123, kInvalidPathToCrx,
           Extension::EXTERNAL_PREF, kCreationFlags, kDontMarkAcknowledged));
-  EXPECT_TRUE(pending->GetById(kGoodId, &info));
-  EXPECT_TRUE(info.version().IsValid());
-  EXPECT_TRUE(info.version().Equals(kVersion124));
+  EXPECT_TRUE((info = pending->GetById(kGoodId)));
+  EXPECT_TRUE(info->version().IsValid());
+  EXPECT_TRUE(info->version().Equals(kVersion124));
 
   // Adding an older version fails even when coming from a higher-priority
   // location.
   EXPECT_FALSE(
       service_->OnExternalExtensionFileFound(
           kGoodId, &kVersion123, kInvalidPathToCrx,
           Extension::EXTERNAL_REGISTRY, kCreationFlags, kDontMarkAcknowledged));
-  EXPECT_TRUE(pending->GetById(kGoodId, &info));
-  EXPECT_TRUE(info.version().IsValid());
-  EXPECT_TRUE(info.version().Equals(kVersion124));
+  EXPECT_TRUE((info = pending->GetById(kGoodId)));
+  EXPECT_TRUE(info->version().IsValid());
+  EXPECT_TRUE(info->version().Equals(kVersion124));
 
   // Adding the latest version from the webstore overrides a specific version.
   GURL kUpdateUrl("http://example.com/update");
   EXPECT_TRUE(
       service_->OnExternalExtensionUpdateUrlFound(
           kGoodId, kUpdateUrl, Extension::EXTERNAL_POLICY_DOWNLOAD));
-  EXPECT_TRUE(pending->GetById(kGoodId, &info));
-  EXPECT_FALSE(info.version().IsValid());
+  EXPECT_TRUE((info = pending->GetById(kGoodId)));
+  EXPECT_FALSE(info->version().IsValid());
 }
 
 // This makes sure we can package and install CRX files that use whitelisted
 // permissions.
 TEST_F(ExtensionServiceTest, InstallWhitelistedExtension) {
   std::string test_id = "hdkklepkcpckhnpgjnmbdfhehckloojk";
   CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       switches::kWhitelistedExtensionID, test_id);
 
   InitializeEmptyExtensionService();
@@ skipping 52 matching lines @@
     scoped_ptr<Version> version;
     version.reset(Version::GetVersionFromString("1.0.0.0"));
 
     // Get path to the CRX with id |kGoodId|.
     return service_->OnExternalExtensionUpdateUrlFound(
         crx_id_, GURL(), Extension::EXTERNAL_POLICY_DOWNLOAD);
   }
 
   // Get the install source of a pending extension.
   Extension::Location GetPendingLocation() {
-    PendingExtensionInfo info;
-    EXPECT_TRUE(service_->pending_extension_manager()->GetById(crx_id_, &info));
-    return info.install_source();
+    const PendingExtensionInfo* info;
+    EXPECT_TRUE((info = service_->pending_extension_manager()->
+        GetById(crx_id_)));
+    return info->install_source();
   }
 
   // Is an extension pending from a sync request?
   bool GetPendingIsFromSync() {
-    PendingExtensionInfo info;
-    EXPECT_TRUE(service_->pending_extension_manager()->GetById(crx_id_, &info));
-    return info.is_from_sync();
+    const PendingExtensionInfo* info;
+    EXPECT_TRUE((info = service_->pending_extension_manager()->
+        GetById(crx_id_)));
+    return info->is_from_sync();
   }
 
   // Is the CRX id these tests use pending?
   bool IsCrxPending() {
     return service_->pending_extension_manager()->IsIdPending(crx_id_);
   }
 
   // Is an extension installed?
   bool IsCrxInstalled() {
     return (service_->GetExtensionById(crx_id_, true) != NULL);
@@ skipping 110 matching lines @@
   provider->UpdateOrAddExtension(hosted_app, "1.0.0.0",
                                  data_dir_.AppendASCII("hosted_app.crx"));
 
   service_->CheckForExternalUpdates();
   loop_.RunAllPending();
 
   ASSERT_TRUE(service_->PopulateExtensionGlobalError(
       extension_global_error.get()));
   ASSERT_EQ(1u, extension_global_error->get_external_extension_ids()->size());
 }