Remove ExtensionService::extension_prefs()

chrome/browser/extensions/extension_service_unittest.cc

 // Copyright (c) 2013 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 586 matching lines @@
 
 void ExtensionServiceTestBase::InitializeExtensionServiceWithUpdater() {
   ExtensionServiceInitParams params = CreateDefaultInitParams();
   params.autoupdate_enabled = true;
   InitializeExtensionService(params);
   service_->updater()->Start();
 }
 
 void ExtensionServiceTestBase::InitializeExtensionSyncService() {
   extension_sync_service_.reset(new ExtensionSyncService(
-      profile_.get(), service_->extension_prefs(), service_));
+      profile_.get(), ExtensionPrefs::Get(profile_.get()), service_));
 }
 
 // static
 void ExtensionServiceTestBase::SetUpTestCase() {
   ExtensionErrorReporter::Init(false);  // no noisy errors
 }
 
 void ExtensionServiceTestBase::SetUp() {
   ExtensionErrorReporter::GetInstance()->ClearErrors();
 }
@@ skipping 940 matching lines @@
   EXPECT_FALSE(base::PathExists(extensions_install_dir_.AppendASCII(
       "bjafgdebaacbbbecmhlhpofkepfkgcpa/1.0")));
   EXPECT_TRUE(base::PathExists(extensions_install_dir_.AppendASCII(
       "bjafgdebaacbbbecmhlhpofkepfkgcpa/2.0")));
   EXPECT_TRUE(base::PathExists(extensions_install_dir_.AppendASCII(
       "hpiknbiabeeppbpihjehijgoemciehgk/2")));
   EXPECT_FALSE(base::PathExists(extensions_install_dir_.AppendASCII(
       "hpiknbiabeeppbpihjehijgoemciehgk/3")));
 
   // Make sure update information got deleted.
-  ExtensionPrefs* prefs = service_->extension_prefs();
+  ExtensionPrefs* prefs = ExtensionPrefs::Get(profile_.get());
   EXPECT_FALSE(
       prefs->GetDelayedInstallInfo("bjafgdebaacbbbecmhlhpofkepfkgcpa"));
 }
 
 // Test various cases for delayed install because of missing imports.
 TEST_F(ExtensionServiceTest, PendingImports) {
   InitPluginService();
 
   base::FilePath source_install_dir = data_dir_
       .AppendASCII("pending_updates_with_imports")
@@ skipping 12 matching lines @@
 
   // These extensions are used by the extensions we test below, they must be
   // installed.
   EXPECT_TRUE(base::PathExists(extensions_install_dir_.AppendASCII(
       "bjafgdebaacbbbecmhlhpofkepfkgcpa/1.0")));
   EXPECT_TRUE(base::PathExists(extensions_install_dir_.AppendASCII(
       "hpiknbiabeeppbpihjehijgoemciehgk/2")));
 
   // Each of these extensions should have been rejected because of dependencies
   // that cannot be satisfied.
-  ExtensionPrefs* prefs = service_->extension_prefs();
+  ExtensionPrefs* prefs = ExtensionPrefs::Get(profile_.get());
   EXPECT_FALSE(
       prefs->GetDelayedInstallInfo("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"));
   EXPECT_FALSE(
       prefs->GetInstalledExtensionInfo("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"));
   EXPECT_FALSE(
       prefs->GetDelayedInstallInfo("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"));
   EXPECT_FALSE(
       prefs->GetInstalledExtensionInfo("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"));
   EXPECT_FALSE(
       prefs->GetDelayedInstallInfo("cccccccccccccccccccccccccccccccc"));
@@ skipping 397 matching lines @@
   InitializeEmptyExtensionService();
   base::FilePath path = data_dir_
       .AppendASCII("permissions");
 
   base::FilePath pem_path = path.AppendASCII("unknown.pem");
   path = path.AppendASCII("unknown");
 
   ASSERT_TRUE(base::PathExists(pem_path));
   ASSERT_TRUE(base::PathExists(path));
 
-  ExtensionPrefs* prefs = service_->extension_prefs();
+  ExtensionPrefs* prefs = ExtensionPrefs::Get(profile_.get());
 
   APIPermissionSet expected_api_perms;
   URLPatternSet expected_host_perms;
 
   // Make sure there aren't any granted permissions before the
   // extension is installed.
   scoped_refptr<PermissionSet> known_perms(
       prefs->GetGrantedPermissions(permissions_crx));
   EXPECT_FALSE(known_perms.get());
 
@@ skipping 27 matching lines @@
   InitializeEmptyExtensionService();
   base::FilePath path = data_dir_
       .AppendASCII("permissions");
 
   base::FilePath pem_path = path.AppendASCII("unknown.pem");
   path = path.AppendASCII("unknown");
 
   ASSERT_TRUE(base::PathExists(pem_path));
   ASSERT_TRUE(base::PathExists(path));
 
-  ExtensionPrefs* prefs = service_->extension_prefs();
+  ExtensionPrefs* prefs = ExtensionPrefs::Get(profile_.get());
 
   APIPermissionSet expected_api_perms;
   URLPatternSet expected_host_perms;
 
   // Make sure there aren't any granted permissions before the
   // extension is installed.
   scoped_refptr<PermissionSet> known_perms(
       prefs->GetGrantedPermissions(permissions_crx));
   EXPECT_FALSE(known_perms.get());
 
@@ skipping 21 matching lines @@
 // since they don't support plugins.
 TEST_F(ExtensionServiceTest, GrantedFullAccessPermissions) {
   InitPluginService();
 
   InitializeEmptyExtensionService();
 
   ASSERT_TRUE(base::PathExists(good1_path()));
   const Extension* extension = PackAndInstallCRX(good1_path(), INSTALL_NEW);
   EXPECT_EQ(0u, GetErrors().size());
   EXPECT_EQ(1u, registry_->enabled_extensions().size());
-  ExtensionPrefs* prefs = service_->extension_prefs();
+  ExtensionPrefs* prefs = ExtensionPrefs::Get(profile_.get());
 
   scoped_refptr<PermissionSet> permissions(
       prefs->GetGrantedPermissions(extension->id()));
   EXPECT_FALSE(permissions->IsEmpty());
   EXPECT_TRUE(permissions->HasEffectiveFullAccess());
   EXPECT_FALSE(permissions->apis().empty());
   EXPECT_TRUE(permissions->HasAPIPermission(APIPermission::kPlugin));
 
   // Full access implies full host access too...
   EXPECT_TRUE(permissions->HasEffectiveAccessToAllHosts());
@@ skipping 11 matching lines @@
       .AppendASCII("unknown");
 
   ASSERT_TRUE(base::PathExists(path));
 
   const Extension* extension = PackAndInstallCRX(path, INSTALL_NEW);
 
   EXPECT_EQ(0u, GetErrors().size());
   EXPECT_EQ(1u, registry_->enabled_extensions().size());
   std::string extension_id = extension->id();
 
-  ExtensionPrefs* prefs = service_->extension_prefs();
+  ExtensionPrefs* prefs = ExtensionPrefs::Get(profile_.get());
 
   APIPermissionSet expected_api_permissions;
   URLPatternSet expected_host_permissions;
 
   expected_api_permissions.insert(APIPermission::kTab);
   AddPattern(&expected_host_permissions, "http://*.google.com/*");
   AddPattern(&expected_host_permissions, "https://*.google.com/*");
   AddPattern(&expected_host_permissions, "http://*.google.com.hk/*");
   AddPattern(&expected_host_permissions, "http://www.example.com/*");
 
@@ skipping 475 matching lines @@
 // Tests that file access is OFF by default.
 TEST_F(ExtensionServiceTest, DefaultFileAccess) {
   InitializeEmptyExtensionService();
   const Extension* extension =
       PackAndInstallCRX(data_dir_
                         .AppendASCII("permissions")
                         .AppendASCII("files"),
                         INSTALL_NEW);
   EXPECT_EQ(0u, GetErrors().size());
   EXPECT_EQ(1u, registry_->enabled_extensions().size());
-  EXPECT_FALSE(service_->extension_prefs()->AllowFileAccess(extension->id()));
+  EXPECT_FALSE(
+      ExtensionPrefs::Get(profile_.get())->AllowFileAccess(extension->id()));
 }
 
 TEST_F(ExtensionServiceTest, UpdateApps) {
   InitializeEmptyExtensionService();
   base::FilePath extensions_path = data_dir_.AppendASCII("app_update");
 
   // First install v1 of a hosted app.
   const Extension* extension =
       InstallCRX(extensions_path.AppendASCII("v1.crx"), INSTALL_NEW);
   ASSERT_EQ(1u, registry_->enabled_extensions().size());
   std::string id = extension->id();
   ASSERT_EQ(std::string("1"), extension->version()->GetString());
 
   // Now try updating to v2.
   UpdateExtension(id,
                   extensions_path.AppendASCII("v2.crx"),
                   ENABLED);
   ASSERT_EQ(std::string("2"),
             service_->GetExtensionById(id, false)->version()->GetString());
 }
 
 // Verifies that the NTP page and launch ordinals are kept when updating apps.
 TEST_F(ExtensionServiceTest, UpdateAppsRetainOrdinals) {
   InitializeEmptyExtensionService();
-  AppSorting* sorting = service_->extension_prefs()->app_sorting();
+  AppSorting* sorting = ExtensionPrefs::Get(profile_.get())->app_sorting();
   base::FilePath extensions_path = data_dir_.AppendASCII("app_update");
 
   // First install v1 of a hosted app.
   const Extension* extension =
       InstallCRX(extensions_path.AppendASCII("v1.crx"), INSTALL_NEW);
   ASSERT_EQ(1u, registry_->enabled_extensions().size());
   std::string id = extension->id();
   ASSERT_EQ(std::string("1"), extension->version()->GetString());
 
   // Modify the ordinals so we can distinguish them from the defaults.
@@ skipping 15 matching lines @@
   ASSERT_TRUE(new_launch_ordinal.Equals(sorting->GetAppLaunchOrdinal(id)));
 }
 
 // Ensures that the CWS has properly initialized ordinals.
 TEST_F(ExtensionServiceTest, EnsureCWSOrdinalsInitialized) {
   InitializeEmptyExtensionService();
   service_->component_loader()->Add(
       IDR_WEBSTORE_MANIFEST, base::FilePath(FILE_PATH_LITERAL("web_store")));
   service_->Init();
 
-  AppSorting* sorting = service_->extension_prefs()->app_sorting();
+  AppSorting* sorting = ExtensionPrefs::Get(profile_.get())->app_sorting();
   EXPECT_TRUE(
       sorting->GetPageOrdinal(extension_misc::kWebStoreAppId).IsValid());
   EXPECT_TRUE(
       sorting->GetAppLaunchOrdinal(extension_misc::kWebStoreAppId).IsValid());
 }
 
 TEST_F(ExtensionServiceTest, InstallAppsWithUnlimitedStorage) {
   InitializeEmptyExtensionService();
   EXPECT_TRUE(registry_->enabled_extensions().is_empty());
 
@@ skipping 259 matching lines @@
   base::FilePath path = data_dir_.AppendASCII("good.crx");
 
   const Extension* good = InstallCRX(path, INSTALL_NEW);
   ASSERT_EQ("1.0.0.0", good->VersionString());
   ASSERT_EQ(good_crx, good->id());
 
   // Disable it and allow it to run in incognito. These settings should carry
   // over to the updated version.
   service_->DisableExtension(good->id(), Extension::DISABLE_USER_ACTION);
   extensions::util::SetIsIncognitoEnabled(good->id(), profile_.get(), true);
-  service_->extension_prefs()->SetDidExtensionEscalatePermissions(good, true);
+  ExtensionPrefs::Get(profile_.get())
+      ->SetDidExtensionEscalatePermissions(good, true);
 
   path = data_dir_.AppendASCII("good2.crx");
   UpdateExtension(good_crx, path, INSTALLED);
   ASSERT_EQ(1u, registry_->disabled_extensions().size());
   const Extension* good2 = service_->GetExtensionById(good_crx, true);
   ASSERT_EQ("1.0.0.1", good2->version()->GetString());
   EXPECT_TRUE(extensions::util::IsIncognitoEnabled(
       good2->id(), profile_.get()));
-  EXPECT_TRUE(service_->extension_prefs()->DidExtensionEscalatePermissions(
-      good2->id()));
+  EXPECT_TRUE(ExtensionPrefs::Get(profile_.get())
+                  ->DidExtensionEscalatePermissions(good2->id()));
 }
 
 // Tests that updating preserves extension location.
 TEST_F(ExtensionServiceTest, UpdateExtensionPreservesLocation) {
   InitializeEmptyExtensionService();
 
   base::FilePath path = data_dir_.AppendASCII("good.crx");
 
   const Extension* good =
       InstallCRXWithLocation(path, Manifest::EXTERNAL_PREF, INSTALL_NEW);
@@ skipping 102 matching lines @@
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(0u, GetErrors().size());
   EXPECT_EQ(2u, loaded_.size());
   EXPECT_EQ(2u, registry_->enabled_extensions().size());
   EXPECT_EQ(0u, registry_->disabled_extensions().size());
   EXPECT_TRUE(registry_->enabled_extensions().Contains(good1));
   EXPECT_TRUE(registry_->enabled_extensions().Contains(good2));
 
   // Make sure the granted permissions have been setup.
   scoped_refptr<PermissionSet> permissions(
-      service_->extension_prefs()->GetGrantedPermissions(good1));
+      ExtensionPrefs::Get(profile_.get())->GetGrantedPermissions(good1));
   EXPECT_FALSE(permissions->IsEmpty());
   EXPECT_TRUE(permissions->HasEffectiveFullAccess());
   EXPECT_FALSE(permissions->apis().empty());
   EXPECT_TRUE(permissions->HasAPIPermission(APIPermission::kPlugin));
 
   // We should be able to reload the extension without getting another prompt.
   loaded_.clear();
   CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       switches::kAppsGalleryInstallAutoConfirmForTests,
       "cancel");
@@ skipping 75 matching lines @@
   EXPECT_TRUE(service_->pending_extension_manager()->IsIdPending(theme_crx));
 
   base::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);
 
-  EXPECT_FALSE(
-      service_->extension_prefs()->IsExtensionDisabled(extension->id()));
+  EXPECT_FALSE(ExtensionPrefs::Get(profile_.get())
+                   ->IsExtensionDisabled(extension->id()));
   EXPECT_TRUE(service_->IsExtensionEnabled(theme_crx));
 }
 
 #if defined(OS_CHROMEOS)
 // Always fails on ChromeOS: http://crbug.com/79737
 #define MAYBE_UpdatePendingExternalCrx DISABLED_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();
   EXPECT_TRUE(service_->pending_extension_manager()->AddFromExternalUpdateUrl(
       theme_crx, GURL(), Manifest::EXTERNAL_PREF_DOWNLOAD, Extension::NO_FLAGS,
       false));
 
   EXPECT_TRUE(service_->pending_extension_manager()->IsIdPending(theme_crx));
 
   base::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);
 
-  EXPECT_FALSE(
-      service_->extension_prefs()->IsExtensionDisabled(extension->id()));
+  EXPECT_FALSE(ExtensionPrefs::Get(profile_.get())
+                   ->IsExtensionDisabled(extension->id()));
   EXPECT_TRUE(service_->IsExtensionEnabled(extension->id()));
   EXPECT_FALSE(extensions::util::IsIncognitoEnabled(extension->id(),
                                                     profile_.get()));
 }
 
 // Test updating a pending CRX as if the source is an external extension
 // with an update URL.  The external update should overwrite a sync update,
 // but a sync update should not overwrite a non-sync update.
 TEST_F(ExtensionServiceTest, UpdatePendingExternalCrxWinsOverSync) {
   InitializeEmptyExtensionService();
@@ skipping 213 matching lines @@
   test_blacklist.Attach(service_->blacklist_);
 
   base::FilePath path = data_dir_.AppendASCII("good.crx");
 
   const Extension* good = InstallCRX(path, INSTALL_NEW);
   EXPECT_EQ(good_crx, good->id());
   UpdateExtension(good_crx, path, FAILED_SILENTLY);
   EXPECT_EQ(1u, registry_->enabled_extensions().size());
 
   base::ListValue whitelist;
-  PrefService* prefs = service_->extension_prefs()->pref_service();
+  PrefService* prefs = ExtensionPrefs::Get(profile_.get())->pref_service();
   whitelist.Append(new base::StringValue(good_crx));
   prefs->Set(extensions::pref_names::kInstallAllowList, whitelist);
 
   test_blacklist.SetBlacklistState(
       good_crx, extensions::BLACKLISTED_MALWARE, true);
   base::RunLoop().RunUntilIdle();
 
   // The good_crx is blacklisted and the whitelist doesn't negate it.
   ASSERT_TRUE(ValidateBooleanPref(good_crx, "blacklist", true));
   EXPECT_EQ(0u, registry_->enabled_extensions().size());
@@ skipping 30 matching lines @@
 #endif  // defined(ENABLE_BLACKLIST_TESTS)
 
 #if defined(ENABLE_BLACKLIST_TESTS)
 // Tests extensions blacklisted in prefs on startup; one still blacklisted by
 // safe browsing, the other not. The not-blacklisted one should recover.
 TEST_F(ExtensionServiceTest, BlacklistedInPrefsFromStartup) {
   extensions::TestBlacklist test_blacklist;
 
   InitializeGoodInstalledExtensionService();
   test_blacklist.Attach(service_->blacklist_);
-  service_->extension_prefs()->SetExtensionBlacklisted(good0, true);
-  service_->extension_prefs()->SetExtensionBlacklisted(good1, true);
+  ExtensionPrefs::Get(profile_.get())->SetExtensionBlacklisted(good0, true);
+  ExtensionPrefs::Get(profile_.get())->SetExtensionBlacklisted(good1, true);
 
   test_blacklist.SetBlacklistState(
       good1, extensions::BLACKLISTED_MALWARE, false);
 
   service_->Init();
 
   ASSERT_EQ(2u, registry_->blacklisted_extensions().size());
   ASSERT_EQ(1u, registry_->enabled_extensions().size());
 
   ASSERT_TRUE(registry_->blacklisted_extensions().Contains(good0));
@@ skipping 504 matching lines @@
   content::WindowedNotificationObserver observer(
       chrome::NOTIFICATION_CRX_INSTALLER_DONE,
       base::Bind(&WaitForCountNotificationsCallback, &count));
   service_->CheckForExternalUpdates();
 
   observer.Wait();
 
   ASSERT_EQ(2u, registry_->enabled_extensions().size());
   EXPECT_TRUE(service_->GetExtensionById(good_crx, false));
   EXPECT_TRUE(service_->GetExtensionById(page_action, false));
-  ExtensionPrefs* prefs = service_->extension_prefs();
+  ExtensionPrefs* prefs = ExtensionPrefs::Get(profile_.get());
   ASSERT_TRUE(!prefs->IsExternalExtensionAcknowledged(good_crx));
   ASSERT_TRUE(prefs->IsExternalExtensionAcknowledged(page_action));
 }
 
 #if !defined(OS_CHROMEOS)
 // This tests if default apps are installed correctly.
 TEST_F(ExtensionServiceTest, DefaultAppsInstall) {
   InitializeEmptyExtensionService();
   set_extensions_enabled(true);
 
@@ skipping 185 matching lines @@
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(1u, registry_->enabled_extensions().size());
   EXPECT_EQ(0u, registry_->disabled_extensions().size());
 
   service_->ReloadExtension(extension_id);
 
   // Extension should be disabled now, waiting to be reloaded.
   EXPECT_EQ(0u, registry_->enabled_extensions().size());
   EXPECT_EQ(1u, registry_->disabled_extensions().size());
-  EXPECT_EQ(Extension::DISABLE_RELOAD,
-            service_->extension_prefs()->GetDisableReasons(extension_id));
+  EXPECT_EQ(
+      Extension::DISABLE_RELOAD,
+      ExtensionPrefs::Get(profile_.get())->GetDisableReasons(extension_id));
 
   // Reloading again should not crash.
   service_->ReloadExtension(extension_id);
 
   // Finish reloading
   base::RunLoop().RunUntilIdle();
 
   // Extension should be enabled again.
   EXPECT_EQ(1u, registry_->enabled_extensions().size());
   EXPECT_EQ(0u, registry_->disabled_extensions().size());
@@ skipping 1532 matching lines @@
   {
     syncer::SyncDataList list = extension_sync_service_->GetAllSyncData(
         syncer::APPS);
     ASSERT_EQ(list.size(), 1U);
 
     extensions::AppSyncData app_sync_data(list[0]);
     EXPECT_TRUE(initial_ordinal.Equals(app_sync_data.app_launch_ordinal()));
     EXPECT_TRUE(initial_ordinal.Equals(app_sync_data.page_ordinal()));
   }
 
-  AppSorting* sorting = service_->extension_prefs()->app_sorting();
+  AppSorting* sorting = ExtensionPrefs::Get(profile_.get())->app_sorting();
   sorting->SetAppLaunchOrdinal(app->id(), initial_ordinal.CreateAfter());
   {
     syncer::SyncDataList list = extension_sync_service_->GetAllSyncData(
         syncer::APPS);
     ASSERT_EQ(list.size(), 1U);
 
     extensions::AppSyncData app_sync_data(list[0]);
     EXPECT_TRUE(initial_ordinal.LessThan(app_sync_data.app_launch_ordinal()));
     EXPECT_TRUE(initial_ordinal.Equals(app_sync_data.page_ordinal()));
   }
@@ skipping 1067 matching lines @@
   base::RunLoop().RunUntilIdle();
 
   // Extension was installed but not loaded.
   EXPECT_TRUE(notifications.CheckNotifications(
       chrome::NOTIFICATION_EXTENSION_INSTALLED));
   EXPECT_TRUE(service_->GetInstalledExtension(id));
 
   EXPECT_FALSE(registry_->enabled_extensions().Contains(id));
   EXPECT_TRUE(registry_->blacklisted_extensions().Contains(id));
 
-  EXPECT_TRUE(service_->extension_prefs()->IsExtensionBlacklisted(id));
-  EXPECT_TRUE(
-      service_->extension_prefs()->IsBlacklistedExtensionAcknowledged(id));
+  EXPECT_TRUE(ExtensionPrefs::Get(profile_.get())->IsExtensionBlacklisted(id));
+  EXPECT_TRUE(ExtensionPrefs::Get(profile_.get())
+                  ->IsBlacklistedExtensionAcknowledged(id));
 }
 
 TEST_F(ExtensionServiceTest, ReconcileKnownDisabledNoneDisabled) {
   // A profile with 3 extensions installed: good0, good1, and good2.
   InitializeGoodInstalledExtensionService();
 
   // Initializing shouldn't disable any extensions if none are known to be
   // disabled.
   service_->Init();
 
   extensions::ExtensionIdSet expected_extensions;
   expected_extensions.insert(good0);
   expected_extensions.insert(good1);
   expected_extensions.insert(good2);
 
   extensions::ExtensionIdSet expected_disabled_extensions;
 
   EXPECT_EQ(expected_extensions, registry_->enabled_extensions().GetIDs());
   EXPECT_EQ(expected_disabled_extensions,
             registry_->disabled_extensions().GetIDs());
 }
 
 TEST_F(ExtensionServiceTest, ReconcileKnownDisabledWithSideEnable) {
   // A profile with 3 extensions installed: good0, good1, and good2.
   InitializeGoodInstalledExtensionService();
 
-  ExtensionPrefs* extension_prefs = service_->extension_prefs();
+  ExtensionPrefs* extension_prefs = ExtensionPrefs::Get(profile_.get());
 
   // Disable good1.
   extension_prefs->SetExtensionState(good1, Extension::DISABLED);
 
   // Mark both good1 and good2 as "known_disabled" (effectively making good2
   // look as if it had been side-enabled).
   extensions::ExtensionIdSet known_disabled;
   known_disabled.insert(good1);
   known_disabled.insert(good2);
   extension_prefs->SetKnownDisabled(known_disabled);
@@ skipping 17 matching lines @@
   // ReconcileKnownDisabled().
   service_->EnableExtension(good2);
   service_->ReconcileKnownDisabled();
   expected_extensions.insert(good2);
   expected_disabled_extensions.erase(good2);
 
   EXPECT_EQ(expected_extensions, registry_->enabled_extensions().GetIDs());
   EXPECT_EQ(expected_disabled_extensions,
             registry_->disabled_extensions().GetIDs());
 }