Refactor ExtensionManagement

chrome/browser/extensions/extension_management_unittest.cc

 // Copyright 2014 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 <algorithm>
 #include <vector>
 
 #include "base/json/json_parser.h"
+#include "base/memory/linked_ptr.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/testing_pref_service.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_management.h"
+#include "chrome/browser/extensions/extension_management_internal.h"
 #include "chrome/browser/extensions/extension_management_test_util.h"
 #include "chrome/browser/extensions/external_policy_loader.h"
 #include "extensions/browser/pref_names.h"
 #include "extensions/common/manifest.h"
 #include "extensions/common/manifest_constants.h"
 #include "extensions/common/url_pattern.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace extensions {
@@ skipping 62 matching lines @@
       pref_service_->SetUserPref(path, value);
   }
 
   void RemovePref(bool managed, const char* path) {
     if (managed)
       pref_service_->RemoveManagedPref(path);
     else
       pref_service_->RemoveUserPref(path);
   }
 
+  linked_ptr<const internal::IndividualSettings> ReadById(
+      const ExtensionId& id) {
+    return extension_management_->ReadById(id);
+  }
+
+  linked_ptr<const internal::GlobalSettings> ReadGlobalSettings() {
+    return extension_management_->ReadGlobalSettings();
+  }
+
   void SetExampleDictPref() {
     std::string error_msg;
     scoped_ptr<base::Value> parsed(base::JSONReader::ReadAndReturnError(
         kExampleDictPreference,
         base::JSONParserOptions::JSON_ALLOW_TRAILING_COMMAS,
         NULL,
         &error_msg));
     ASSERT_TRUE(parsed && parsed->IsType(base::Value::TYPE_DICTIONARY))
         << error_msg;
     SetPref(true, pref_names::kExtensionManagement, parsed.release());
@@ skipping 89 matching lines @@
 }
 
 // Verify that preference controlled by legacy ExtensionInstallSources policy is
 // handled well.
 TEST_F(ExtensionManagementServiceTest, LegacyInstallSources) {
   base::ListValue allowed_sites_pref;
   allowed_sites_pref.AppendString("https://www.example.com/foo");
   allowed_sites_pref.AppendString("https://corp.mycompany.com/*");
   SetPref(
       true, pref_names::kAllowedInstallSites, allowed_sites_pref.DeepCopy());
-  const URLPatternSet& allowed_sites =
-      extension_management_->ReadGlobalSettings().install_sources;
-  ASSERT_TRUE(extension_management_->ReadGlobalSettings()
-                  .has_restricted_install_sources);
+  const URLPatternSet& allowed_sites = ReadGlobalSettings()->install_sources;
+  ASSERT_TRUE(ReadGlobalSettings()->has_restricted_install_sources);
   EXPECT_FALSE(allowed_sites.is_empty());
   EXPECT_TRUE(allowed_sites.MatchesURL(GURL("https://www.example.com/foo")));
   EXPECT_FALSE(allowed_sites.MatchesURL(GURL("https://www.example.com/bar")));
   EXPECT_TRUE(
       allowed_sites.MatchesURL(GURL("https://corp.mycompany.com/entry")));
   EXPECT_FALSE(
       allowed_sites.MatchesURL(GURL("https://www.mycompany.com/entry")));
 }
 
 // Verify that preference controlled by legacy ExtensionAllowedTypes policy is
 // handled well.
 TEST_F(ExtensionManagementServiceTest, LegacyAllowedTypes) {
   base::ListValue allowed_types_pref;
   allowed_types_pref.AppendInteger(Manifest::TYPE_THEME);
   allowed_types_pref.AppendInteger(Manifest::TYPE_USER_SCRIPT);
 
   SetPref(true, pref_names::kAllowedTypes, allowed_types_pref.DeepCopy());
   const std::vector<Manifest::Type>& allowed_types =
-      extension_management_->ReadGlobalSettings().allowed_types;
-  ASSERT_TRUE(
-      extension_management_->ReadGlobalSettings().has_restricted_allowed_types);
+      ReadGlobalSettings()->allowed_types;
+  ASSERT_TRUE(ReadGlobalSettings()->has_restricted_allowed_types);
   EXPECT_TRUE(allowed_types.size() == 2);
   EXPECT_FALSE(std::find(allowed_types.begin(),
                          allowed_types.end(),
                          Manifest::TYPE_EXTENSION) != allowed_types.end());
   EXPECT_TRUE(std::find(allowed_types.begin(),
                         allowed_types.end(),
                         Manifest::TYPE_THEME) != allowed_types.end());
   EXPECT_TRUE(std::find(allowed_types.begin(),
                    allowed_types.end(),
                    Manifest::TYPE_USER_SCRIPT) != allowed_types.end());
 }
 
 // Verify that preference controlled by legacy ExtensionInstallBlacklist policy
 // is handled well.
 TEST_F(ExtensionManagementServiceTest, LegacyInstallBlacklist) {
   base::ListValue denied_list_pref;
   denied_list_pref.AppendString(kTargetExtension);
 
   SetPref(true, pref_names::kInstallDenyList, denied_list_pref.DeepCopy());
-  EXPECT_EQ(extension_management_->ReadById(kTargetExtension).installation_mode,
+  EXPECT_EQ(ReadById(kTargetExtension)->installation_mode,
             ExtensionManagement::INSTALLATION_BLOCKED);
-  EXPECT_EQ(extension_management_->ReadById(kOtherExtension).installation_mode,
+  EXPECT_EQ(ReadById(kOtherExtension)->installation_mode,
             ExtensionManagement::INSTALLATION_ALLOWED);
 }
 
 // Verify that preference controlled by legacy ExtensionInstallWhitelist policy
 // is handled well.
 TEST_F(ExtensionManagementServiceTest, LegacyInstallWhitelist) {
   base::ListValue denied_list_pref;
   denied_list_pref.AppendString("*");
   base::ListValue allowed_list_pref;
   allowed_list_pref.AppendString(kTargetExtension);
 
   SetPref(true, pref_names::kInstallDenyList, denied_list_pref.DeepCopy());
   SetPref(true, pref_names::kInstallAllowList, allowed_list_pref.DeepCopy());
-  EXPECT_EQ(extension_management_->ReadById(kTargetExtension).installation_mode,
+  EXPECT_EQ(ReadById(kTargetExtension)->installation_mode,
             ExtensionManagement::INSTALLATION_ALLOWED);
-  EXPECT_EQ(extension_management_->ReadById(kOtherExtension).installation_mode,
+  EXPECT_EQ(ReadById(kOtherExtension)->installation_mode,
             ExtensionManagement::INSTALLATION_BLOCKED);
 
   // Verify that install whitelist preference set by user is ignored.
   RemovePref(true, pref_names::kInstallAllowList);
   SetPref(false, pref_names::kInstallAllowList, allowed_list_pref.DeepCopy());
-  EXPECT_EQ(extension_management_->ReadById(kTargetExtension).installation_mode,
+  EXPECT_EQ(ReadById(kTargetExtension)->installation_mode,
             ExtensionManagement::INSTALLATION_BLOCKED);
 }
 
 // Verify that preference controlled by legacy ExtensionInstallForcelist policy
 // is handled well.
 TEST_F(ExtensionManagementServiceTest, LegacyInstallForcelist) {
   base::DictionaryValue forced_list_pref;
   ExternalPolicyLoader::AddExtension(
       &forced_list_pref, kTargetExtension, kExampleUpdateUrl);
 
   SetPref(true, pref_names::kInstallForceList, forced_list_pref.DeepCopy());
-  EXPECT_EQ(extension_management_->ReadById(kTargetExtension).installation_mode,
+  EXPECT_EQ(ReadById(kTargetExtension)->installation_mode,
             ExtensionManagement::INSTALLATION_FORCED);
-  EXPECT_EQ(extension_management_->ReadById(kTargetExtension).update_url,
+  EXPECT_EQ(ReadById(kTargetExtension)->update_url,
             kExampleUpdateUrl);
-  EXPECT_EQ(extension_management_->ReadById(kOtherExtension).installation_mode,
+  EXPECT_EQ(ReadById(kOtherExtension)->installation_mode,
             ExtensionManagement::INSTALLATION_ALLOWED);
 
   // Verify that install forcelist preference set by user is ignored.
   RemovePref(true, pref_names::kInstallForceList);
   SetPref(false, pref_names::kInstallForceList, forced_list_pref.DeepCopy());
-  EXPECT_EQ(extension_management_->ReadById(kTargetExtension).installation_mode,
+  EXPECT_EQ(ReadById(kTargetExtension)->installation_mode,
             ExtensionManagement::INSTALLATION_ALLOWED);
 }
 
 // Tests parsing of new dictionary preference.
 TEST_F(ExtensionManagementServiceTest, PreferenceParsing) {
   SetExampleDictPref();
 
   // Verifies the installation mode settings.
   EXPECT_TRUE(extension_management_->BlacklistedByDefault());
-  EXPECT_EQ(extension_management_->ReadById(kTargetExtension).installation_mode,
+  EXPECT_EQ(ReadById(kTargetExtension)->installation_mode,
             ExtensionManagement::INSTALLATION_ALLOWED);
-  EXPECT_EQ(
-      extension_management_->ReadById(kTargetExtension2).installation_mode,
-      ExtensionManagement::INSTALLATION_FORCED);
-  EXPECT_EQ(extension_management_->ReadById(kTargetExtension2).update_url,
-            kExampleUpdateUrl);
-  EXPECT_EQ(
-      extension_management_->ReadById(kTargetExtension3).installation_mode,
-      ExtensionManagement::INSTALLATION_RECOMMENDED);
-  EXPECT_EQ(extension_management_->ReadById(kTargetExtension3).update_url,
-            kExampleUpdateUrl);
-  EXPECT_EQ(extension_management_->ReadById(kOtherExtension).installation_mode,
+  EXPECT_EQ(ReadById(kTargetExtension2)->installation_mode,
+            ExtensionManagement::INSTALLATION_FORCED);
+  EXPECT_EQ(ReadById(kTargetExtension2)->update_url, kExampleUpdateUrl);
+  EXPECT_EQ(ReadById(kTargetExtension3)->installation_mode,
+            ExtensionManagement::INSTALLATION_RECOMMENDED);
+  EXPECT_EQ(ReadById(kTargetExtension3)->update_url, kExampleUpdateUrl);
+  EXPECT_EQ(ReadById(kOtherExtension)->installation_mode,
             ExtensionManagement::INSTALLATION_BLOCKED);
 
   // Verifies global settings.
-  EXPECT_TRUE(extension_management_->ReadGlobalSettings()
-                  .has_restricted_install_sources);
-  const URLPatternSet& allowed_sites =
-      extension_management_->ReadGlobalSettings().install_sources;
+  EXPECT_TRUE(ReadGlobalSettings()->has_restricted_install_sources);
+  const URLPatternSet& allowed_sites = ReadGlobalSettings()->install_sources;
   EXPECT_EQ(allowed_sites.size(), 1u);
   EXPECT_TRUE(allowed_sites.MatchesURL(GURL("http://foo.com/entry")));
   EXPECT_FALSE(allowed_sites.MatchesURL(GURL("http://bar.com/entry")));
 
-  EXPECT_TRUE(
-      extension_management_->ReadGlobalSettings().has_restricted_allowed_types);
+  EXPECT_TRUE(ReadGlobalSettings()->has_restricted_allowed_types);
   const std::vector<Manifest::Type>& allowed_types =
-      extension_management_->ReadGlobalSettings().allowed_types;
+      ReadGlobalSettings()->allowed_types;
   EXPECT_EQ(allowed_types.size(), 2u);
   EXPECT_TRUE(std::find(allowed_types.begin(),
                         allowed_types.end(),
                         Manifest::TYPE_THEME) != allowed_types.end());
   EXPECT_TRUE(std::find(allowed_types.begin(),
                         allowed_types.end(),
                         Manifest::TYPE_USER_SCRIPT) != allowed_types.end());
 }
 
 // Tests functionality of new preference as to deprecate legacy
 // ExtensionInstallSources policy.
 TEST_F(ExtensionManagementServiceTest, NewInstallSources) {
   // Set the legacy preference, and verifies that it works.
   base::ListValue allowed_sites_pref;
   allowed_sites_pref.AppendString("https://www.example.com/foo");
   SetPref(
       true, pref_names::kAllowedInstallSites, allowed_sites_pref.DeepCopy());
-  EXPECT_TRUE(extension_management_->ReadGlobalSettings()
-                  .has_restricted_install_sources);
+  EXPECT_TRUE(ReadGlobalSettings()->has_restricted_install_sources);
   EXPECT_TRUE(
-      extension_management_->ReadGlobalSettings()
-          .install_sources.MatchesURL(GURL("https://www.example.com/foo")));
+      ReadGlobalSettings()
+          ->install_sources.MatchesURL(GURL("https://www.example.com/foo")));
 
   // Set the new dictionary preference.
   {
     PrefUpdater updater(pref_service_.get());
     updater.ClearInstallSources();
   }
   // Verifies that the new one overrides the legacy ones.
-  EXPECT_TRUE(extension_management_->ReadGlobalSettings()
-                  .has_restricted_install_sources);
+  EXPECT_TRUE(ReadGlobalSettings()->has_restricted_install_sources);
   EXPECT_FALSE(
-      extension_management_->ReadGlobalSettings()
-          .install_sources.MatchesURL(GURL("https://www.example.com/foo")));
+      ReadGlobalSettings()
+          ->install_sources.MatchesURL(GURL("https://www.example.com/foo")));
 
   // Updates the new dictionary preference.
   {
     PrefUpdater updater(pref_service_.get());
     updater.AddInstallSource("https://corp.mycompany.com/*");
   }
-  EXPECT_TRUE(extension_management_->ReadGlobalSettings()
-                  .has_restricted_install_sources);
-  EXPECT_TRUE(extension_management_->ReadGlobalSettings()
-                  .install_sources.MatchesURL(
+  EXPECT_TRUE(ReadGlobalSettings()->has_restricted_install_sources);
+  EXPECT_TRUE(ReadGlobalSettings()
+                  ->install_sources.MatchesURL(
                       GURL("https://corp.mycompany.com/entry")));
 }
 
 // Tests functionality of new preference as to deprecate legacy
 // ExtensionAllowedTypes policy.
 TEST_F(ExtensionManagementServiceTest, NewAllowedTypes) {
   // Set the legacy preference, and verifies that it works.
   base::ListValue allowed_types_pref;
   allowed_types_pref.AppendInteger(Manifest::TYPE_USER_SCRIPT);
   SetPref(true, pref_names::kAllowedTypes, allowed_types_pref.DeepCopy());
-  EXPECT_TRUE(
-      extension_management_->ReadGlobalSettings().has_restricted_allowed_types);
-  EXPECT_EQ(extension_management_->ReadGlobalSettings().allowed_types.size(),
-            1u);
-  EXPECT_EQ(extension_management_->ReadGlobalSettings().allowed_types[0],
-            Manifest::TYPE_USER_SCRIPT);
+  EXPECT_TRUE(ReadGlobalSettings()->has_restricted_allowed_types);
+  EXPECT_EQ(ReadGlobalSettings()->allowed_types.size(), 1u);
+  EXPECT_EQ(ReadGlobalSettings()->allowed_types[0], Manifest::TYPE_USER_SCRIPT);
 
   // Set the new dictionary preference.
   {
     PrefUpdater updater(pref_service_.get());
     updater.ClearAllowedTypes();
   }
   // Verifies that the new one overrides the legacy ones.
-  EXPECT_TRUE(
-      extension_management_->ReadGlobalSettings().has_restricted_allowed_types);
-  EXPECT_EQ(extension_management_->ReadGlobalSettings().allowed_types.size(),
-            0u);
+  EXPECT_TRUE(ReadGlobalSettings()->has_restricted_allowed_types);
+  EXPECT_EQ(ReadGlobalSettings()->allowed_types.size(), 0u);
 
   // Updates the new dictionary preference.
   {
     PrefUpdater updater(pref_service_.get());
     updater.AddAllowedType("theme");
   }
-  EXPECT_TRUE(
-      extension_management_->ReadGlobalSettings().has_restricted_allowed_types);
-  EXPECT_EQ(extension_management_->ReadGlobalSettings().allowed_types.size(),
-            1u);
-  EXPECT_EQ(extension_management_->ReadGlobalSettings().allowed_types[0],
-            Manifest::TYPE_THEME);
+  EXPECT_TRUE(ReadGlobalSettings()->has_restricted_allowed_types);
+  EXPECT_EQ(ReadGlobalSettings()->allowed_types.size(), 1u);
+  EXPECT_EQ(ReadGlobalSettings()->allowed_types[0], Manifest::TYPE_THEME);
 }
 
 // Tests functionality of new preference as to deprecate legacy
 // ExtensionInstallBlacklist policy.
 TEST_F(ExtensionManagementServiceTest, NewInstallBlacklist) {
   // Set the new dictionary preference.
   {
     PrefUpdater updater(pref_service_.get());
     updater.SetBlacklistedByDefault(false);  // Allowed by default.
     updater.SetIndividualExtensionInstallationAllowed(kTargetExtension, false);
     updater.ClearPerExtensionSettings(kTargetExtension2);
     updater.ClearPerExtensionSettings(kOtherExtension);
   }
   EXPECT_FALSE(extension_management_->BlacklistedByDefault());
-  EXPECT_EQ(extension_management_->ReadById(kTargetExtension).installation_mode,
+  EXPECT_EQ(ReadById(kTargetExtension)->installation_mode,
             ExtensionManagement::INSTALLATION_BLOCKED);
-  EXPECT_EQ(extension_management_->ReadById(kOtherExtension).installation_mode,
+  EXPECT_EQ(ReadById(kOtherExtension)->installation_mode,
             ExtensionManagement::INSTALLATION_ALLOWED);
 
   // Set legacy preference.
   base::ListValue denied_list_pref;
   denied_list_pref.AppendString("*");
   denied_list_pref.AppendString(kTargetExtension2);
   SetPref(true, pref_names::kInstallDenyList, denied_list_pref.DeepCopy());
 
   base::ListValue allowed_list_pref;
   allowed_list_pref.AppendString(kTargetExtension);
   SetPref(true, pref_names::kInstallAllowList, allowed_list_pref.DeepCopy());
 
   // Verifies that the new one have higher priority over the legacy ones.
   EXPECT_FALSE(extension_management_->BlacklistedByDefault());
-  EXPECT_EQ(extension_management_->ReadById(kTargetExtension).installation_mode,
+  EXPECT_EQ(ReadById(kTargetExtension)->installation_mode,
             ExtensionManagement::INSTALLATION_BLOCKED);
-  EXPECT_EQ(
-      extension_management_->ReadById(kTargetExtension2).installation_mode,
-      ExtensionManagement::INSTALLATION_BLOCKED);
-  EXPECT_EQ(extension_management_->ReadById(kOtherExtension).installation_mode,
+  EXPECT_EQ(ReadById(kTargetExtension2)->installation_mode,
+            ExtensionManagement::INSTALLATION_BLOCKED);
+  EXPECT_EQ(ReadById(kOtherExtension)->installation_mode,
             ExtensionManagement::INSTALLATION_ALLOWED);
 }
 
 // Tests functionality of new preference as to deprecate legacy
 // ExtensionInstallWhitelist policy.
 TEST_F(ExtensionManagementServiceTest, NewInstallWhitelist) {
   // Set the new dictionary preference.
   {
     PrefUpdater updater(pref_service_.get());
     updater.SetBlacklistedByDefault(true);  // Disallowed by default.
     updater.SetIndividualExtensionInstallationAllowed(kTargetExtension, true);
     updater.ClearPerExtensionSettings(kTargetExtension2);
     updater.ClearPerExtensionSettings(kOtherExtension);
   }
   EXPECT_TRUE(extension_management_->BlacklistedByDefault());
-  EXPECT_EQ(extension_management_->ReadById(kTargetExtension).installation_mode,
+  EXPECT_EQ(ReadById(kTargetExtension)->installation_mode,
             ExtensionManagement::INSTALLATION_ALLOWED);
-  EXPECT_EQ(extension_management_->ReadById(kOtherExtension).installation_mode,
+  EXPECT_EQ(ReadById(kOtherExtension)->installation_mode,
             ExtensionManagement::INSTALLATION_BLOCKED);
 
   // Set legacy preference.
   base::ListValue denied_list_pref;
   denied_list_pref.AppendString(kTargetExtension);
   SetPref(true, pref_names::kInstallDenyList, denied_list_pref.DeepCopy());
 
   base::ListValue allowed_list_pref;
   allowed_list_pref.AppendString(kTargetExtension2);
   SetPref(true, pref_names::kInstallAllowList, allowed_list_pref.DeepCopy());
 
   // Verifies that the new one have higher priority over the legacy ones.
   EXPECT_TRUE(extension_management_->BlacklistedByDefault());
-  EXPECT_EQ(extension_management_->ReadById(kTargetExtension).installation_mode,
+  EXPECT_EQ(ReadById(kTargetExtension)->installation_mode,
             ExtensionManagement::INSTALLATION_ALLOWED);
-  EXPECT_EQ(
-      extension_management_->ReadById(kTargetExtension2).installation_mode,
-      ExtensionManagement::INSTALLATION_ALLOWED);
-  EXPECT_EQ(extension_management_->ReadById(kOtherExtension).installation_mode,
+  EXPECT_EQ(ReadById(kTargetExtension2)->installation_mode,
+            ExtensionManagement::INSTALLATION_ALLOWED);
+  EXPECT_EQ(ReadById(kOtherExtension)->installation_mode,
             ExtensionManagement::INSTALLATION_BLOCKED);
 }
 
 // Tests functionality of new preference as to deprecate legacy
 // ExtensionInstallForcelist policy.
 TEST_F(ExtensionManagementServiceTest, NewInstallForcelist) {
   // Set some legacy preferences, to verify that the new one overrides the
   // legacy ones.
   base::ListValue denied_list_pref;
   denied_list_pref.AppendString(kTargetExtension);
   SetPref(true, pref_names::kInstallDenyList, denied_list_pref.DeepCopy());
 
   // Set the new dictionary preference.
   {
     PrefUpdater updater(pref_service_.get());
     updater.SetIndividualExtensionAutoInstalled(
         kTargetExtension, kExampleUpdateUrl, true);
     updater.ClearPerExtensionSettings(kOtherExtension);
   }
-  EXPECT_EQ(extension_management_->ReadById(kTargetExtension).installation_mode,
+  EXPECT_EQ(ReadById(kTargetExtension)->installation_mode,
             ExtensionManagement::INSTALLATION_FORCED);
-  EXPECT_EQ(extension_management_->ReadById(kTargetExtension).update_url,
-            kExampleUpdateUrl);
-  EXPECT_EQ(extension_management_->ReadById(kOtherExtension).installation_mode,
+  EXPECT_EQ(ReadById(kTargetExtension)->update_url, kExampleUpdateUrl);
+  EXPECT_EQ(ReadById(kOtherExtension)->installation_mode,
             ExtensionManagement::INSTALLATION_ALLOWED);
 }
 
 // Tests the flag value indicating that extensions are blacklisted by default.
 TEST_F(ExtensionAdminPolicyTest, BlacklistedByDefault) {
   EXPECT_FALSE(BlacklistedByDefault(NULL));
 
   base::ListValue blacklist;
   blacklist.Append(new base::StringValue(kOtherExtension));
   EXPECT_FALSE(BlacklistedByDefault(&blacklist));
@@ skipping 132 matching lines @@
   EXPECT_FALSE(error.empty());
 
   CreateExtension(Manifest::INTERNAL);
   error.clear();
   EXPECT_FALSE(MustRemainEnabled(extension_.get(), NULL));
   EXPECT_FALSE(MustRemainEnabled(extension_.get(), &error));
   EXPECT_TRUE(error.empty());
 }
 
 }  // namespace extensions