Convert ExtensionRegistry to a BrowserContextKeyedService

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 69 matching lines @@
 #include "content/public/browser/dom_storage_context.h"
 #include "content/public/browser/gpu_data_manager.h"
 #include "content/public/browser/indexed_db_context.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/plugin_service.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/common/content_constants.h"
 #include "content/public/test/test_utils.h"
+#include "extensions/browser/extension_registry.h"
 #include "extensions/browser/external_provider_interface.h"
 #include "extensions/browser/management_policy.h"
 #include "extensions/browser/pending_extension_info.h"
 #include "extensions/browser/pending_extension_manager.h"
 #include "extensions/browser/test_management_policy.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_builder.h"
 #include "extensions/common/extension_resource.h"
 #include "extensions/common/manifest_constants.h"
@@ skipping 44 matching lines @@
 using content::IndexedDBContext;
 using content::PluginService;
 using extensions::APIPermission;
 using extensions::APIPermissionSet;
 using extensions::AppSorting;
 using extensions::Blacklist;
 using extensions::CrxInstaller;
 using extensions::Extension;
 using extensions::ExtensionCreator;
 using extensions::ExtensionPrefs;
+using extensions::ExtensionRegistry;
 using extensions::ExtensionResource;
 using extensions::ExtensionSystem;
 using extensions::FakeSafeBrowsingDatabaseManager;
 using extensions::FeatureSwitch;
 using extensions::Manifest;
 using extensions::PermissionSet;
 using extensions::TestExtensionSystem;
 using extensions::URLPatternSet;
 
 namespace keys = extensions::manifest_keys;
@@ skipping 3198 matching lines @@
 // initialized.
 TEST_F(ExtensionServiceTest, SetUnsetBlacklistInPrefs) {
   scoped_refptr<FakeSafeBrowsingDatabaseManager> blacklist_db(
       new FakeSafeBrowsingDatabaseManager(true));
   Blacklist::ScopedDatabaseManagerForTest scoped_blacklist_db(blacklist_db);
 
   // A profile with 3 extensions installed: good0, good1, and good2.
   InitializeGoodInstalledExtensionService();
   service_->Init();
 
-  const extensions::ExtensionSet* extensions = service_->extensions();
-  const extensions::ExtensionSet* blacklisted_extensions =
-      service_->blacklisted_extensions();
+  ExtensionRegistry* registry = ExtensionRegistry::Get(profile_.get());
+  const extensions::ExtensionSet& enabled_extensions =
+      registry->enabled_extensions();
+  const extensions::ExtensionSet& blacklisted_extensions =
+      registry->blacklisted_extensions();
 
-  EXPECT_TRUE( extensions->Contains(good0) &&
-              !blacklisted_extensions->Contains(good0));
-  EXPECT_TRUE( extensions->Contains(good1) &&
-              !blacklisted_extensions->Contains(good1));
-  EXPECT_TRUE( extensions->Contains(good2) &&
-              !blacklisted_extensions->Contains(good2));
+  EXPECT_TRUE(enabled_extensions.Contains(good0) &&
+              !blacklisted_extensions.Contains(good0));
+  EXPECT_TRUE(enabled_extensions.Contains(good1) &&
+              !blacklisted_extensions.Contains(good1));
+  EXPECT_TRUE(enabled_extensions.Contains(good2) &&
+              !blacklisted_extensions.Contains(good2));
 
   EXPECT_FALSE(IsPrefExist(good0, "blacklist"));
   EXPECT_FALSE(IsPrefExist(good1, "blacklist"));
   EXPECT_FALSE(IsPrefExist(good2, "blacklist"));
   EXPECT_FALSE(IsPrefExist("invalid_id", "blacklist"));
 
   // Blacklist good0 and good1 (and an invalid extension ID).
   blacklist_db->SetUnsafe(good0, good1, "invalid_id").NotifyUpdate();
   base::RunLoop().RunUntilIdle();
 
-  EXPECT_TRUE(!extensions->Contains(good0) &&
-               blacklisted_extensions->Contains(good0));
-  EXPECT_TRUE(!extensions->Contains(good1) &&
-               blacklisted_extensions->Contains(good1));
-  EXPECT_TRUE( extensions->Contains(good2) &&
-              !blacklisted_extensions->Contains(good2));
+  EXPECT_TRUE(!enabled_extensions.Contains(good0) &&
+              blacklisted_extensions.Contains(good0));
+  EXPECT_TRUE(!enabled_extensions.Contains(good1) &&
+              blacklisted_extensions.Contains(good1));
+  EXPECT_TRUE(enabled_extensions.Contains(good2) &&
+              !blacklisted_extensions.Contains(good2));
 
   EXPECT_TRUE(ValidateBooleanPref(good0, "blacklist", true));
   EXPECT_TRUE(ValidateBooleanPref(good1, "blacklist", true));
   EXPECT_FALSE(IsPrefExist(good2, "blacklist"));
   EXPECT_FALSE(IsPrefExist("invalid_id", "blacklist"));
 
   // Un-blacklist good1 and blacklist good2.
   blacklist_db->SetUnsafe(good0, good2, "invalid_id").NotifyUpdate();
   base::RunLoop().RunUntilIdle();
 
-  EXPECT_TRUE(!extensions->Contains(good0) &&
-               blacklisted_extensions->Contains(good0));
-  EXPECT_TRUE( extensions->Contains(good1) &&
-              !blacklisted_extensions->Contains(good1));
-  EXPECT_TRUE(!extensions->Contains(good2) &&
-               blacklisted_extensions->Contains(good2));
+  EXPECT_TRUE(!enabled_extensions.Contains(good0) &&
+              blacklisted_extensions.Contains(good0));
+  EXPECT_TRUE(enabled_extensions.Contains(good1) &&
+              !blacklisted_extensions.Contains(good1));
+  EXPECT_TRUE(!enabled_extensions.Contains(good2) &&
+              blacklisted_extensions.Contains(good2));
 
   EXPECT_TRUE(ValidateBooleanPref(good0, "blacklist", true));
   EXPECT_FALSE(IsPrefExist(good1, "blacklist"));
   EXPECT_TRUE(ValidateBooleanPref(good2, "blacklist", true));
   EXPECT_FALSE(IsPrefExist("invalid_id", "blacklist"));
 }
 #endif  // defined(ENABLE_BLACKLIST_TESTS)
 
 #if defined(ENABLE_BLACKLIST_TESTS)
 // Tests trying to install a blacklisted extension.
@@ skipping 61 matching lines @@
   InitializeGoodInstalledExtensionService();
 
   // Blacklist good1 before the service initializes.
   blacklist_db->SetUnsafe(good1);
 
   // Load extensions.
   service_->Init();
   ASSERT_EQ(3u, loaded_.size());  // hasn't had time to blacklist yet
 
   base::RunLoop().RunUntilIdle();
-  ASSERT_EQ(1u, service_->blacklisted_extensions()->size());
-  ASSERT_EQ(2u, service_->extensions()->size());
 
-  ASSERT_TRUE(service_->extensions()->Contains(good0));
-  ASSERT_TRUE(service_->blacklisted_extensions()->Contains(good1));
-  ASSERT_TRUE(service_->extensions()->Contains(good2));
+  ExtensionRegistry* registry = ExtensionRegistry::Get(profile_.get());
+  ASSERT_EQ(1u, registry->blacklisted_extensions().size());
+  ASSERT_EQ(2u, registry->enabled_extensions().size());
+
+  ASSERT_TRUE(registry->enabled_extensions().Contains(good0));
+  ASSERT_TRUE(registry->blacklisted_extensions().Contains(good1));
+  ASSERT_TRUE(registry->enabled_extensions().Contains(good2));
 }
 #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) {
   scoped_refptr<FakeSafeBrowsingDatabaseManager> blacklist_db(
       new FakeSafeBrowsingDatabaseManager(true));
   Blacklist::ScopedDatabaseManagerForTest scoped_blacklist_db(blacklist_db);
 
   InitializeGoodInstalledExtensionService();
   service_->extension_prefs()->SetExtensionBlacklisted(good0, true);
   service_->extension_prefs()->SetExtensionBlacklisted(good1, true);
 
   blacklist_db->SetUnsafe(good1);
 
   service_->Init();
 
-  ASSERT_EQ(2u, service_->blacklisted_extensions()->size());
-  ASSERT_EQ(1u, service_->extensions()->size());
+  ExtensionRegistry* registry = ExtensionRegistry::Get(profile_.get());
+  ASSERT_EQ(2u, registry->blacklisted_extensions().size());
+  ASSERT_EQ(1u, registry->enabled_extensions().size());
 
-  ASSERT_TRUE(service_->blacklisted_extensions()->Contains(good0));
-  ASSERT_TRUE(service_->blacklisted_extensions()->Contains(good1));
-  ASSERT_TRUE(service_->extensions()->Contains(good2));
+  ASSERT_TRUE(registry->blacklisted_extensions().Contains(good0));
+  ASSERT_TRUE(registry->blacklisted_extensions().Contains(good1));
+  ASSERT_TRUE(registry->enabled_extensions().Contains(good2));
 
   // Give time for the blacklist to update.
   base::RunLoop().RunUntilIdle();
 
-  ASSERT_EQ(1u, service_->blacklisted_extensions()->size());
-  ASSERT_EQ(2u, service_->extensions()->size());
+  ASSERT_EQ(1u, registry->blacklisted_extensions().size());
+  ASSERT_EQ(2u, registry->enabled_extensions().size());
 
-  ASSERT_TRUE(service_->extensions()->Contains(good0));
-  ASSERT_TRUE(service_->blacklisted_extensions()->Contains(good1));
-  ASSERT_TRUE(service_->extensions()->Contains(good2));
+  ASSERT_TRUE(registry->enabled_extensions().Contains(good0));
+  ASSERT_TRUE(registry->blacklisted_extensions().Contains(good1));
+  ASSERT_TRUE(registry->enabled_extensions().Contains(good2));
 }
 #endif  // defined(ENABLE_BLACKLIST_TESTS)
 
 // Will not install extension blacklisted by policy.
 TEST_F(ExtensionServiceTest, BlacklistedByPolicyWillNotInstall) {
   InitializeEmptyExtensionService();
 
   // Blacklist everything.
   {
     ListPrefUpdate update(profile_->GetPrefs(),
@@ skipping 362 matching lines @@
 }
 #endif
 
 // Tests disabling extensions
 TEST_F(ExtensionServiceTest, DisableExtension) {
   InitializeEmptyExtensionService();
 
   InstallCRX(data_dir_.AppendASCII("good.crx"), INSTALL_NEW);
   EXPECT_TRUE(service_->GetExtensionById(good_crx, true));
   EXPECT_TRUE(service_->GetExtensionById(good_crx, false));
-  EXPECT_EQ(1u, service_->extensions()->size());
-  EXPECT_EQ(0u, service_->disabled_extensions()->size());
-  EXPECT_EQ(0u, service_->terminated_extensions()->size());
-  EXPECT_EQ(0u, service_->blacklisted_extensions()->size());
+
+  ExtensionRegistry* registry = ExtensionRegistry::Get(profile_.get());
+  EXPECT_EQ(1u, registry->enabled_extensions().size());
+  EXPECT_EQ(0u, registry->disabled_extensions().size());
+  EXPECT_EQ(0u, registry->terminated_extensions().size());
+  EXPECT_EQ(0u, registry->blacklisted_extensions().size());
 
   // Disable it.
   service_->DisableExtension(good_crx, Extension::DISABLE_USER_ACTION);
 
   EXPECT_TRUE(service_->GetExtensionById(good_crx, true));
   EXPECT_FALSE(service_->GetExtensionById(good_crx, false));
-  EXPECT_EQ(0u, service_->extensions()->size());
-  EXPECT_EQ(1u, service_->disabled_extensions()->size());
-  EXPECT_EQ(0u, service_->terminated_extensions()->size());
-  EXPECT_EQ(0u, service_->blacklisted_extensions()->size());
+  EXPECT_EQ(0u, registry->enabled_extensions().size());
+  EXPECT_EQ(1u, registry->disabled_extensions().size());
+  EXPECT_EQ(0u, registry->terminated_extensions().size());
+  EXPECT_EQ(0u, registry->blacklisted_extensions().size());
 }
 
 TEST_F(ExtensionServiceTest, TerminateExtension) {
   InitializeEmptyExtensionService();
 
   InstallCRX(data_dir_.AppendASCII("good.crx"), INSTALL_NEW);
-  EXPECT_EQ(1u, service_->extensions()->size());
-  EXPECT_EQ(0u, service_->disabled_extensions()->size());
-  EXPECT_EQ(0u, service_->terminated_extensions()->size());
-  EXPECT_EQ(0u, service_->blacklisted_extensions()->size());
+  ExtensionRegistry* registry = ExtensionRegistry::Get(profile_.get());
+  EXPECT_EQ(1u, registry->enabled_extensions().size());
+  EXPECT_EQ(0u, registry->disabled_extensions().size());
+  EXPECT_EQ(0u, registry->terminated_extensions().size());
+  EXPECT_EQ(0u, registry->blacklisted_extensions().size());
 
   TerminateExtension(good_crx);
 
-  EXPECT_EQ(0u, service_->extensions()->size());
-  EXPECT_EQ(0u, service_->disabled_extensions()->size());
-  EXPECT_EQ(1u, service_->terminated_extensions()->size());
-  EXPECT_EQ(0u, service_->blacklisted_extensions()->size());
+  EXPECT_EQ(0u, registry->enabled_extensions().size());
+  EXPECT_EQ(0u, registry->disabled_extensions().size());
+  EXPECT_EQ(1u, registry->terminated_extensions().size());
+  EXPECT_EQ(0u, registry->blacklisted_extensions().size());
 }
 
 TEST_F(ExtensionServiceTest, DisableTerminatedExtension) {
   InitializeEmptyExtensionService();
 
   InstallCRX(data_dir_.AppendASCII("good.crx"), INSTALL_NEW);
   TerminateExtension(good_crx);
   EXPECT_TRUE(service_->GetTerminatedExtension(good_crx));
 
   // Disable it.
   service_->DisableExtension(good_crx, Extension::DISABLE_USER_ACTION);
 
   EXPECT_FALSE(service_->GetTerminatedExtension(good_crx));
   EXPECT_TRUE(service_->GetExtensionById(good_crx, true));
 
-  EXPECT_EQ(0u, service_->extensions()->size());
-  EXPECT_EQ(1u, service_->disabled_extensions()->size());
-  EXPECT_EQ(0u, service_->terminated_extensions()->size());
-  EXPECT_EQ(0u, service_->blacklisted_extensions()->size());
+  ExtensionRegistry* registry = ExtensionRegistry::Get(profile_.get());
+  EXPECT_EQ(0u, registry->enabled_extensions().size());
+  EXPECT_EQ(1u, registry->disabled_extensions().size());
+  EXPECT_EQ(0u, registry->terminated_extensions().size());
+  EXPECT_EQ(0u, registry->blacklisted_extensions().size());
 }
 
 // Tests disabling all extensions (simulating --disable-extensions flag).
 TEST_F(ExtensionServiceTest, DisableAllExtensions) {
   InitializeEmptyExtensionService();
 
   base::FilePath path = data_dir_.AppendASCII("good.crx");
   InstallCRX(path, INSTALL_NEW);
 
   EXPECT_EQ(1u, service_->extensions()->size());
@@ skipping 2718 matching lines @@
       extension.get(),
       syncer::StringOrdinal(),
       false /* has requirement errors */,
       extensions::BLACKLISTED_MALWARE,
       false /* wait for idle */);
   base::RunLoop().RunUntilIdle();
 
   // Extension was installed but not loaded.
   EXPECT_TRUE(notifications.CheckNotifications(
       chrome::NOTIFICATION_EXTENSION_INSTALLED));
+  EXPECT_TRUE(service_->GetInstalledExtension(id));
 
-  EXPECT_TRUE(service_->GetInstalledExtension(id));
-  EXPECT_FALSE(service_->extensions()->Contains(id));
-  EXPECT_TRUE(service_->blacklisted_extensions()->Contains(id));
+  ExtensionRegistry* registry = ExtensionRegistry::Get(profile_.get());
+  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));
 }
 
 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
@@ skipping 47 matching lines @@
   // ReconcileKnownDisabled().
   service_->EnableExtension(good2);
   service_->ReconcileKnownDisabled();
   expected_extensions.insert(good2);
   expected_disabled_extensions.erase(good2);
 
   EXPECT_EQ(expected_extensions, service_->extensions()->GetIDs());
   EXPECT_EQ(expected_disabled_extensions,
             service_->disabled_extensions()->GetIDs());
 }