Extensions installed by policy overrun previously installed extensions.

chrome/browser/extensions/extension_service_unittest.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_service_unittest.h"
 
 #include <algorithm>
 #include <set>
 #include <vector>
 
@@ skipping 1211 matching lines @@
                                          path, Extension::EXTERNAL_PREF);
   loop_.RunAllPending();
   ASSERT_TRUE(NULL == service_->GetExtensionById(good_crx, false));
   ValidateIntegerPref(good_crx, "location",
                       Extension::EXTERNAL_EXTENSION_UNINSTALLED);
 
   // Try adding the same extension from an external update URL.
   service_->pending_extension_manager()->AddFromExternalUpdateUrl(
       good_crx,
       GURL("http:://fake.update/url"),
-      Extension::EXTERNAL_PREF_DOWNLOAD);
+      Extension::EXTERNAL_PREF_DOWNLOAD,
+      false);
 
   ASSERT_FALSE(service_->pending_extension_manager()->IsIdPending(good_crx));
 }
 
 // Test that uninstalling an external extension does not crash when
 // the extension could not be loaded.
 // This extension shown in preferences file requires an experimental permission.
 // It could not be loaded without such permission.
 TEST_F(ExtensionServiceTest, UninstallingNotLoadedExtension) {
   FilePath source_install_dir = data_dir_
@@ skipping 988 matching lines @@
 #define MAYBE_UpdatePendingExternalCrx FAILS_UpdatePendingExternalCrx
 #else
 #define MAYBE_UpdatePendingExternalCrx UpdatePendingExternalCrx
 #endif
 // Test updating a pending CRX as if the source is an external extension
 // with an update URL.  In this case we don't know if the CRX is a theme
 // or not.
 TEST_F(ExtensionServiceTest, MAYBE_UpdatePendingExternalCrx) {
   InitializeEmptyExtensionService();
   service_->pending_extension_manager()->AddFromExternalUpdateUrl(
-      theme_crx, GURL(), Extension::EXTERNAL_PREF_DOWNLOAD);
+      theme_crx, GURL(), Extension::EXTERNAL_PREF_DOWNLOAD, false);
 
   EXPECT_TRUE(service_->pending_extension_manager()->IsIdPending(theme_crx));
 
   FilePath path = data_dir_.AppendASCII("theme.crx");
   UpdateExtension(theme_crx, path, ENABLED);
 
   EXPECT_FALSE(service_->pending_extension_manager()->IsIdPending(theme_crx));
 
   const Extension* extension = service_->GetExtensionById(theme_crx, true);
   ASSERT_TRUE(extension);
@@ skipping 16 matching lines @@
       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());
 
   // Add a crx to be updated, with the same ID, from a non-sync source.
   service_->pending_extension_manager()->AddFromExternalUpdateUrl(
-      kGoodId, GURL(kGoodUpdateURL), Extension::EXTERNAL_PREF_DOWNLOAD);
+      kGoodId, GURL(kGoodUpdateURL), Extension::EXTERNAL_PREF_DOWNLOAD, false);
 
   // 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());
   EXPECT_EQ(Extension::EXTERNAL_PREF_DOWNLOAD,
             pending_extension_info.install_source());
 
   // Add a crx to be installed from the update mechanism.
   EXPECT_FALSE(service_->pending_extension_manager()->AddFromSync(
@@ skipping 1408 matching lines @@
   PendingExtensionInfo info;
   EXPECT_TRUE(
       service_->pending_extension_manager()->GetById(good_crx, &info));
   EXPECT_EQ(extension_sync_data.update_url, info.update_url());
   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, HigherPriorityInstall) {
+  InitializeEmptyExtensionService();
+
+  FilePath path = data_dir_.AppendASCII("good.crx");
+  InstallCrx(path, true);
+  ValidatePrefKeyCount(1u);
+  ValidateIntegerPref(good_crx, "state", Extension::ENABLED);
+  ValidateIntegerPref(good_crx, "location", Extension::INTERNAL);
+
+  PendingExtensionManager* pending = service_->pending_extension_manager();
+  EXPECT_FALSE(pending->IsIdPending(kGoodId));
+
+  // Skip install when the location is the same.
+  service_->OnExternalExtensionUpdateUrlFound(kGoodId, GURL(kGoodUpdateURL),
+      Extension::INTERNAL);
+  EXPECT_FALSE(pending->IsIdPending(kGoodId));
+  // Force install when the location has higher priority.
+  service_->OnExternalExtensionUpdateUrlFound(kGoodId, GURL(kGoodUpdateURL),
+      Extension::EXTERNAL_POLICY_DOWNLOAD);
+  EXPECT_TRUE(pending->IsIdPending(kGoodId));
+  pending->Remove(kGoodId);
+  // Skip install when the location has lower priority.
+  service_->OnExternalExtensionUpdateUrlFound(kGoodId, GURL(kGoodUpdateURL),
+      Extension::INTERNAL);
+  EXPECT_FALSE(pending->IsIdPending(kGoodId));
+}
+
 // Test that when multiple sources try to install an extension,
 // we consistently choose the right one. To make tests easy to read,
 // methods that fake requests to install crx files in several ways
 // are provided.
 class ExtensionSourcePriorityTest : public ExtensionServiceTest {
  public:
   void SetUp() {
     ExtensionServiceTest::SetUp();
 
     // All tests use a single extension.  Put the id and path in member vars
     // that all methods can read.
     crx_id_ = kGoodId;
     crx_path_ = data_dir_.AppendASCII("good.crx");
   }
 
   // Fake an external source adding a URL to fetch an extension from.
   void AddPendingExternalPrefUrl() {
     service_->pending_extension_manager()->AddFromExternalUpdateUrl(
-        crx_id_, GURL(), Extension::EXTERNAL_PREF_DOWNLOAD);
+        crx_id_, GURL(), Extension::EXTERNAL_PREF_DOWNLOAD, false);
   }
 
   // Fake an external file from external_extensions.json.
   void AddPendingExternalPrefFileInstall() {
     scoped_ptr<Version> version;
     version.reset(Version::GetVersionFromString("1.0.0.0"));
 
     service_->OnExternalExtensionFileFound(
         crx_id_, version.get(), crx_path_, Extension::EXTERNAL_PREF);
   }
@@ skipping 112 matching lines @@
   ASSERT_FALSE(AddPendingSyncInstall());
 
   // Wait for the external source to install.
   WaitForCrxInstall(crx_path_, true);
   ASSERT_TRUE(IsCrxInstalled());
 
   // Now that the extension is installed, sync request should fail
   // because the extension is already installed.
   ASSERT_FALSE(AddPendingSyncInstall());
 }