extensions: Relocate pref name constants.

chrome/browser/extensions/api/management/management_browsertest.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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/ref_counted.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/stl_util.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/extension_browsertest.h"
 #include "chrome/browser/extensions/extension_host.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/extension_test_message_listener.h"
 #include "chrome/browser/extensions/external_policy_loader.h"
 #include "chrome/browser/extensions/updater/extension_downloader.h"
 #include "chrome/browser/extensions/updater/extension_updater.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/test/net/url_request_prepackaged_interceptor.h"
+#include "extensions/browser/pref_names.h"
 #include "net/url_request/url_fetcher.h"
 
 using extensions::Extension;
 using extensions::Manifest;
 
 class ExtensionManagementTest : public ExtensionBrowserTest {
  protected:
   // Helper method that returns whether the extension is at the given version.
   // This calls version(), which must be defined in the extension's bg page,
   // as well as asking the extension itself.
@@ skipping 450 matching lines @@
       GURL("http://localhost/autoupdate/manifest"),
       basedir.AppendASCII("manifest_v2.xml"));
   interceptor.SetResponseIgnoreQuery(GURL("http://localhost/autoupdate/v2.crx"),
                                      basedir.AppendASCII("v2.crx"));
 
   const size_t size_before = service->extensions()->size();
   ASSERT_TRUE(service->disabled_extensions()->is_empty());
 
   PrefService* prefs = browser()->profile()->GetPrefs();
   const base::DictionaryValue* forcelist =
-      prefs->GetDictionary(prefs::kExtensionInstallForceList);
+      prefs->GetDictionary(extensions::pref_names::kInstallForceList);
   ASSERT_TRUE(forcelist->empty()) << kForceInstallNotEmptyHelp;
 
   {
     // Set the policy as a user preference and fire notification observers.
-    DictionaryPrefUpdate pref_update(prefs, prefs::kExtensionInstallForceList);
+    DictionaryPrefUpdate pref_update(prefs,
+                                     extensions::pref_names::kInstallForceList);
     base::DictionaryValue* forcelist = pref_update.Get();
     extensions::ExternalPolicyLoader::AddExtension(
         forcelist, kExtensionId, "http://localhost/autoupdate/manifest");
   }
 
   // Check if the extension got installed.
   ASSERT_TRUE(WaitForExtensionInstall());
   ASSERT_EQ(size_before + 1, service->extensions()->size());
   const Extension* extension = service->GetExtensionById(kExtensionId, false);
   ASSERT_TRUE(extension);
@@ skipping 10 matching lines @@
 
   // Now try to disable it through the management api, again failing.
   ExtensionTestMessageListener listener1("ready", false);
   ASSERT_TRUE(LoadExtension(
       test_data_dir_.AppendASCII("management/uninstall_extension")));
   ASSERT_TRUE(listener1.WaitUntilSatisfied());
   EXPECT_EQ(size_before + 2, service->extensions()->size());
   EXPECT_EQ(0u, service->disabled_extensions()->size());
 
   // Check that emptying the list triggers uninstall.
-  prefs->ClearPref(prefs::kExtensionInstallForceList);
+  prefs->ClearPref(extensions::pref_names::kInstallForceList);
   EXPECT_EQ(size_before + 1, service->extensions()->size());
   EXPECT_FALSE(service->GetExtensionById(kExtensionId, true));
 }
 
 // See http://crbug.com/103371 and http://crbug.com/120640.
 #if defined(ADDRESS_SANITIZER) || defined(OS_WIN)
 #define MAYBE_PolicyOverridesUserInstall DISABLED_PolicyOverridesUserInstall
 #else
 #define MAYBE_PolicyOverridesUserInstall PolicyOverridesUserInstall
 #endif
@@ skipping 15 matching lines @@
 
   interceptor.SetResponseIgnoreQuery(
       GURL("http://localhost/autoupdate/manifest"),
       basedir.AppendASCII("manifest_v2.xml"));
   interceptor.SetResponseIgnoreQuery(GURL("http://localhost/autoupdate/v2.crx"),
                                      basedir.AppendASCII("v2.crx"));
 
   // Check that the policy is initially empty.
   PrefService* prefs = browser()->profile()->GetPrefs();
   const base::DictionaryValue* forcelist =
-      prefs->GetDictionary(prefs::kExtensionInstallForceList);
+      prefs->GetDictionary(extensions::pref_names::kInstallForceList);
   ASSERT_TRUE(forcelist->empty()) << kForceInstallNotEmptyHelp;
 
   // User install of the extension.
   ASSERT_TRUE(InstallExtension(basedir.AppendASCII("v2.crx"), 1));
   ASSERT_EQ(size_before + 1, service->extensions()->size());
   const Extension* extension = service->GetExtensionById(kExtensionId, false);
   ASSERT_TRUE(extension);
   EXPECT_EQ(Manifest::INTERNAL, extension->location());
   EXPECT_TRUE(service->IsExtensionEnabled(kExtensionId));
 
   // Setup the force install policy. It should override the location.
   {
-    DictionaryPrefUpdate pref_update(prefs, prefs::kExtensionInstallForceList);
+    DictionaryPrefUpdate pref_update(prefs,
+                                     extensions::pref_names::kInstallForceList);
     extensions::ExternalPolicyLoader::AddExtension(
         pref_update.Get(), kExtensionId,
         "http://localhost/autoupdate/manifest");
   }
   ASSERT_TRUE(WaitForExtensionInstall());
   ASSERT_EQ(size_before + 1, service->extensions()->size());
   extension = service->GetExtensionById(kExtensionId, false);
   ASSERT_TRUE(extension);
   EXPECT_EQ(Manifest::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.
-  prefs->ClearPref(prefs::kExtensionInstallForceList);
+  prefs->ClearPref(extensions::pref_names::kInstallForceList);
   ASSERT_EQ(size_before, service->extensions()->size());
   extension = service->GetExtensionById(kExtensionId, true);
   EXPECT_FALSE(extension);
 
   // User install again, but have it disabled too before setting the policy.
   ASSERT_TRUE(InstallExtension(basedir.AppendASCII("v2.crx"), 1));
   ASSERT_EQ(size_before + 1, service->extensions()->size());
   extension = service->GetExtensionById(kExtensionId, false);
   ASSERT_TRUE(extension);
   EXPECT_EQ(Manifest::INTERNAL, extension->location());
   EXPECT_TRUE(service->IsExtensionEnabled(kExtensionId));
   EXPECT_TRUE(service->disabled_extensions()->is_empty());
 
   DisableExtension(kExtensionId);
   EXPECT_EQ(1u, service->disabled_extensions()->size());
   extension = service->GetExtensionById(kExtensionId, true);
   EXPECT_TRUE(extension);
   EXPECT_FALSE(service->IsExtensionEnabled(kExtensionId));
 
   // Install the policy again. It should overwrite the extension's location,
   // and force enable it too.
   {
-    DictionaryPrefUpdate pref_update(prefs, prefs::kExtensionInstallForceList);
+    DictionaryPrefUpdate pref_update(prefs,
+                                     extensions::pref_names::kInstallForceList);
     base::DictionaryValue* forcelist = pref_update.Get();
     extensions::ExternalPolicyLoader::AddExtension(
         forcelist, kExtensionId, "http://localhost/autoupdate/manifest");
   }
   ASSERT_TRUE(WaitForExtensionInstall());
   ASSERT_EQ(size_before + 1, service->extensions()->size());
   extension = service->GetExtensionById(kExtensionId, false);
   ASSERT_TRUE(extension);
   EXPECT_EQ(Manifest::EXTERNAL_POLICY_DOWNLOAD, extension->location());
   EXPECT_TRUE(service->IsExtensionEnabled(kExtensionId));
   EXPECT_TRUE(service->disabled_extensions()->is_empty());
 }