Extensions installed by policy overrun previously installed extensions.

chrome/browser/extensions/extension_management_browsertest.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 "base/memory/ref_counted.h"
 #include "base/stl_util.h"
 #include "chrome/browser/extensions/autoupdate_interceptor.h"
 #include "chrome/browser/extensions/extension_browsertest.h"
 #include "chrome/browser/extensions/extension_host.h"
 #include "chrome/browser/extensions/extension_service.h"
@@ skipping 382 matching lines @@
   PendingExtensionManager* pending_extension_manager =
       service->pending_extension_manager();
 
   // The code that reads external_extensions.json uses this method to inform
   // the ExtensionService of an extension to download.  Using the real code
   // is race-prone, because instantating the ExtensionService starts a read
   // of external_extensions.json before this test function starts.
 
   pending_extension_manager->AddFromExternalUpdateUrl(
       kExtensionId, GURL("http://localhost/autoupdate/manifest"),
-      Extension::EXTERNAL_PREF_DOWNLOAD);
+      Extension::EXTERNAL_PREF_DOWNLOAD, false);
 
   // Run autoupdate and make sure version 2 of the extension was installed.
   service->updater()->CheckNow();
   ASSERT_TRUE(WaitForExtensionInstall());
   const ExtensionList* extensions = service->extensions();
   ASSERT_EQ(size_before + 1, extensions->size());
   ASSERT_EQ(kExtensionId, extensions->at(size_before)->id());
   ASSERT_EQ("2.0", extensions->at(size_before)->VersionString());
 
   // Uninstalling the extension should set a pref that keeps the extension from
   // being installed again the next time external_extensions.json is read.
 
   UninstallExtension(kExtensionId);
 
   ExtensionPrefs* extension_prefs = service->extension_prefs();
   EXPECT_TRUE(extension_prefs->IsExternalExtensionUninstalled(kExtensionId))
       << "Uninstalling should set kill bit on externaly installed extension.";
 
   // Try to install the extension again from an external source. It should fail
   // because of the killbit.
   pending_extension_manager->AddFromExternalUpdateUrl(
       kExtensionId, GURL("http://localhost/autoupdate/manifest"),
-      Extension::EXTERNAL_PREF_DOWNLOAD);
+      Extension::EXTERNAL_PREF_DOWNLOAD, false);
   EXPECT_FALSE(pending_extension_manager->IsIdPending(kExtensionId))
       << "External reinstall of a killed extension shouldn't work.";
   EXPECT_TRUE(extension_prefs->IsExternalExtensionUninstalled(kExtensionId))
       << "External reinstall of a killed extension should leave it killed.";
 
   // Installing from non-external source.
   ASSERT_TRUE(InstallExtension(basedir.AppendASCII("v2.crx"), 1));
 
   EXPECT_FALSE(extension_prefs->IsExternalExtensionUninstalled(kExtensionId))
       << "Reinstalling should clear the kill bit.";
 
   // Uninstalling from a non-external source should not set the kill bit.
   UninstallExtension(kExtensionId);
 
   EXPECT_FALSE(extension_prefs->IsExternalExtensionUninstalled(kExtensionId))
       << "Uninstalling non-external extension should not set kill bit.";
 }
 
+namespace {
+
+const char* kForceInstallNotEmptyHelp =
+    "A policy may already be controlling the list of force-installed "
+    "extensions. Please remove all policy settings from your computer "
+    "before running tests. E.g. from /etc/chromium/policies Linux or "
+    "from the registry on Windows, etc.";
+
+}
+
 // See http://crbug.com/57378 for flakiness details.
 IN_PROC_BROWSER_TEST_F(ExtensionManagementTest, ExternalPolicyRefresh) {
   ExtensionService* service = browser()->profile()->GetExtensionService();
   const char* kExtensionId = "ogjcoiohnmldgjemafoockdghcjciccf";
   // We don't want autoupdate blacklist checks.
   service->updater()->set_blacklist_checks_enabled(false);
 
   FilePath basedir = test_data_dir_.AppendASCII("autoupdate");
 
   // Note: This interceptor gets requests on the IO thread.
   scoped_refptr<AutoUpdateInterceptor> interceptor(new AutoUpdateInterceptor());
   URLFetcher::enable_interception_for_tests(true);
 
   interceptor->SetResponseOnIOThread("http://localhost/autoupdate/manifest",
                                      basedir.AppendASCII("manifest_v2.xml"));
   interceptor->SetResponseOnIOThread("http://localhost/autoupdate/v2.crx",
                                      basedir.AppendASCII("v2.crx"));
 
   const size_t size_before = service->extensions()->size();
   ASSERT_TRUE(service->disabled_extensions()->empty());
 
   PrefService* prefs = browser()->profile()->GetPrefs();
   const ListValue* forcelist =
       prefs->GetList(prefs::kExtensionInstallForceList);
-  ASSERT_TRUE(forcelist->empty())
-      << "A policy may already be controlling the list of force-installed "
-      << "extensions. Please remove all policy settings from your computer "
-      << "before running tests. E.g. from /etc/chromium/policies Linux or "
-      << "from the registry on Windows, etc.";
+  ASSERT_TRUE(forcelist->empty()) << kForceInstallNotEmptyHelp;
 
   {
     // Set the policy as a user preference and fire notification observers.
     ListPrefUpdate pref_update(prefs, prefs::kExtensionInstallForceList);
     ListValue* forcelist = pref_update.Get();
     ASSERT_TRUE(forcelist->empty());
     forcelist->Append(Value::CreateStringValue(
         std::string(kExtensionId) +
         ";http://localhost/autoupdate/manifest"));
   }
@@ skipping 25 matching lines @@
 
   // Check that emptying the list triggers uninstall.
   {
     prefs->ClearPref(prefs::kExtensionInstallForceList);
   }
   EXPECT_EQ(size_before + 1, extensions->size());
   ExtensionList::const_iterator i;
   for (i = extensions->begin(); i != extensions->end(); ++i)
     EXPECT_NE(kExtensionId, (*i)->id());
 }
+
+IN_PROC_BROWSER_TEST_F(ExtensionManagementTest, PolicyOverridesUserInstall) {
+  ExtensionService* service = browser()->profile()->GetExtensionService();
+  const char* kExtensionId = "ogjcoiohnmldgjemafoockdghcjciccf";
+  service->updater()->set_blacklist_checks_enabled(false);
+  const size_t size_before = service->extensions()->size();
+  FilePath basedir = test_data_dir_.AppendASCII("autoupdate");
+  ASSERT_TRUE(service->disabled_extensions()->empty());
+
+  // Note: This interceptor gets requests on the IO thread.
+  scoped_refptr<AutoUpdateInterceptor> interceptor(new AutoUpdateInterceptor());
+  URLFetcher::enable_interception_for_tests(true);
+
+  interceptor->SetResponseOnIOThread("http://localhost/autoupdate/manifest",
+                                     basedir.AppendASCII("manifest_v2.xml"));
+  interceptor->SetResponseOnIOThread("http://localhost/autoupdate/v2.crx",
+                                     basedir.AppendASCII("v2.crx"));
+
+  // Check that the policy is initially empty.
+  PrefService* prefs = browser()->profile()->GetPrefs();
+  const ListValue* forcelist =
+      prefs->GetList(prefs::kExtensionInstallForceList);
+  ASSERT_TRUE(forcelist->empty()) << kForceInstallNotEmptyHelp;
+
+  // User install of the extension.
+  ASSERT_TRUE(InstallExtension(basedir.AppendASCII("v2.crx"), 1));
+  const ExtensionList* extensions = service->extensions();
+  ASSERT_EQ(size_before + 1, extensions->size());
+  const Extension* extension = extensions->at(size_before);
+  ASSERT_EQ(kExtensionId, extension->id());
+  EXPECT_EQ(Extension::INTERNAL, extension->location());
+  EXPECT_TRUE(service->IsExtensionEnabled(kExtensionId));
+
+  // Setup the force install policy. It should override the location.
+  {
+    ListPrefUpdate pref_update(prefs, prefs::kExtensionInstallForceList);
+    ListValue* forcelist = pref_update.Get();
+    ASSERT_TRUE(forcelist->empty());
+    forcelist->Append(Value::CreateStringValue(
+        std::string(kExtensionId) + ";http://localhost/autoupdate/manifest"));
+  }
+  ASSERT_TRUE(WaitForExtensionInstall());
+  extensions = service->extensions();
+  ASSERT_EQ(size_before + 1, extensions->size());
+  extension = extensions->at(size_before);
+  ASSERT_EQ(kExtensionId, extension->id());
+  EXPECT_EQ(Extension::EXTERNAL_POLICY_DOWNLOAD, extension->location());
+  EXPECT_TRUE(service->IsExtensionEnabled(kExtensionId));
+
+  // Remove the policy, and verify that the extension was uninstalled.
+  // TODO(joaodasilva): it would be nicer if the extension was kept instead,
+  // and reverted location to INTERNAL or whatever it was before the policy
+  // was applied.
+  {
+    ListPrefUpdate pref_update(prefs, prefs::kExtensionInstallForceList);
+    ListValue* forcelist = pref_update.Get();
+    ASSERT_TRUE(!forcelist->empty());
+    forcelist->Clear();
+  }
+  extensions = service->extensions();
+  ASSERT_EQ(size_before, extensions->size());
+  extension = service->GetExtensionById(kExtensionId, true);
+  EXPECT_TRUE(extension == NULL);
+
+  // User install again, but have it disabled too before setting the policy.
+  ASSERT_TRUE(InstallExtension(basedir.AppendASCII("v2.crx"), 1));
+  extensions = service->extensions();
+  ASSERT_EQ(size_before + 1, extensions->size());
+  extension = extensions->at(size_before);
+  ASSERT_EQ(kExtensionId, extension->id());
+  EXPECT_EQ(Extension::INTERNAL, extension->location());
+  EXPECT_TRUE(service->IsExtensionEnabled(kExtensionId));
+  EXPECT_TRUE(service->disabled_extensions()->empty());
+
+  service->DisableExtension(kExtensionId);
+  EXPECT_EQ(1u, service->disabled_extensions()->size());
+  EXPECT_EQ(kExtensionId, service->disabled_extensions()->at(0)->id());
+  EXPECT_FALSE(service->IsExtensionEnabled(kExtensionId));
+
+  // Install the policy again. It should overwrite the extension's location,
+  // and force enable it too.
+  {
+    ListPrefUpdate pref_update(prefs, prefs::kExtensionInstallForceList);
+    ListValue* forcelist = pref_update.Get();
+    ASSERT_TRUE(forcelist->empty());
+    forcelist->Append(Value::CreateStringValue(
+        std::string(kExtensionId) + ";http://localhost/autoupdate/manifest"));
+  }
+  ASSERT_TRUE(WaitForExtensionInstall());
+  extensions = service->extensions();
+  ASSERT_EQ(size_before + 1, extensions->size());
+  extension = extensions->at(size_before);
+  ASSERT_EQ(kExtensionId, extension->id());
+  EXPECT_EQ(Extension::EXTERNAL_POLICY_DOWNLOAD, extension->location());
+  EXPECT_TRUE(service->IsExtensionEnabled(kExtensionId));
+  EXPECT_TRUE(service->disabled_extensions()->empty());
+}