// found in the LICENSE file.
#include <algorithm>
+#include <string>
#include <vector>
#include "base/json/json_parser.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 "chrome/browser/extensions/standard_management_policy_provider.h"
#include "extensions/browser/pref_names.h"
#include "extensions/common/manifest.h"
#include "extensions/common/manifest_constants.h"
+#include "extensions/common/permissions/api_permission.h"
+#include "extensions/common/permissions/permissions_info.h"
#include "extensions/common/url_pattern.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "url/gurl.h"
const char kTargetExtension2[] = "bcdefghijklmnopabcdefghijklmnopa";
const char kTargetExtension3[] = "cdefghijklmnopabcdefghijklmnopab";
const char kTargetExtension4[] = "defghijklmnopabcdefghijklmnopabc";
-const char kOtherExtension[] = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
const char kExampleUpdateUrl[] = "http://example.com/update_url";
+const char kNonExistingExtension[] = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
+const char kNonExistingUpdateUrl[] = "http://example.net/update.xml";
+
const char kExampleDictPreference[] =
"{"
" \"abcdefghijklmnopabcdefghijklmnop\": {" // kTargetExtension
" \"installation_mode\": \"allowed\","
+ " \"blocked_permissions\": [\"fileSystem\", \"bookmarks\"],"
" },"
" \"bcdefghijklmnopabcdefghijklmnopa\": {" // kTargetExtension2
" \"installation_mode\": \"force_installed\","
" \"update_url\": \"http://example.com/update_url\","
+ " \"allowed_permissions\": [\"fileSystem\", \"bookmarks\"],"
" },"
" \"cdefghijklmnopabcdefghijklmnopab\": {" // kTargetExtension3
" \"installation_mode\": \"normal_installed\","
" \"update_url\": \"http://example.com/update_url\","
+ " \"allowed_permissions\": [\"fileSystem\", \"downloads\"],"
+ " \"blocked_permissions\": [\"fileSystem\", \"history\"],"
" },"
" \"defghijklmnopabcdefghijklmnopabc\": {" // kTargetExtension4
" \"installation_mode\": \"blocked\","
" },"
+ " \"update_url:http://example.com/update_url\": {" // kExampleUpdateUrl
+ " \"installation_mode\": \"allowed\","
+ " \"allowed_permissions\": [\"downloads\"],"
+ " \"blocked_permissions\": [\"bookmarks\"],"
+ " },"
" \"*\": {"
" \"installation_mode\": \"blocked\","
" \"install_sources\": [\"*://foo.com/*\"],"
" \"allowed_types\": [\"theme\", \"user_script\"],"
+ " \"blocked_permissions\": [\"fileSystem\", \"downloads\"],"
" },"
"}";
typedef ExtensionManagementPrefUpdater<TestingPrefServiceSimple> PrefUpdater;
ExtensionManagementServiceTest() {}
- virtual ~ExtensionManagementServiceTest() {}
+ ~ExtensionManagementServiceTest() override {}
// testing::Test:
- virtual void SetUp() OVERRIDE {
- InitPrefService();
- }
+ void SetUp() override { InitPrefService(); }
void InitPrefService() {
extension_management_.reset();
pref_service_->RemoveUserPref(path);
}
+ const internal::GlobalSettings* ReadGlobalSettings() {
+ return extension_management_->global_settings_.get();
+ }
+
+ ExtensionManagement::InstallationMode GetInstallationModeById(
+ const std::string& id) {
+ return GetInstallationMode(id, kNonExistingUpdateUrl);
+ }
+
+ ExtensionManagement::InstallationMode GetInstallationModeByUpdateUrl(
+ const std::string& update_url) {
+ return GetInstallationMode(kNonExistingExtension, update_url);
+ }
+
+ void CheckAutomaticallyInstalledUpdateUrl(const std::string& id,
+ const std::string& update_url) {
+ auto iter = extension_management_->settings_by_id_.find(id);
+ ASSERT_TRUE(iter != extension_management_->settings_by_id_.end());
+ ASSERT_TRUE((iter->second->installation_mode ==
+ ExtensionManagement::INSTALLATION_FORCED) ||
+ (iter->second->installation_mode ==
+ ExtensionManagement::INSTALLATION_RECOMMENDED));
+ EXPECT_EQ(iter->second->update_url, update_url);
+ }
+
+ APIPermissionSet GetBlockedAPIPermissionsById(const std::string& id) {
+ return GetBlockedAPIPermissions(id, kNonExistingUpdateUrl);
+ }
+
+ APIPermissionSet GetBlockedAPIPermissionsByUpdateUrl(
+ const std::string& update_url) {
+ return GetBlockedAPIPermissions(kNonExistingExtension, update_url);
+ }
+
void SetExampleDictPref() {
std::string error_msg;
scoped_ptr<base::Value> parsed(base::JSONReader::ReadAndReturnError(
SetPref(true, pref_names::kExtensionManagement, parsed.release());
}
+ ExtensionManagement::InstallationMode GetInstallationMode(
+ const std::string& id,
+ const std::string& update_url) {
+ scoped_refptr<const Extension> extension =
+ CreateExtensionWithIdAndUpdateUrl(Manifest::UNPACKED, id, update_url);
+ return extension_management_->GetInstallationMode(extension.get());
+ }
+
+ APIPermissionSet GetBlockedAPIPermissions(const std::string& id,
+ const std::string& update_url) {
+ scoped_refptr<const Extension> extension =
+ CreateExtensionWithIdAndUpdateUrl(Manifest::UNPACKED, id, update_url);
+ return extension_management_->GetBlockedAPIPermissions(extension.get());
+ }
+
protected:
scoped_ptr<TestingPrefServiceSimple> pref_service_;
scoped_ptr<ExtensionManagement> extension_management_;
+
+ private:
+ // Create an extension with specified |location|, |id| and |update_url|.
+ scoped_refptr<const Extension> CreateExtensionWithIdAndUpdateUrl(
+ Manifest::Location location,
+ const std::string& id,
+ const std::string& update_url) {
+ base::DictionaryValue manifest_dict;
+ manifest_dict.SetString(manifest_keys::kName, "test");
+ manifest_dict.SetString(manifest_keys::kVersion, "0.1");
+ manifest_dict.SetString(manifest_keys::kUpdateURL, update_url);
+ std::string error;
+ scoped_refptr<const Extension> extension =
+ Extension::Create(base::FilePath(), location, manifest_dict,
+ Extension::NO_FLAGS, id, &error);
+ CHECK(extension.get()) << error;
+ return extension;
+ }
};
class ExtensionAdminPolicyTest : public ExtensionManagementServiceTest {
public:
ExtensionAdminPolicyTest() {}
- virtual ~ExtensionAdminPolicyTest() {}
+ ~ExtensionAdminPolicyTest() override {}
+
+ void SetUpPolicyProvider() {
+ provider_.reset(
+ new StandardManagementPolicyProvider(extension_management_.get()));
+ }
void CreateExtension(Manifest::Location location) {
base::DictionaryValue values;
bool MustRemainEnabled(const Extension* extension, base::string16* error);
protected:
+ scoped_ptr<StandardManagementPolicyProvider> provider_;
scoped_refptr<Extension> extension_;
};
bool ExtensionAdminPolicyTest::BlacklistedByDefault(
const base::ListValue* blacklist) {
- InitPrefService();
+ SetUpPolicyProvider();
if (blacklist)
SetPref(true, pref_names::kInstallDenyList, blacklist->DeepCopy());
return extension_management_->BlacklistedByDefault();
const base::ListValue* allowed_types,
const Extension* extension,
base::string16* error) {
- InitPrefService();
+ SetUpPolicyProvider();
if (blacklist)
SetPref(true, pref_names::kInstallDenyList, blacklist->DeepCopy());
if (whitelist)
SetPref(true, pref_names::kInstallForceList, forcelist->DeepCopy());
if (allowed_types)
SetPref(true, pref_names::kAllowedTypes, allowed_types->DeepCopy());
- return extension_management_->GetProvider()->UserMayLoad(extension, error);
+ return provider_->UserMayLoad(extension, error);
}
bool ExtensionAdminPolicyTest::UserMayModifySettings(const Extension* extension,
base::string16* error) {
- InitPrefService();
- return extension_management_->GetProvider()->UserMayModifySettings(extension,
- error);
+ SetUpPolicyProvider();
+ return provider_->UserMayModifySettings(extension, error);
}
bool ExtensionAdminPolicyTest::MustRemainEnabled(const Extension* extension,
base::string16* error) {
- InitPrefService();
- return extension_management_->GetProvider()->MustRemainEnabled(extension,
- error);
+ SetUpPolicyProvider();
+ return provider_->MustRemainEnabled(extension, error);
}
// Verify that preference controlled by legacy ExtensionInstallSources policy is
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")));
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);
- EXPECT_TRUE(allowed_types.size() == 2);
+ ReadGlobalSettings()->allowed_types;
+ ASSERT_TRUE(ReadGlobalSettings()->has_restricted_allowed_types);
+ EXPECT_EQ(allowed_types.size(), 2u);
EXPECT_FALSE(std::find(allowed_types.begin(),
allowed_types.end(),
Manifest::TYPE_EXTENSION) != allowed_types.end());
denied_list_pref.AppendString(kTargetExtension);
SetPref(true, pref_names::kInstallDenyList, denied_list_pref.DeepCopy());
- EXPECT_EQ(extension_management_->ReadById(kTargetExtension).installation_mode,
+ EXPECT_EQ(GetInstallationModeById(kTargetExtension),
ExtensionManagement::INSTALLATION_BLOCKED);
- EXPECT_EQ(extension_management_->ReadById(kOtherExtension).installation_mode,
+ EXPECT_EQ(GetInstallationModeById(kNonExistingExtension),
ExtensionManagement::INSTALLATION_ALLOWED);
}
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(GetInstallationModeById(kTargetExtension),
ExtensionManagement::INSTALLATION_ALLOWED);
- EXPECT_EQ(extension_management_->ReadById(kOtherExtension).installation_mode,
+ EXPECT_EQ(GetInstallationModeById(kNonExistingExtension),
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(GetInstallationModeById(kTargetExtension),
ExtensionManagement::INSTALLATION_BLOCKED);
}
&forced_list_pref, kTargetExtension, kExampleUpdateUrl);
SetPref(true, pref_names::kInstallForceList, forced_list_pref.DeepCopy());
- EXPECT_EQ(extension_management_->ReadById(kTargetExtension).installation_mode,
+ EXPECT_EQ(GetInstallationModeById(kTargetExtension),
ExtensionManagement::INSTALLATION_FORCED);
- EXPECT_EQ(extension_management_->ReadById(kTargetExtension).update_url,
- kExampleUpdateUrl);
- EXPECT_EQ(extension_management_->ReadById(kOtherExtension).installation_mode,
+ CheckAutomaticallyInstalledUpdateUrl(kTargetExtension, kExampleUpdateUrl);
+ EXPECT_EQ(GetInstallationModeById(kNonExistingExtension),
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(GetInstallationModeById(kTargetExtension),
ExtensionManagement::INSTALLATION_ALLOWED);
}
// Verifies the installation mode settings.
EXPECT_TRUE(extension_management_->BlacklistedByDefault());
- EXPECT_EQ(extension_management_->ReadById(kTargetExtension).installation_mode,
+ EXPECT_EQ(GetInstallationModeById(kTargetExtension),
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(GetInstallationModeById(kTargetExtension2),
+ ExtensionManagement::INSTALLATION_FORCED);
+ CheckAutomaticallyInstalledUpdateUrl(kTargetExtension2, kExampleUpdateUrl);
+ EXPECT_EQ(GetInstallationModeById(kTargetExtension3),
+ ExtensionManagement::INSTALLATION_RECOMMENDED);
+ CheckAutomaticallyInstalledUpdateUrl(kTargetExtension3, kExampleUpdateUrl);
+ EXPECT_EQ(GetInstallationModeById(kNonExistingExtension),
ExtensionManagement::INSTALLATION_BLOCKED);
+ EXPECT_EQ(GetInstallationModeByUpdateUrl(kExampleUpdateUrl),
+ ExtensionManagement::INSTALLATION_ALLOWED);
// 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(),
EXPECT_TRUE(std::find(allowed_types.begin(),
allowed_types.end(),
Manifest::TYPE_USER_SCRIPT) != allowed_types.end());
+
+ // Verifies blocked permission list settings.
+ APIPermissionSet api_permission_set;
+ api_permission_set.clear();
+ api_permission_set.insert(APIPermission::kFileSystem);
+ api_permission_set.insert(APIPermission::kDownloads);
+ EXPECT_EQ(api_permission_set,
+ GetBlockedAPIPermissionsById(kNonExistingExtension));
+
+ api_permission_set.clear();
+ api_permission_set.insert(APIPermission::kFileSystem);
+ api_permission_set.insert(APIPermission::kDownloads);
+ api_permission_set.insert(APIPermission::kBookmark);
+ EXPECT_EQ(api_permission_set, GetBlockedAPIPermissionsById(kTargetExtension));
+
+ api_permission_set.clear();
+ api_permission_set.insert(APIPermission::kDownloads);
+ EXPECT_EQ(api_permission_set,
+ GetBlockedAPIPermissionsById(kTargetExtension2));
+
+ api_permission_set.clear();
+ api_permission_set.insert(APIPermission::kFileSystem);
+ api_permission_set.insert(APIPermission::kHistory);
+ EXPECT_EQ(api_permission_set,
+ GetBlockedAPIPermissionsById(kTargetExtension3));
+
+ api_permission_set.clear();
+ api_permission_set.insert(APIPermission::kFileSystem);
+ api_permission_set.insert(APIPermission::kBookmark);
+ EXPECT_EQ(api_permission_set,
+ GetBlockedAPIPermissionsByUpdateUrl(kExampleUpdateUrl));
+}
+
+// Tests the handling of installation mode in case it's specified in both
+// per-extension and per-update-url settings.
+TEST_F(ExtensionManagementServiceTest, InstallationModeConflictHandling) {
+ SetExampleDictPref();
+
+ // Per-extension installation mode settings should always override
+ // per-update-url settings.
+ EXPECT_EQ(GetInstallationMode(kTargetExtension, kExampleUpdateUrl),
+ ExtensionManagement::INSTALLATION_ALLOWED);
+ EXPECT_EQ(GetInstallationMode(kTargetExtension2, kExampleUpdateUrl),
+ ExtensionManagement::INSTALLATION_FORCED);
+ EXPECT_EQ(GetInstallationMode(kTargetExtension3, kExampleUpdateUrl),
+ ExtensionManagement::INSTALLATION_RECOMMENDED);
+}
+
+// Tests the handling of blocked permissions in case it's specified in both
+// per-extension and per-update-url settings.
+TEST_F(ExtensionManagementServiceTest, BlockedPermissionsConflictHandling) {
+ SetExampleDictPref();
+
+ // Both settings should be enforced.
+ APIPermissionSet blocked_permissions_for_update_url;
+ blocked_permissions_for_update_url.insert(APIPermission::kFileSystem);
+ blocked_permissions_for_update_url.insert(APIPermission::kBookmark);
+
+ APIPermissionSet api_permission_set;
+
+ api_permission_set = blocked_permissions_for_update_url;
+ api_permission_set.insert(APIPermission::kFileSystem);
+ api_permission_set.insert(APIPermission::kDownloads);
+ api_permission_set.insert(APIPermission::kBookmark);
+ EXPECT_EQ(api_permission_set,
+ GetBlockedAPIPermissions(kTargetExtension, kExampleUpdateUrl));
+
+ api_permission_set = blocked_permissions_for_update_url;
+ api_permission_set.insert(APIPermission::kDownloads);
+ EXPECT_EQ(api_permission_set,
+ GetBlockedAPIPermissions(kTargetExtension2, kExampleUpdateUrl));
+
+ api_permission_set = blocked_permissions_for_update_url;
+ api_permission_set.insert(APIPermission::kFileSystem);
+ api_permission_set.insert(APIPermission::kHistory);
+ EXPECT_EQ(api_permission_set,
+ GetBlockedAPIPermissions(kTargetExtension3, kExampleUpdateUrl));
}
// Tests functionality of new preference as to deprecate legacy
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(
- extension_management_->ReadGlobalSettings()
- .install_sources.MatchesURL(GURL("https://www.example.com/foo")));
+ EXPECT_TRUE(ReadGlobalSettings()->has_restricted_install_sources);
+ EXPECT_TRUE(ReadGlobalSettings()->install_sources.MatchesURL(
+ GURL("https://www.example.com/foo")));
// Set the new dictionary preference.
{
updater.ClearInstallSources();
}
// Verifies that the new one overrides the legacy ones.
- EXPECT_TRUE(extension_management_->ReadGlobalSettings()
- .has_restricted_install_sources);
- EXPECT_FALSE(
- extension_management_->ReadGlobalSettings()
- .install_sources.MatchesURL(GURL("https://www.example.com/foo")));
+ EXPECT_TRUE(ReadGlobalSettings()->has_restricted_install_sources);
+ EXPECT_FALSE(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(
- GURL("https://corp.mycompany.com/entry")));
+ 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
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.
{
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
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(GetInstallationModeById(kTargetExtension),
ExtensionManagement::INSTALLATION_BLOCKED);
- EXPECT_EQ(extension_management_->ReadById(kOtherExtension).installation_mode,
+ EXPECT_EQ(GetInstallationModeById(kNonExistingExtension),
ExtensionManagement::INSTALLATION_ALLOWED);
// Set legacy preference.
// 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(GetInstallationModeById(kTargetExtension),
ExtensionManagement::INSTALLATION_BLOCKED);
- EXPECT_EQ(
- extension_management_->ReadById(kTargetExtension2).installation_mode,
- ExtensionManagement::INSTALLATION_BLOCKED);
- EXPECT_EQ(extension_management_->ReadById(kOtherExtension).installation_mode,
+ EXPECT_EQ(GetInstallationModeById(kTargetExtension2),
+ ExtensionManagement::INSTALLATION_BLOCKED);
+ EXPECT_EQ(GetInstallationModeById(kNonExistingExtension),
ExtensionManagement::INSTALLATION_ALLOWED);
}
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(GetInstallationModeById(kTargetExtension),
ExtensionManagement::INSTALLATION_ALLOWED);
- EXPECT_EQ(extension_management_->ReadById(kOtherExtension).installation_mode,
+ EXPECT_EQ(GetInstallationModeById(kNonExistingExtension),
ExtensionManagement::INSTALLATION_BLOCKED);
// Set legacy preference.
// 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(GetInstallationModeById(kTargetExtension),
+ ExtensionManagement::INSTALLATION_ALLOWED);
+ EXPECT_EQ(GetInstallationModeById(kTargetExtension2),
ExtensionManagement::INSTALLATION_ALLOWED);
- EXPECT_EQ(
- extension_management_->ReadById(kTargetExtension2).installation_mode,
- ExtensionManagement::INSTALLATION_ALLOWED);
- EXPECT_EQ(extension_management_->ReadById(kOtherExtension).installation_mode,
+ EXPECT_EQ(GetInstallationModeById(kNonExistingExtension),
ExtensionManagement::INSTALLATION_BLOCKED);
}
PrefUpdater updater(pref_service_.get());
updater.SetIndividualExtensionAutoInstalled(
kTargetExtension, kExampleUpdateUrl, true);
- updater.ClearPerExtensionSettings(kOtherExtension);
}
- EXPECT_EQ(extension_management_->ReadById(kTargetExtension).installation_mode,
+ EXPECT_EQ(GetInstallationModeById(kTargetExtension),
ExtensionManagement::INSTALLATION_FORCED);
- EXPECT_EQ(extension_management_->ReadById(kTargetExtension).update_url,
- kExampleUpdateUrl);
- EXPECT_EQ(extension_management_->ReadById(kOtherExtension).installation_mode,
+ CheckAutomaticallyInstalledUpdateUrl(kTargetExtension, kExampleUpdateUrl);
+ EXPECT_EQ(GetInstallationModeById(kNonExistingExtension),
ExtensionManagement::INSTALLATION_ALLOWED);
}
const char* forced = kTargetExtension2;
const char* recommended = kTargetExtension3;
const char* blocked = kTargetExtension4;
- const char* not_specified = kOtherExtension;
+ const char* not_specified = kNonExistingExtension;
// BlacklistedByDefault() is true in example preference.
EXPECT_TRUE(extension_management_->IsInstallationExplicitlyAllowed(allowed));
EXPECT_FALSE(BlacklistedByDefault(NULL));
base::ListValue blacklist;
- blacklist.Append(new base::StringValue(kOtherExtension));
+ blacklist.Append(new base::StringValue(kNonExistingExtension));
EXPECT_FALSE(BlacklistedByDefault(&blacklist));
blacklist.Append(new base::StringValue("*"));
EXPECT_TRUE(BlacklistedByDefault(&blacklist));
projects / platform / framework / web / crosswalk.git / blobdiff