chrome/chrome_cleaner/chrome_utils/extensions_util_unittest.cc - chromium/src.git - Git at Google

 // Copyright 2018 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/chrome_cleaner/chrome_utils/extensions_util.h"

 #include <memory>
 #include <string>
 #include <unordered_set>
 #include <utility>
 #include <vector>

 #include "base/base_paths_win.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/path_service.h"
 #include "base/stl_util.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/scoped_path_override.h"
 #include "base/test/test_reg_util_win.h"
 #include "base/test/test_timeouts.h"
 #include "base/win/registry.h"
 #include "chrome/chrome_cleaner/parsers/json_parser/test_json_parser.h"
 #include "chrome/chrome_cleaner/test/test_extensions.h"
 #include "chrome/chrome_cleaner/test/test_file_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"

 using base::WaitableEvent;

 namespace chrome_cleaner {
 namespace {

 const int kExtensionIdLength = 32;

 struct ExtensionIDHash {
   size_t operator()(const ForceInstalledExtension& extension) const {
     return std::hash<std::string>{}(extension.id.AsString());
   }
 };

 struct ExtensionIDEqual {
   bool operator()(const ForceInstalledExtension& lhs,
                   const ForceInstalledExtension& rhs) const {
     return lhs.id == rhs.id;
   }
 };

 bool ExtensionPolicyRegistryEntryFound(
     TestRegistryEntry test_entry,
     const std::vector<ExtensionPolicyRegistryEntry>& found_policies) {
   for (const ExtensionPolicyRegistryEntry& policy : found_policies) {
     base::string16 test_entry_value(test_entry.value);
     if (policy.extension_id == test_entry_value.substr(0, kExtensionIdLength) &&
         policy.hkey == test_entry.hkey && policy.path == test_entry.path &&
         policy.name == test_entry.name) {
       return true;
     }
   }
   return false;
 }

 }  // namespace

 TEST(ExtensionsUtilTest, GetExtensionForcelistRegistryPolicies) {
   registry_util::RegistryOverrideManager registry_override;
   registry_override.OverrideRegistry(HKEY_CURRENT_USER);
   registry_override.OverrideRegistry(HKEY_LOCAL_MACHINE);
   for (const TestRegistryEntry& policy : kExtensionForcelistEntries) {
     base::win::RegKey policy_key;
     ASSERT_EQ(ERROR_SUCCESS, policy_key.Create(policy.hkey, policy.path.c_str(),
                                                KEY_ALL_ACCESS));
     ASSERT_TRUE(policy_key.Valid());
     ASSERT_EQ(ERROR_SUCCESS,
               policy_key.WriteValue(policy.name.c_str(), policy.value.c_str()));
   }

   std::vector<ExtensionPolicyRegistryEntry> policies;
   GetExtensionForcelistRegistryPolicies(&policies);

   for (const TestRegistryEntry& expected_result : kExtensionForcelistEntries) {
     EXPECT_TRUE(ExtensionPolicyRegistryEntryFound(expected_result, policies));
   }
 }

 TEST(ExtensionsUtilTest, RemoveForcelistPolicyExtensions) {
   registry_util::RegistryOverrideManager registry_override;
   registry_override.OverrideRegistry(HKEY_CURRENT_USER);
   registry_override.OverrideRegistry(HKEY_LOCAL_MACHINE);
   for (const TestRegistryEntry& policy : kExtensionForcelistEntries) {
     base::win::RegKey policy_key;
     ASSERT_EQ(ERROR_SUCCESS, policy_key.Create(policy.hkey, policy.path.c_str(),
                                                KEY_ALL_ACCESS));
     DCHECK(policy_key.Valid());
     ASSERT_EQ(ERROR_SUCCESS,
               policy_key.WriteValue(policy.name.c_str(), policy.value.c_str()));
     base::string16 value;
     policy_key.ReadValue(policy.name.c_str(), &value);
     ASSERT_EQ(value, policy.value);
   }

   std::vector<ForceInstalledExtension> extensions;
   std::vector<ExtensionPolicyRegistryEntry> policies;
   GetExtensionForcelistRegistryPolicies(&policies);
   for (ExtensionPolicyRegistryEntry& policy : policies) {
     ForceInstalledExtension extension(
         ExtensionID::Create(base::UTF16ToUTF8(policy.extension_id)).value(),
         POLICY_EXTENSION_FORCELIST, "", "");
     extension.policy_registry_entry =
         std::make_shared<ExtensionPolicyRegistryEntry>(std::move(policy));
     extensions.push_back(extension);
   }

   for (ForceInstalledExtension& extension : extensions) {
     base::win::RegKey policy_key;
     ASSERT_TRUE(RemoveForcelistPolicyExtension(extension));
     ASSERT_EQ(ERROR_SUCCESS,
               policy_key.Open(extension.policy_registry_entry->hkey,
                               extension.policy_registry_entry->path.c_str(),
                               KEY_READ));
     base::string16 value;
     policy_key.ReadValue(extension.policy_registry_entry->name.c_str(), &value);
     ASSERT_EQ(value, L"");
   }
 }

 TEST(ExtensionsUtilTest, GetNonWhitelistedDefaultExtensions) {
   // Set up a fake default extensions JSON file.
   base::ScopedPathOverride program_files_override(base::DIR_PROGRAM_FILES);
   base::FilePath program_files_dir;
   ASSERT_TRUE(
       base::PathService::Get(base::DIR_PROGRAM_FILES, &program_files_dir));

   base::FilePath fake_apps_dir(
       program_files_dir.Append(kFakeChromeFolder).Append(L"default_apps"));
   ASSERT_TRUE(base::CreateDirectoryAndGetError(fake_apps_dir, nullptr));

   base::FilePath default_extensions_file =
       fake_apps_dir.Append(L"external_extensions.json");
   CreateFileWithContent(default_extensions_file, kDefaultExtensionsJson,
                         sizeof(kDefaultExtensionsJson) - 1);
   ASSERT_TRUE(base::PathExists(default_extensions_file));

   // Set up an invalid default extensions JSON file
   base::ScopedPathOverride program_files_x86_override(
       base::DIR_PROGRAM_FILESX86);
   ASSERT_TRUE(
       base::PathService::Get(base::DIR_PROGRAM_FILESX86, &program_files_dir));

   fake_apps_dir =
       program_files_dir.Append(kFakeChromeFolder).Append(L"default_apps");
   ASSERT_TRUE(base::CreateDirectoryAndGetError(fake_apps_dir, nullptr));

   default_extensions_file = fake_apps_dir.Append(L"external_extensions.json");
   CreateFileWithContent(default_extensions_file, kInvalidDefaultExtensionsJson,
                         sizeof(kInvalidDefaultExtensionsJson) - 1);
   ASSERT_TRUE(base::PathExists(default_extensions_file));

   TestJsonParser json_parser;
   std::vector<ExtensionPolicyFile> policies;
   base::WaitableEvent done(WaitableEvent::ResetPolicy::MANUAL,
                            WaitableEvent::InitialState::NOT_SIGNALED);
   GetNonWhitelistedDefaultExtensions(&json_parser, &policies, &done);
   ASSERT_TRUE(done.TimedWait(TestTimeouts::action_timeout()));

   const base::string16 expected_extension_ids[] = {kTestExtensionId1,
                                                    kTestExtensionId2};
   ASSERT_EQ(base::size(expected_extension_ids), policies.size());
   const base::string16 found_extension_ids[] = {policies[0].extension_id,
                                                 policies[1].extension_id};
   EXPECT_THAT(expected_extension_ids,
               ::testing::UnorderedElementsAreArray(found_extension_ids));
 }

 TEST(ExtensionsUtilTest, RemoveNonWhitelistedDefaultExtensions) {
   // Set up a fake default extensions JSON file.
   base::ScopedPathOverride program_files_override(base::DIR_PROGRAM_FILES);
   base::FilePath program_files_dir;
   ASSERT_TRUE(
       base::PathService::Get(base::DIR_PROGRAM_FILES, &program_files_dir));

   base::FilePath fake_apps_dir(
       program_files_dir.Append(kFakeChromeFolder).Append(L"default_apps"));
   ASSERT_TRUE(base::CreateDirectoryAndGetError(fake_apps_dir, nullptr));

   base::FilePath default_extensions_file =
       fake_apps_dir.Append(L"external_extensions.json");
   CreateFileWithContent(default_extensions_file, kDefaultExtensionsJson,
                         sizeof(kDefaultExtensionsJson) - 1);
   ASSERT_TRUE(base::PathExists(default_extensions_file));

   // Set up an invalid default extensions JSON file
   base::ScopedPathOverride program_files_x86_override(
       base::DIR_PROGRAM_FILESX86);
   ASSERT_TRUE(
       base::PathService::Get(base::DIR_PROGRAM_FILESX86, &program_files_dir));

   fake_apps_dir =
       program_files_dir.Append(kFakeChromeFolder).Append(L"default_apps");
   ASSERT_TRUE(base::CreateDirectoryAndGetError(fake_apps_dir, nullptr));

   default_extensions_file = fake_apps_dir.Append(L"external_extensions.json");
   CreateFileWithContent(default_extensions_file, kInvalidDefaultExtensionsJson,
                         sizeof(kInvalidDefaultExtensionsJson) - 1);
   ASSERT_TRUE(base::PathExists(default_extensions_file));

   TestJsonParser json_parser;
   std::vector<ExtensionPolicyFile> policies;
   base::WaitableEvent done(WaitableEvent::ResetPolicy::MANUAL,
                            WaitableEvent::InitialState::NOT_SIGNALED);
   GetNonWhitelistedDefaultExtensions(&json_parser, &policies, &done);
   ASSERT_TRUE(done.TimedWait(TestTimeouts::action_timeout()));

   std::vector<ForceInstalledExtension> extensions;
   for (ExtensionPolicyFile& policy : policies) {
     ForceInstalledExtension extension(
         ExtensionID::Create(base::UTF16ToUTF8(policy.extension_id)).value(),
         DEFAULT_APPS_EXTENSION, "", "");
     extension.policy_file =
         std::make_shared<ExtensionPolicyFile>(std::move(policy));
     extensions.push_back(extension);
   }
   base::Value json_result = extensions[0].policy_file->json->data.Clone();
   for (ForceInstalledExtension& extension : extensions) {
     ASSERT_TRUE(RemoveDefaultExtension(extension, &json_result));
   }
   std::string result;
   JSONStringValueSerializer serializer(&result);
   ASSERT_TRUE(serializer.Serialize(json_result));
   ASSERT_EQ(result, kValidDefaultExtensionsJson);
   base::Value original = json_result.Clone();
   for (ForceInstalledExtension& extension : extensions) {
     ASSERT_FALSE(RemoveDefaultExtension(extension, &json_result));
     ASSERT_EQ(original, json_result);
   }
 }

 TEST(ExtensionsUtilTest, GetNonWhitelistedDefaultExtensionsNoFilesFound) {
   base::ScopedPathOverride program_files_override(base::DIR_PROGRAM_FILES);
   base::ScopedPathOverride program_files_x86_override(
       base::DIR_PROGRAM_FILESX86);

   TestJsonParser json_parser;
   std::vector<ExtensionPolicyFile> policies;
   base::WaitableEvent done(WaitableEvent::ResetPolicy::MANUAL,
                            WaitableEvent::InitialState::NOT_SIGNALED);
   GetNonWhitelistedDefaultExtensions(&json_parser, &policies, &done);
   ASSERT_TRUE(done.TimedWait(TestTimeouts::action_timeout()));

   size_t expected_policies_found = 0;
   ASSERT_EQ(expected_policies_found, policies.size());
 }

 TEST(ExtensionsUtilTest, GetExtensionSettingsForceInstalledExtensions) {
   registry_util::RegistryOverrideManager registry_override;
   registry_override.OverrideRegistry(HKEY_CURRENT_USER);
   registry_override.OverrideRegistry(HKEY_LOCAL_MACHINE);

   base::win::RegKey settings_key;
   ASSERT_EQ(ERROR_SUCCESS,
             settings_key.Create(HKEY_LOCAL_MACHINE,
                                 kExtensionSettingsPolicyPath, KEY_ALL_ACCESS));
   ASSERT_TRUE(settings_key.Valid());
   ASSERT_EQ(ERROR_SUCCESS,
             settings_key.WriteValue(kExtensionSettingsName,
                                     kExtensionSettingsJsonOnlyForced));

   TestJsonParser json_parser;
   std::vector<ExtensionPolicyRegistryEntry> policies;
   base::WaitableEvent done(WaitableEvent::ResetPolicy::MANUAL,
                            WaitableEvent::InitialState::NOT_SIGNALED);
   GetExtensionSettingsForceInstalledExtensions(&json_parser, &policies, &done);
   ASSERT_TRUE(done.TimedWait(TestTimeouts::action_timeout()));

   // Check that only the two force installed extensions were found
   const base::string16 expected_extension_ids[] = {kTestExtensionId4,
                                                    kTestExtensionId5};
   const base::string16 found_extension_ids[] = {policies[0].extension_id,
                                                 policies[1].extension_id};
   EXPECT_THAT(expected_extension_ids,
               ::testing::UnorderedElementsAreArray(found_extension_ids));

   // Also check that the collected registry entries match the values in the
   // registry.
   for (const ExtensionPolicyRegistryEntry& policy : policies) {
     EXPECT_EQ(policy.hkey, HKEY_LOCAL_MACHINE);
     EXPECT_EQ(policy.path, kExtensionSettingsPolicyPath);
     EXPECT_EQ(policy.name, kExtensionSettingsName);
   }
 }

 TEST(ExtensionsUtilTest, RemoveExtensionSettingsForceInstalledExtensions) {
   registry_util::RegistryOverrideManager registry_override;
   registry_override.OverrideRegistry(HKEY_CURRENT_USER);
   registry_override.OverrideRegistry(HKEY_LOCAL_MACHINE);

   base::win::RegKey settings_key;
   ASSERT_EQ(ERROR_SUCCESS,
             settings_key.Create(HKEY_LOCAL_MACHINE,
                                 kExtensionSettingsPolicyPath, KEY_ALL_ACCESS));
   DCHECK(settings_key.Valid());
   ASSERT_EQ(ERROR_SUCCESS,
             settings_key.WriteValue(kExtensionSettingsName,
                                     kExtensionSettingsJsonOnlyForced));

   TestJsonParser json_parser;
   std::vector<ExtensionPolicyRegistryEntry> policies;
   base::WaitableEvent done(WaitableEvent::ResetPolicy::MANUAL,
                            WaitableEvent::InitialState::NOT_SIGNALED);
   GetExtensionSettingsForceInstalledExtensions(&json_parser, &policies, &done);
   ASSERT_TRUE(done.TimedWait(TestTimeouts::action_timeout()));

   std::unordered_set<ForceInstalledExtension, ExtensionIDHash, ExtensionIDEqual>
       extensions;
   base::Value json_result = policies[0].json->data.Clone();
   for (ExtensionPolicyRegistryEntry& policy : policies) {
     ForceInstalledExtension extension(
         ExtensionID::Create(base::UTF16ToUTF8(policy.extension_id)).value(),
         POLICY_EXTENSION_SETTINGS, "", "");
     extension.policy_registry_entry =
         std::make_shared<ExtensionPolicyRegistryEntry>(std::move(policy));
     extensions.insert(extension);
   }

   for (const ForceInstalledExtension& extension : extensions) {
     ASSERT_TRUE(
         RemoveExtensionSettingsPoliciesExtension(extension, &json_result));
   }
   std::string result;
   JSONStringValueSerializer serializer(&result);
   ASSERT_TRUE(serializer.Serialize(json_result));
   ASSERT_EQ(result, "{}");
   base::Value original = json_result.Clone();
   for (const ForceInstalledExtension& extension : extensions) {
     ASSERT_FALSE(
         RemoveExtensionSettingsPoliciesExtension(extension, &json_result));
     ASSERT_EQ(original, json_result);
   }
 }

 TEST(ExtensionsUtilTest, RemoveSomeExtensionSettingsForceInstalledExtensions) {
   registry_util::RegistryOverrideManager registry_override;
   registry_override.OverrideRegistry(HKEY_CURRENT_USER);
   registry_override.OverrideRegistry(HKEY_LOCAL_MACHINE);

   base::win::RegKey settings_key;
   ASSERT_EQ(ERROR_SUCCESS,
             settings_key.Create(HKEY_LOCAL_MACHINE,
                                 kExtensionSettingsPolicyPath, KEY_ALL_ACCESS));
   DCHECK(settings_key.Valid());
   ASSERT_EQ(ERROR_SUCCESS, settings_key.WriteValue(kExtensionSettingsName,
                                                    kExtensionSettingsJson));

   TestJsonParser json_parser;
   std::vector<ExtensionPolicyRegistryEntry> policies;
   base::WaitableEvent done(WaitableEvent::ResetPolicy::MANUAL,
                            WaitableEvent::InitialState::NOT_SIGNALED);
   GetExtensionSettingsForceInstalledExtensions(&json_parser, &policies, &done);
   ASSERT_TRUE(done.TimedWait(TestTimeouts::action_timeout()));

   std::unordered_set<ForceInstalledExtension, ExtensionIDHash, ExtensionIDEqual>
       extensions;
   base::Value json_result = policies[0].json->data.Clone();
   for (ExtensionPolicyRegistryEntry& policy : policies) {
     ForceInstalledExtension extension(
         ExtensionID::Create(base::UTF16ToUTF8(policy.extension_id)).value(),
         POLICY_EXTENSION_SETTINGS, "", "");
     extension.policy_registry_entry =
         std::make_shared<ExtensionPolicyRegistryEntry>(std::move(policy));
     extensions.insert(extension);
   }

   for (const ForceInstalledExtension& extension : extensions) {
     ASSERT_TRUE(
         RemoveExtensionSettingsPoliciesExtension(extension, &json_result));
   }
   std::string result;
   JSONStringValueSerializer serializer(&result);
   ASSERT_TRUE(serializer.Serialize(json_result));
   ASSERT_EQ(result, kValidExtensionSettingsJson);
   base::Value original = json_result.Clone();
   for (const ForceInstalledExtension& extension : extensions) {
     ASSERT_FALSE(
         RemoveExtensionSettingsPoliciesExtension(extension, &json_result));
     ASSERT_EQ(original, json_result);
   }
 }

 TEST(ExtensionsUtilTest,
      GetExtensionSettingsForceInstalledExtensionsNoneFound) {
   registry_util::RegistryOverrideManager registry_override;
   registry_override.OverrideRegistry(HKEY_CURRENT_USER);
   registry_override.OverrideRegistry(HKEY_LOCAL_MACHINE);

   TestJsonParser json_parser;
   std::vector<ExtensionPolicyRegistryEntry> policies;
   base::WaitableEvent done(WaitableEvent::ResetPolicy::MANUAL,
                            WaitableEvent::InitialState::NOT_SIGNALED);
   GetExtensionSettingsForceInstalledExtensions(&json_parser, &policies, &done);
   ASSERT_TRUE(done.TimedWait(TestTimeouts::action_timeout()));

   size_t expected_policies_found = 0;
   ASSERT_EQ(expected_policies_found, policies.size());
 }

 TEST(ExtensionsUtilTest, GetMasterPreferencesExtensions) {
   // Set up a fake master preferences JSON file.
   base::ScopedPathOverride program_files_override(base::DIR_PROGRAM_FILES);
   base::FilePath program_files_dir;
   ASSERT_TRUE(
       base::PathService::Get(base::DIR_PROGRAM_FILES, &program_files_dir));

   base::FilePath chrome_dir(program_files_dir.Append(kChromeExePath));
   ASSERT_TRUE(base::CreateDirectoryAndGetError(chrome_dir, nullptr));

   base::FilePath master_preferences =
       chrome_dir.Append(kMasterPreferencesFileName);
   CreateFileWithContent(master_preferences, kMasterPreferencesJson,
                         sizeof(kMasterPreferencesJson) - 1);
   ASSERT_TRUE(base::PathExists(master_preferences));

   TestJsonParser json_parser;
   std::vector<ExtensionPolicyFile> policies;
   base::WaitableEvent done(WaitableEvent::ResetPolicy::MANUAL,
                            WaitableEvent::InitialState::NOT_SIGNALED);
   GetMasterPreferencesExtensions(&json_parser, &policies, &done);
   ASSERT_TRUE(done.TimedWait(TestTimeouts::action_timeout()));

   const base::string16 expected_extension_ids[] = {kTestExtensionId6,
                                                    kTestExtensionId7};
   ASSERT_EQ(base::size(expected_extension_ids), policies.size());
   const base::string16 found_extension_ids[] = {policies[0].extension_id,
                                                 policies[1].extension_id};
   EXPECT_THAT(expected_extension_ids,
               ::testing::UnorderedElementsAreArray(found_extension_ids));
 }

 TEST(ExtensionsUtilTest, RemoveMasterPreferencesExtensionsNoneFound) {
   // Set up a fake master preferences JSON file.
   base::ScopedPathOverride program_files_override(base::DIR_PROGRAM_FILES);
   base::FilePath program_files_dir;
   ASSERT_TRUE(
       base::PathService::Get(base::DIR_PROGRAM_FILES, &program_files_dir));

   base::FilePath chrome_dir(program_files_dir.Append(kChromeExePath));
   ASSERT_TRUE(base::CreateDirectoryAndGetError(chrome_dir, nullptr));

   base::FilePath master_preferences =
       chrome_dir.Append(kMasterPreferencesFileName);
   CreateFileWithContent(master_preferences, kMasterPreferencesJson,
                         sizeof(kMasterPreferencesJson) - 1);
   ASSERT_TRUE(base::PathExists(master_preferences));

   TestJsonParser json_parser;
   std::vector<ExtensionPolicyFile> policies;
   base::WaitableEvent done(WaitableEvent::ResetPolicy::MANUAL,
                            WaitableEvent::InitialState::NOT_SIGNALED);
   GetMasterPreferencesExtensions(&json_parser, &policies, &done);
   ASSERT_TRUE(done.TimedWait(TestTimeouts::action_timeout()));

   std::vector<ForceInstalledExtension> extensions;
   for (ExtensionPolicyFile& policy : policies) {
     ForceInstalledExtension extension(
         ExtensionID::Create(base::UTF16ToUTF8(policy.extension_id)).value(),
         POLICY_MASTER_PREFERENCES, "", "");
     extension.policy_file =
         std::make_shared<ExtensionPolicyFile>(std::move(policy));
     extensions.push_back(extension);
   }
   base::Value json_result = extensions[0].policy_file->json->data.Clone();
   for (ForceInstalledExtension& extension : extensions) {
     ASSERT_TRUE(RemoveMasterPreferencesExtension(extension, &json_result));
   }
   std::string result;
   JSONStringValueSerializer serializer(&result);
   ASSERT_TRUE(serializer.Serialize(json_result));
   ASSERT_EQ(result, kValidMasterPreferencesJson);
 }

 TEST(ExtensionsUtilTest, GetMasterPreferencesExtensionsNoneFound) {
   // Set up a fake master preferences JSON file.
   base::ScopedPathOverride program_files_override(base::DIR_PROGRAM_FILES);
   base::FilePath program_files_dir;
   ASSERT_TRUE(
       base::PathService::Get(base::DIR_PROGRAM_FILES, &program_files_dir));

   base::FilePath chrome_dir(program_files_dir.Append(kChromeExePath));
   ASSERT_TRUE(base::CreateDirectoryAndGetError(chrome_dir, nullptr));

   base::FilePath master_preferences =
       chrome_dir.Append(kMasterPreferencesFileName);
   CreateFileWithContent(master_preferences, kMasterPreferencesJsonNoExtensions,
                         sizeof(kMasterPreferencesJsonNoExtensions) - 1);
   ASSERT_TRUE(base::PathExists(master_preferences));

   TestJsonParser json_parser;
   std::vector<ExtensionPolicyFile> policies;
   base::WaitableEvent done(WaitableEvent::ResetPolicy::MANUAL,
                            WaitableEvent::InitialState::NOT_SIGNALED);
   GetMasterPreferencesExtensions(&json_parser, &policies, &done);
   ASSERT_TRUE(done.TimedWait(TestTimeouts::action_timeout()));

   size_t expected_policies_found = 0;
   ASSERT_EQ(expected_policies_found, policies.size());
 }

 }  // namespace chrome_cleaner
	// Copyright 2018 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/chrome_cleaner/chrome_utils/extensions_util.h"

	#include <memory>
	#include <string>
	#include <unordered_set>
	#include <utility>
	#include <vector>

	#include "base/base_paths_win.h"
	#include "base/files/file_path.h"
	#include "base/files/file_util.h"
	#include "base/json/json_string_value_serializer.h"
	#include "base/path_service.h"
	#include "base/stl_util.h"
	#include "base/strings/string16.h"
	#include "base/strings/utf_string_conversions.h"
	#include "base/synchronization/waitable_event.h"
	#include "base/test/scoped_path_override.h"
	#include "base/test/test_reg_util_win.h"
	#include "base/test/test_timeouts.h"
	#include "base/win/registry.h"
	#include "chrome/chrome_cleaner/parsers/json_parser/test_json_parser.h"
	#include "chrome/chrome_cleaner/test/test_extensions.h"
	#include "chrome/chrome_cleaner/test/test_file_util.h"
	#include "testing/gmock/include/gmock/gmock.h"
	#include "testing/gtest/include/gtest/gtest.h"

	using base::WaitableEvent;

	namespace chrome_cleaner {
	namespace {

	const int kExtensionIdLength = 32;

	struct ExtensionIDHash {
	size_t operator()(const ForceInstalledExtension& extension) const {
	return std::hash<std::string>{}(extension.id.AsString());
	}
	};

	struct ExtensionIDEqual {
	bool operator()(const ForceInstalledExtension& lhs,
	const ForceInstalledExtension& rhs) const {
	return lhs.id == rhs.id;
	}
	};

	bool ExtensionPolicyRegistryEntryFound(
	TestRegistryEntry test_entry,
	const std::vector<ExtensionPolicyRegistryEntry>& found_policies) {
	for (const ExtensionPolicyRegistryEntry& policy : found_policies) {
	base::string16 test_entry_value(test_entry.value);
	if (policy.extension_id == test_entry_value.substr(0, kExtensionIdLength) &&
	policy.hkey == test_entry.hkey && policy.path == test_entry.path &&
	policy.name == test_entry.name) {
	return true;
	}
	}
	return false;
	}

	} // namespace

	TEST(ExtensionsUtilTest, GetExtensionForcelistRegistryPolicies) {
	registry_util::RegistryOverrideManager registry_override;
	registry_override.OverrideRegistry(HKEY_CURRENT_USER);
	registry_override.OverrideRegistry(HKEY_LOCAL_MACHINE);
	for (const TestRegistryEntry& policy : kExtensionForcelistEntries) {
	base::win::RegKey policy_key;
	ASSERT_EQ(ERROR_SUCCESS, policy_key.Create(policy.hkey, policy.path.c_str(),
	KEY_ALL_ACCESS));
	ASSERT_TRUE(policy_key.Valid());
	ASSERT_EQ(ERROR_SUCCESS,
	policy_key.WriteValue(policy.name.c_str(), policy.value.c_str()));
	}

	std::vector<ExtensionPolicyRegistryEntry> policies;
	GetExtensionForcelistRegistryPolicies(&policies);

	for (const TestRegistryEntry& expected_result : kExtensionForcelistEntries) {
	EXPECT_TRUE(ExtensionPolicyRegistryEntryFound(expected_result, policies));
	}
	}

	TEST(ExtensionsUtilTest, RemoveForcelistPolicyExtensions) {
	registry_util::RegistryOverrideManager registry_override;
	registry_override.OverrideRegistry(HKEY_CURRENT_USER);
	registry_override.OverrideRegistry(HKEY_LOCAL_MACHINE);
	for (const TestRegistryEntry& policy : kExtensionForcelistEntries) {
	base::win::RegKey policy_key;
	ASSERT_EQ(ERROR_SUCCESS, policy_key.Create(policy.hkey, policy.path.c_str(),
	KEY_ALL_ACCESS));
	DCHECK(policy_key.Valid());
	ASSERT_EQ(ERROR_SUCCESS,
	policy_key.WriteValue(policy.name.c_str(), policy.value.c_str()));
	base::string16 value;
	policy_key.ReadValue(policy.name.c_str(), &value);
	ASSERT_EQ(value, policy.value);
	}

	std::vector<ForceInstalledExtension> extensions;
	std::vector<ExtensionPolicyRegistryEntry> policies;
	GetExtensionForcelistRegistryPolicies(&policies);
	for (ExtensionPolicyRegistryEntry& policy : policies) {
	ForceInstalledExtension extension(
	ExtensionID::Create(base::UTF16ToUTF8(policy.extension_id)).value(),
	POLICY_EXTENSION_FORCELIST, "", "");
	extension.policy_registry_entry =
	std::make_shared<ExtensionPolicyRegistryEntry>(std::move(policy));
	extensions.push_back(extension);
	}

	for (ForceInstalledExtension& extension : extensions) {
	base::win::RegKey policy_key;
	ASSERT_TRUE(RemoveForcelistPolicyExtension(extension));
	ASSERT_EQ(ERROR_SUCCESS,
	policy_key.Open(extension.policy_registry_entry->hkey,
	extension.policy_registry_entry->path.c_str(),
	KEY_READ));
	base::string16 value;
	policy_key.ReadValue(extension.policy_registry_entry->name.c_str(), &value);
	ASSERT_EQ(value, L"");
	}
	}

	TEST(ExtensionsUtilTest, GetNonWhitelistedDefaultExtensions) {
	// Set up a fake default extensions JSON file.
	base::ScopedPathOverride program_files_override(base::DIR_PROGRAM_FILES);
	base::FilePath program_files_dir;
	ASSERT_TRUE(
	base::PathService::Get(base::DIR_PROGRAM_FILES, &program_files_dir));

	base::FilePath fake_apps_dir(
	program_files_dir.Append(kFakeChromeFolder).Append(L"default_apps"));
	ASSERT_TRUE(base::CreateDirectoryAndGetError(fake_apps_dir, nullptr));

	base::FilePath default_extensions_file =
	fake_apps_dir.Append(L"external_extensions.json");
	CreateFileWithContent(default_extensions_file, kDefaultExtensionsJson,
	sizeof(kDefaultExtensionsJson) - 1);
	ASSERT_TRUE(base::PathExists(default_extensions_file));

	// Set up an invalid default extensions JSON file
	base::ScopedPathOverride program_files_x86_override(
	base::DIR_PROGRAM_FILESX86);
	ASSERT_TRUE(
	base::PathService::Get(base::DIR_PROGRAM_FILESX86, &program_files_dir));

	fake_apps_dir =
	program_files_dir.Append(kFakeChromeFolder).Append(L"default_apps");
	ASSERT_TRUE(base::CreateDirectoryAndGetError(fake_apps_dir, nullptr));

	default_extensions_file = fake_apps_dir.Append(L"external_extensions.json");
	CreateFileWithContent(default_extensions_file, kInvalidDefaultExtensionsJson,
	sizeof(kInvalidDefaultExtensionsJson) - 1);
	ASSERT_TRUE(base::PathExists(default_extensions_file));

	TestJsonParser json_parser;
	std::vector<ExtensionPolicyFile> policies;
	base::WaitableEvent done(WaitableEvent::ResetPolicy::MANUAL,
	WaitableEvent::InitialState::NOT_SIGNALED);
	GetNonWhitelistedDefaultExtensions(&json_parser, &policies, &done);
	ASSERT_TRUE(done.TimedWait(TestTimeouts::action_timeout()));

	const base::string16 expected_extension_ids[] = {kTestExtensionId1,
	kTestExtensionId2};
	ASSERT_EQ(base::size(expected_extension_ids), policies.size());
	const base::string16 found_extension_ids[] = {policies[0].extension_id,
	policies[1].extension_id};
	EXPECT_THAT(expected_extension_ids,
	::testing::UnorderedElementsAreArray(found_extension_ids));
	}

	TEST(ExtensionsUtilTest, RemoveNonWhitelistedDefaultExtensions) {
	// Set up a fake default extensions JSON file.
	base::ScopedPathOverride program_files_override(base::DIR_PROGRAM_FILES);
	base::FilePath program_files_dir;
	ASSERT_TRUE(
	base::PathService::Get(base::DIR_PROGRAM_FILES, &program_files_dir));

	base::FilePath fake_apps_dir(
	program_files_dir.Append(kFakeChromeFolder).Append(L"default_apps"));
	ASSERT_TRUE(base::CreateDirectoryAndGetError(fake_apps_dir, nullptr));

	base::FilePath default_extensions_file =
	fake_apps_dir.Append(L"external_extensions.json");
	CreateFileWithContent(default_extensions_file, kDefaultExtensionsJson,
	sizeof(kDefaultExtensionsJson) - 1);
	ASSERT_TRUE(base::PathExists(default_extensions_file));

	// Set up an invalid default extensions JSON file
	base::ScopedPathOverride program_files_x86_override(
	base::DIR_PROGRAM_FILESX86);
	ASSERT_TRUE(
	base::PathService::Get(base::DIR_PROGRAM_FILESX86, &program_files_dir));

	fake_apps_dir =
	program_files_dir.Append(kFakeChromeFolder).Append(L"default_apps");
	ASSERT_TRUE(base::CreateDirectoryAndGetError(fake_apps_dir, nullptr));

	default_extensions_file = fake_apps_dir.Append(L"external_extensions.json");
	CreateFileWithContent(default_extensions_file, kInvalidDefaultExtensionsJson,
	sizeof(kInvalidDefaultExtensionsJson) - 1);
	ASSERT_TRUE(base::PathExists(default_extensions_file));

	TestJsonParser json_parser;
	std::vector<ExtensionPolicyFile> policies;
	base::WaitableEvent done(WaitableEvent::ResetPolicy::MANUAL,
	WaitableEvent::InitialState::NOT_SIGNALED);
	GetNonWhitelistedDefaultExtensions(&json_parser, &policies, &done);
	ASSERT_TRUE(done.TimedWait(TestTimeouts::action_timeout()));

	std::vector<ForceInstalledExtension> extensions;
	for (ExtensionPolicyFile& policy : policies) {
	ForceInstalledExtension extension(
	ExtensionID::Create(base::UTF16ToUTF8(policy.extension_id)).value(),
	DEFAULT_APPS_EXTENSION, "", "");
	extension.policy_file =
	std::make_shared<ExtensionPolicyFile>(std::move(policy));
	extensions.push_back(extension);
	}
	base::Value json_result = extensions[0].policy_file->json->data.Clone();
	for (ForceInstalledExtension& extension : extensions) {
	ASSERT_TRUE(RemoveDefaultExtension(extension, &json_result));
	}
	std::string result;
	JSONStringValueSerializer serializer(&result);
	ASSERT_TRUE(serializer.Serialize(json_result));
	ASSERT_EQ(result, kValidDefaultExtensionsJson);
	base::Value original = json_result.Clone();
	for (ForceInstalledExtension& extension : extensions) {
	ASSERT_FALSE(RemoveDefaultExtension(extension, &json_result));
	ASSERT_EQ(original, json_result);
	}
	}

	TEST(ExtensionsUtilTest, GetNonWhitelistedDefaultExtensionsNoFilesFound) {
	base::ScopedPathOverride program_files_override(base::DIR_PROGRAM_FILES);
	base::ScopedPathOverride program_files_x86_override(
	base::DIR_PROGRAM_FILESX86);

	TestJsonParser json_parser;
	std::vector<ExtensionPolicyFile> policies;
	base::WaitableEvent done(WaitableEvent::ResetPolicy::MANUAL,
	WaitableEvent::InitialState::NOT_SIGNALED);
	GetNonWhitelistedDefaultExtensions(&json_parser, &policies, &done);
	ASSERT_TRUE(done.TimedWait(TestTimeouts::action_timeout()));

	size_t expected_policies_found = 0;
	ASSERT_EQ(expected_policies_found, policies.size());
	}

	TEST(ExtensionsUtilTest, GetExtensionSettingsForceInstalledExtensions) {
	registry_util::RegistryOverrideManager registry_override;
	registry_override.OverrideRegistry(HKEY_CURRENT_USER);
	registry_override.OverrideRegistry(HKEY_LOCAL_MACHINE);

	base::win::RegKey settings_key;
	ASSERT_EQ(ERROR_SUCCESS,
	settings_key.Create(HKEY_LOCAL_MACHINE,
	kExtensionSettingsPolicyPath, KEY_ALL_ACCESS));
	ASSERT_TRUE(settings_key.Valid());
	ASSERT_EQ(ERROR_SUCCESS,
	settings_key.WriteValue(kExtensionSettingsName,
	kExtensionSettingsJsonOnlyForced));

	TestJsonParser json_parser;
	std::vector<ExtensionPolicyRegistryEntry> policies;
	base::WaitableEvent done(WaitableEvent::ResetPolicy::MANUAL,
	WaitableEvent::InitialState::NOT_SIGNALED);
	GetExtensionSettingsForceInstalledExtensions(&json_parser, &policies, &done);
	ASSERT_TRUE(done.TimedWait(TestTimeouts::action_timeout()));

	// Check that only the two force installed extensions were found
	const base::string16 expected_extension_ids[] = {kTestExtensionId4,
	kTestExtensionId5};
	const base::string16 found_extension_ids[] = {policies[0].extension_id,
	policies[1].extension_id};
	EXPECT_THAT(expected_extension_ids,
	::testing::UnorderedElementsAreArray(found_extension_ids));

	// Also check that the collected registry entries match the values in the
	// registry.
	for (const ExtensionPolicyRegistryEntry& policy : policies) {
	EXPECT_EQ(policy.hkey, HKEY_LOCAL_MACHINE);
	EXPECT_EQ(policy.path, kExtensionSettingsPolicyPath);
	EXPECT_EQ(policy.name, kExtensionSettingsName);
	}
	}

	TEST(ExtensionsUtilTest, RemoveExtensionSettingsForceInstalledExtensions) {
	registry_util::RegistryOverrideManager registry_override;
	registry_override.OverrideRegistry(HKEY_CURRENT_USER);
	registry_override.OverrideRegistry(HKEY_LOCAL_MACHINE);

	base::win::RegKey settings_key;
	ASSERT_EQ(ERROR_SUCCESS,
	settings_key.Create(HKEY_LOCAL_MACHINE,
	kExtensionSettingsPolicyPath, KEY_ALL_ACCESS));
	DCHECK(settings_key.Valid());
	ASSERT_EQ(ERROR_SUCCESS,
	settings_key.WriteValue(kExtensionSettingsName,
	kExtensionSettingsJsonOnlyForced));

	TestJsonParser json_parser;
	std::vector<ExtensionPolicyRegistryEntry> policies;
	base::WaitableEvent done(WaitableEvent::ResetPolicy::MANUAL,
	WaitableEvent::InitialState::NOT_SIGNALED);
	GetExtensionSettingsForceInstalledExtensions(&json_parser, &policies, &done);
	ASSERT_TRUE(done.TimedWait(TestTimeouts::action_timeout()));

	std::unordered_set<ForceInstalledExtension, ExtensionIDHash, ExtensionIDEqual>
	extensions;
	base::Value json_result = policies[0].json->data.Clone();
	for (ExtensionPolicyRegistryEntry& policy : policies) {
	ForceInstalledExtension extension(
	ExtensionID::Create(base::UTF16ToUTF8(policy.extension_id)).value(),
	POLICY_EXTENSION_SETTINGS, "", "");
	extension.policy_registry_entry =
	std::make_shared<ExtensionPolicyRegistryEntry>(std::move(policy));
	extensions.insert(extension);
	}

	for (const ForceInstalledExtension& extension : extensions) {
	ASSERT_TRUE(
	RemoveExtensionSettingsPoliciesExtension(extension, &json_result));
	}
	std::string result;
	JSONStringValueSerializer serializer(&result);
	ASSERT_TRUE(serializer.Serialize(json_result));
	ASSERT_EQ(result, "{}");
	base::Value original = json_result.Clone();
	for (const ForceInstalledExtension& extension : extensions) {
	ASSERT_FALSE(
	RemoveExtensionSettingsPoliciesExtension(extension, &json_result));
	ASSERT_EQ(original, json_result);
	}
	}

	TEST(ExtensionsUtilTest, RemoveSomeExtensionSettingsForceInstalledExtensions) {
	registry_util::RegistryOverrideManager registry_override;
	registry_override.OverrideRegistry(HKEY_CURRENT_USER);
	registry_override.OverrideRegistry(HKEY_LOCAL_MACHINE);

	base::win::RegKey settings_key;
	ASSERT_EQ(ERROR_SUCCESS,
	settings_key.Create(HKEY_LOCAL_MACHINE,
	kExtensionSettingsPolicyPath, KEY_ALL_ACCESS));
	DCHECK(settings_key.Valid());
	ASSERT_EQ(ERROR_SUCCESS, settings_key.WriteValue(kExtensionSettingsName,
	kExtensionSettingsJson));

	TestJsonParser json_parser;
	std::vector<ExtensionPolicyRegistryEntry> policies;
	base::WaitableEvent done(WaitableEvent::ResetPolicy::MANUAL,
	WaitableEvent::InitialState::NOT_SIGNALED);
	GetExtensionSettingsForceInstalledExtensions(&json_parser, &policies, &done);
	ASSERT_TRUE(done.TimedWait(TestTimeouts::action_timeout()));

	std::unordered_set<ForceInstalledExtension, ExtensionIDHash, ExtensionIDEqual>
	extensions;
	base::Value json_result = policies[0].json->data.Clone();
	for (ExtensionPolicyRegistryEntry& policy : policies) {
	ForceInstalledExtension extension(
	ExtensionID::Create(base::UTF16ToUTF8(policy.extension_id)).value(),
	POLICY_EXTENSION_SETTINGS, "", "");
	extension.policy_registry_entry =
	std::make_shared<ExtensionPolicyRegistryEntry>(std::move(policy));
	extensions.insert(extension);
	}

	for (const ForceInstalledExtension& extension : extensions) {
	ASSERT_TRUE(
	RemoveExtensionSettingsPoliciesExtension(extension, &json_result));
	}
	std::string result;
	JSONStringValueSerializer serializer(&result);
	ASSERT_TRUE(serializer.Serialize(json_result));
	ASSERT_EQ(result, kValidExtensionSettingsJson);
	base::Value original = json_result.Clone();
	for (const ForceInstalledExtension& extension : extensions) {
	ASSERT_FALSE(
	RemoveExtensionSettingsPoliciesExtension(extension, &json_result));
	ASSERT_EQ(original, json_result);
	}
	}

	TEST(ExtensionsUtilTest,
	GetExtensionSettingsForceInstalledExtensionsNoneFound) {
	registry_util::RegistryOverrideManager registry_override;
	registry_override.OverrideRegistry(HKEY_CURRENT_USER);
	registry_override.OverrideRegistry(HKEY_LOCAL_MACHINE);

	TestJsonParser json_parser;
	std::vector<ExtensionPolicyRegistryEntry> policies;
	base::WaitableEvent done(WaitableEvent::ResetPolicy::MANUAL,
	WaitableEvent::InitialState::NOT_SIGNALED);
	GetExtensionSettingsForceInstalledExtensions(&json_parser, &policies, &done);
	ASSERT_TRUE(done.TimedWait(TestTimeouts::action_timeout()));

	size_t expected_policies_found = 0;
	ASSERT_EQ(expected_policies_found, policies.size());
	}

	TEST(ExtensionsUtilTest, GetMasterPreferencesExtensions) {
	// Set up a fake master preferences JSON file.
	base::ScopedPathOverride program_files_override(base::DIR_PROGRAM_FILES);
	base::FilePath program_files_dir;
	ASSERT_TRUE(
	base::PathService::Get(base::DIR_PROGRAM_FILES, &program_files_dir));

	base::FilePath chrome_dir(program_files_dir.Append(kChromeExePath));
	ASSERT_TRUE(base::CreateDirectoryAndGetError(chrome_dir, nullptr));

	base::FilePath master_preferences =
	chrome_dir.Append(kMasterPreferencesFileName);
	CreateFileWithContent(master_preferences, kMasterPreferencesJson,
	sizeof(kMasterPreferencesJson) - 1);
	ASSERT_TRUE(base::PathExists(master_preferences));

	TestJsonParser json_parser;
	std::vector<ExtensionPolicyFile> policies;
	base::WaitableEvent done(WaitableEvent::ResetPolicy::MANUAL,
	WaitableEvent::InitialState::NOT_SIGNALED);
	GetMasterPreferencesExtensions(&json_parser, &policies, &done);
	ASSERT_TRUE(done.TimedWait(TestTimeouts::action_timeout()));

	const base::string16 expected_extension_ids[] = {kTestExtensionId6,
	kTestExtensionId7};
	ASSERT_EQ(base::size(expected_extension_ids), policies.size());
	const base::string16 found_extension_ids[] = {policies[0].extension_id,
	policies[1].extension_id};
	EXPECT_THAT(expected_extension_ids,
	::testing::UnorderedElementsAreArray(found_extension_ids));
	}

	TEST(ExtensionsUtilTest, RemoveMasterPreferencesExtensionsNoneFound) {
	// Set up a fake master preferences JSON file.
	base::ScopedPathOverride program_files_override(base::DIR_PROGRAM_FILES);
	base::FilePath program_files_dir;
	ASSERT_TRUE(
	base::PathService::Get(base::DIR_PROGRAM_FILES, &program_files_dir));

	base::FilePath chrome_dir(program_files_dir.Append(kChromeExePath));
	ASSERT_TRUE(base::CreateDirectoryAndGetError(chrome_dir, nullptr));

	base::FilePath master_preferences =
	chrome_dir.Append(kMasterPreferencesFileName);
	CreateFileWithContent(master_preferences, kMasterPreferencesJson,
	sizeof(kMasterPreferencesJson) - 1);
	ASSERT_TRUE(base::PathExists(master_preferences));

	TestJsonParser json_parser;
	std::vector<ExtensionPolicyFile> policies;
	base::WaitableEvent done(WaitableEvent::ResetPolicy::MANUAL,
	WaitableEvent::InitialState::NOT_SIGNALED);
	GetMasterPreferencesExtensions(&json_parser, &policies, &done);
	ASSERT_TRUE(done.TimedWait(TestTimeouts::action_timeout()));

	std::vector<ForceInstalledExtension> extensions;
	for (ExtensionPolicyFile& policy : policies) {
	ForceInstalledExtension extension(
	ExtensionID::Create(base::UTF16ToUTF8(policy.extension_id)).value(),
	POLICY_MASTER_PREFERENCES, "", "");
	extension.policy_file =
	std::make_shared<ExtensionPolicyFile>(std::move(policy));
	extensions.push_back(extension);
	}
	base::Value json_result = extensions[0].policy_file->json->data.Clone();
	for (ForceInstalledExtension& extension : extensions) {
	ASSERT_TRUE(RemoveMasterPreferencesExtension(extension, &json_result));
	}
	std::string result;
	JSONStringValueSerializer serializer(&result);
	ASSERT_TRUE(serializer.Serialize(json_result));
	ASSERT_EQ(result, kValidMasterPreferencesJson);
	}

	TEST(ExtensionsUtilTest, GetMasterPreferencesExtensionsNoneFound) {
	// Set up a fake master preferences JSON file.
	base::ScopedPathOverride program_files_override(base::DIR_PROGRAM_FILES);
	base::FilePath program_files_dir;
	ASSERT_TRUE(
	base::PathService::Get(base::DIR_PROGRAM_FILES, &program_files_dir));

	base::FilePath chrome_dir(program_files_dir.Append(kChromeExePath));
	ASSERT_TRUE(base::CreateDirectoryAndGetError(chrome_dir, nullptr));

	base::FilePath master_preferences =
	chrome_dir.Append(kMasterPreferencesFileName);
	CreateFileWithContent(master_preferences, kMasterPreferencesJsonNoExtensions,
	sizeof(kMasterPreferencesJsonNoExtensions) - 1);
	ASSERT_TRUE(base::PathExists(master_preferences));

	TestJsonParser json_parser;
	std::vector<ExtensionPolicyFile> policies;
	base::WaitableEvent done(WaitableEvent::ResetPolicy::MANUAL,
	WaitableEvent::InitialState::NOT_SIGNALED);
	GetMasterPreferencesExtensions(&json_parser, &policies, &done);
	ASSERT_TRUE(done.TimedWait(TestTimeouts::action_timeout()));

	size_t expected_policies_found = 0;
	ASSERT_EQ(expected_policies_found, policies.size());
	}

	} // namespace chrome_cleaner