// 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>
#include "base/memory/scoped_ptr.h"
#include "base/memory/weak_ptr.h"
#include "base/message_loop/message_loop.h"
-#include "base/path_service.h"
#include "base/prefs/scoped_user_pref_update.h"
#include "base/stl_util.h"
#include "base/strings/string16.h"
#include "chrome/browser/extensions/extension_error_ui.h"
#include "chrome/browser/extensions/extension_notification_observer.h"
#include "chrome/browser/extensions/extension_service.h"
+#include "chrome/browser/extensions/extension_service_test_base.h"
#include "chrome/browser/extensions/extension_special_storage_policy.h"
#include "chrome/browser/extensions/extension_sync_data.h"
+#include "chrome/browser/extensions/extension_sync_service.h"
#include "chrome/browser/extensions/extension_util.h"
-#include "chrome/browser/extensions/external_install_ui.h"
+#include "chrome/browser/extensions/external_install_error.h"
+#include "chrome/browser/extensions/external_install_manager.h"
#include "chrome/browser/extensions/external_policy_loader.h"
#include "chrome/browser/extensions/external_pref_loader.h"
#include "chrome/browser/extensions/external_provider_impl.h"
#include "chrome/browser/extensions/fake_safe_browsing_database_manager.h"
-#include "chrome/browser/extensions/install_observer.h"
-#include "chrome/browser/extensions/install_tracker.h"
-#include "chrome/browser/extensions/install_tracker_factory.h"
#include "chrome/browser/extensions/installed_loader.h"
#include "chrome/browser/extensions/pack_extension_job.h"
+#include "chrome/browser/extensions/pending_extension_info.h"
+#include "chrome/browser/extensions/pending_extension_manager.h"
#include "chrome/browser/extensions/test_blacklist.h"
#include "chrome/browser/extensions/test_extension_system.h"
#include "chrome/browser/extensions/unpacked_installer.h"
#include "chrome/browser/extensions/updater/extension_updater.h"
-#include "chrome/browser/prefs/browser_prefs.h"
-#include "chrome/browser/prefs/pref_service_mock_factory.h"
#include "chrome/browser/prefs/pref_service_syncable.h"
+#include "chrome/browser/supervised_user/supervised_user_service.h"
+#include "chrome/browser/supervised_user/supervised_user_service_factory.h"
#include "chrome/browser/sync/profile_sync_service.h"
#include "chrome/browser/sync/profile_sync_service_factory.h"
#include "chrome/common/chrome_constants.h"
-#include "chrome/common/chrome_paths.h"
#include "chrome/common/chrome_switches.h"
#include "chrome/common/extensions/api/plugins/plugins_handler.h"
-#include "chrome/common/extensions/extension_l10n_util.h"
#include "chrome/common/extensions/manifest_handlers/app_launch_info.h"
#include "chrome/common/extensions/manifest_handlers/content_scripts_handler.h"
#include "chrome/common/extensions/manifest_url_handler.h"
#include "chrome/common/url_constants.h"
#include "chrome/test/base/scoped_browser_locale.h"
#include "chrome/test/base/testing_profile.h"
-#include "components/user_prefs/pref_registry_syncable.h"
+#include "components/pref_registry/pref_registry_syncable.h"
#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 "extensions/browser/extension_registry.h"
#include "extensions/browser/extension_system.h"
#include "extensions/browser/external_provider_interface.h"
+#include "extensions/browser/install_flag.h"
#include "extensions/browser/management_policy.h"
-#include "extensions/browser/pending_extension_info.h"
-#include "extensions/browser/pending_extension_manager.h"
#include "extensions/browser/pref_names.h"
#include "extensions/browser/test_management_policy.h"
+#include "extensions/browser/uninstall_reason.h"
#include "extensions/common/constants.h"
#include "extensions/common/extension.h"
#include "extensions/common/extension_builder.h"
+#include "extensions/common/extension_l10n_util.h"
#include "extensions/common/extension_resource.h"
+#include "extensions/common/feature_switch.h"
#include "extensions/common/manifest_constants.h"
#include "extensions/common/manifest_handlers/background_info.h"
#include "extensions/common/permissions/permission_set.h"
+#include "extensions/common/permissions/permissions_data.h"
+#include "extensions/common/switches.h"
#include "extensions/common/url_pattern.h"
#include "extensions/common/value_builder.h"
#include "gpu/config/gpu_info.h"
#include "net/cookies/cookie_options.h"
#include "net/url_request/url_request_context.h"
#include "net/url_request/url_request_context_getter.h"
+#include "sync/api/fake_sync_change_processor.h"
#include "sync/api/string_ordinal.h"
#include "sync/api/sync_data.h"
#include "sync/api/sync_error_factory.h"
#include "webkit/common/database/database_identifier.h"
#if defined(OS_CHROMEOS)
-#include "chrome/browser/chromeos/extensions/install_limiter.h"
-#include "chrome/browser/chromeos/login/user_manager.h"
+#include "chrome/browser/chromeos/login/users/scoped_test_user_manager.h"
#include "chrome/browser/chromeos/settings/cros_settings.h"
#include "chrome/browser/chromeos/settings/device_settings_service.h"
#endif
using extensions::Manifest;
using extensions::PermissionSet;
using extensions::TestExtensionSystem;
+using extensions::UnloadedExtensionInfo;
using extensions::URLPatternSet;
namespace keys = extensions::manifest_keys;
}
virtual bool OnExternalExtensionUpdateUrlFound(
- const std::string& id, const GURL& update_url,
+ const std::string& id,
+ const std::string& install_parameter,
+ const GURL& update_url,
Manifest::Location location,
int creation_flags,
bool mark_acknowledged) OVERRIDE {
EXPECT_FALSE(v1.get());
EXPECT_EQ(Manifest::EXTERNAL_PREF_DOWNLOAD, location1);
+ std::string parsed_install_parameter;
+ pref->GetString("install_parameter", &parsed_install_parameter);
+ EXPECT_EQ(parsed_install_parameter, install_parameter);
+
// Remove it so we won't count it again.
prefs_->Remove(id, NULL);
}
DISALLOW_COPY_AND_ASSIGN(MockProviderVisitor);
};
-ExtensionServiceTestBase::ExtensionServiceInitParams::
-ExtensionServiceInitParams()
- : autoupdate_enabled(false), is_first_run(true), profile_is_managed(false) {
-}
-
-// Our message loop may be used in tests which require it to be an IO loop.
-ExtensionServiceTestBase::ExtensionServiceTestBase()
- : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP),
- service_(NULL),
- management_policy_(NULL),
- expected_extensions_count_(0),
- registry_(NULL) {
- base::FilePath test_data_dir;
- if (!PathService::Get(chrome::DIR_TEST_DATA, &test_data_dir)) {
- ADD_FAILURE();
- return;
- }
- data_dir_ = test_data_dir.AppendASCII("extensions");
-}
-
-ExtensionServiceTestBase::~ExtensionServiceTestBase() {
- service_ = NULL;
-}
-
-void ExtensionServiceTestBase::InitializeExtensionService(
- const ExtensionServiceTestBase::ExtensionServiceInitParams& params) {
- profile_ = CreateTestingProfile(params);
- service_ = InitializeExtensionServiceForProfile(params, profile_.get());
- management_policy_ =
- ExtensionSystem::Get(profile_.get())->management_policy();
- extensions_install_dir_ = params.extensions_install_dir;
- expected_extensions_count_ = 0;
- registry_ = extensions::ExtensionRegistry::Get(profile_.get());
-}
-
-// static
-scoped_ptr<TestingProfile> ExtensionServiceTestBase::CreateTestingProfile(
- const ExtensionServiceInitParams& params) {
- TestingProfile::Builder profile_builder;
- // Create a PrefService that only contains user defined preference values.
- PrefServiceMockFactory factory;
- // If pref_file is empty, TestingProfile automatically creates
- // TestingPrefServiceSyncable instance.
- if (!params.pref_file.empty()) {
- factory.SetUserPrefsFile(params.pref_file,
- base::MessageLoopProxy::current().get());
- scoped_refptr<user_prefs::PrefRegistrySyncable> registry(
- new user_prefs::PrefRegistrySyncable);
- scoped_ptr<PrefServiceSyncable> prefs(
- factory.CreateSyncable(registry.get()));
- chrome::RegisterUserProfilePrefs(registry.get());
- profile_builder.SetPrefService(prefs.Pass());
- }
-
- if (params.profile_is_managed)
- profile_builder.SetManagedUserId("asdf");
-
- profile_builder.SetPath(params.profile_path);
- return profile_builder.Build();
-}
-
-// static
-ExtensionService*
-ExtensionServiceTestBase::InitializeExtensionServiceForProfile(
- const ExtensionServiceInitParams& params,
- Profile* profile) {
- TestExtensionSystem* system = static_cast<TestExtensionSystem*>(
- ExtensionSystem::Get(profile));
- if (!params.is_first_run) {
- ExtensionPrefs* prefs = system->CreateExtensionPrefs(
- CommandLine::ForCurrentProcess(),
- params.extensions_install_dir);
- prefs->SetAlertSystemFirstRun();
- }
-
- ExtensionService* service = system->CreateExtensionService(
- CommandLine::ForCurrentProcess(),
- params.extensions_install_dir,
- params.autoupdate_enabled);
-
- service->SetFileTaskRunnerForTesting(
- base::MessageLoopProxy::current().get());
- service->set_extensions_enabled(true);
- service->set_show_extensions_prompts(false);
- service->set_install_updates_when_idle_for_test(false);
-
- // When we start up, we want to make sure there is no external provider,
- // since the ExtensionService on Windows will use the Registry as a default
- // provider and if there is something already registered there then it will
- // interfere with the tests. Those tests that need an external provider
- // will register one specifically.
- service->ClearProvidersForTesting();
-
-#if defined(OS_CHROMEOS)
- extensions::InstallLimiter::Get(profile)->DisableForTest();
-#endif
- return service;
-}
-
-void ExtensionServiceTestBase::InitializeInstalledExtensionService(
- const base::FilePath& prefs_file,
- const base::FilePath& source_install_dir) {
- EXPECT_TRUE(temp_dir_.CreateUniqueTempDir());
- base::FilePath path = temp_dir_.path();
- path = path.Append(FILE_PATH_LITERAL("TestingExtensionsPath"));
- EXPECT_TRUE(base::DeleteFile(path, true));
- base::File::Error error = base::File::FILE_OK;
- EXPECT_TRUE(base::CreateDirectoryAndGetError(path, &error)) << error;
- base::FilePath temp_prefs = path.Append(chrome::kPreferencesFilename);
- EXPECT_TRUE(base::CopyFile(prefs_file, temp_prefs));
-
- base::FilePath extensions_install_dir =
- path.Append(FILE_PATH_LITERAL("Extensions"));
- EXPECT_TRUE(base::DeleteFile(extensions_install_dir, true));
- EXPECT_TRUE(
- base::CopyDirectory(source_install_dir, extensions_install_dir, true));
-
- ExtensionServiceInitParams params;
- params.profile_path = path;
- params.pref_file = temp_prefs;
- params.extensions_install_dir = extensions_install_dir;
- InitializeExtensionService(params);
-}
-
-void ExtensionServiceTestBase::InitializeGoodInstalledExtensionService() {
- base::FilePath source_install_dir = data_dir_
- .AppendASCII("good")
- .AppendASCII("Extensions");
- base::FilePath pref_path =
- source_install_dir.DirName().Append(chrome::kPreferencesFilename);
- InitializeInstalledExtensionService(pref_path, source_install_dir);
-}
-
-void ExtensionServiceTestBase::InitializeEmptyExtensionService() {
- InitializeExtensionService(CreateDefaultInitParams());
-}
-
-void ExtensionServiceTestBase::InitializeProcessManager() {
- static_cast<extensions::TestExtensionSystem*>(
- ExtensionSystem::Get(profile_.get()))->
- CreateProcessManager();
-}
-
-void ExtensionServiceTestBase::InitializeExtensionServiceWithUpdater() {
- ExtensionServiceInitParams params = CreateDefaultInitParams();
- params.autoupdate_enabled = true;
- InitializeExtensionService(params);
- service_->updater()->Start();
-}
-
-void ExtensionServiceTestBase::InitializeExtensionSyncService() {
- extension_sync_service_.reset(new ExtensionSyncService(
- profile_.get(), service_->extension_prefs(), service_));
-}
-
-// static
-void ExtensionServiceTestBase::SetUpTestCase() {
- ExtensionErrorReporter::Init(false); // no noisy errors
-}
-
-void ExtensionServiceTestBase::SetUp() {
- ExtensionErrorReporter::GetInstance()->ClearErrors();
-}
-
-void ExtensionServiceTestBase::TearDown() {
-}
-
-ExtensionServiceTestBase::ExtensionServiceInitParams
-ExtensionServiceTestBase::CreateDefaultInitParams() {
- return CreateDefaultInitParamsInTempDir(&temp_dir_);
-}
-
-// static
-ExtensionServiceTestBase::ExtensionServiceInitParams
-ExtensionServiceTestBase::CreateDefaultInitParamsInTempDir(
- base::ScopedTempDir* temp_dir) {
- ExtensionServiceInitParams params;
- EXPECT_TRUE(temp_dir->CreateUniqueTempDir());
- base::FilePath path = temp_dir->path();
- path = path.Append(FILE_PATH_LITERAL("TestingExtensionsPath"));
- EXPECT_TRUE(base::DeleteFile(path, true));
- base::File::Error error = base::File::FILE_OK;
- EXPECT_TRUE(base::CreateDirectoryAndGetError(path, &error)) << error;
- base::FilePath prefs_filename =
- path.Append(FILE_PATH_LITERAL("TestPreferences"));
- base::FilePath extensions_install_dir =
- path.Append(FILE_PATH_LITERAL("Extensions"));
- EXPECT_TRUE(base::DeleteFile(extensions_install_dir, true));
- EXPECT_TRUE(base::CreateDirectoryAndGetError(extensions_install_dir,
- &error)) << error;
-
- params.profile_path = path;
- params.pref_file = prefs_filename;
- params.extensions_install_dir = extensions_install_dir;
- return params;
-}
-
-class ExtensionServiceTest
- : public ExtensionServiceTestBase, public content::NotificationObserver {
+class ExtensionServiceTest : public extensions::ExtensionServiceTestBase,
+ public content::NotificationObserver {
public:
ExtensionServiceTest()
- : installed_(NULL),
+ : unloaded_reason_(UnloadedExtensionInfo::REASON_UNDEFINED),
+ installed_(NULL),
was_update_(false),
override_external_install_prompt_(
- FeatureSwitch::prompt_for_external_extensions(), false) {
- registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_LOADED,
- content::NotificationService::AllSources());
- registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
+ FeatureSwitch::prompt_for_external_extensions(),
+ false),
+ expected_extensions_count_(0) {
+ registrar_.Add(this,
+ extensions::NOTIFICATION_EXTENSION_LOADED_DEPRECATED,
content::NotificationService::AllSources());
- registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_INSTALLED,
+ registrar_.Add(this,
+ extensions::NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED,
content::NotificationService::AllSources());
+ registrar_.Add(
+ this,
+ extensions::NOTIFICATION_EXTENSION_WILL_BE_INSTALLED_DEPRECATED,
+ content::NotificationService::AllSources());
}
virtual void Observe(int type,
const content::NotificationSource& source,
const content::NotificationDetails& details) OVERRIDE {
switch (type) {
- case chrome::NOTIFICATION_EXTENSION_LOADED: {
+ case extensions::NOTIFICATION_EXTENSION_LOADED_DEPRECATED: {
const Extension* extension =
content::Details<const Extension>(details).ptr();
loaded_.push_back(make_scoped_refptr(extension));
break;
}
- case chrome::NOTIFICATION_EXTENSION_UNLOADED: {
- const Extension* e =
- content::Details<extensions::UnloadedExtensionInfo>(
- details)->extension;
+ case extensions::NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED: {
+ UnloadedExtensionInfo* unloaded_info =
+ content::Details<UnloadedExtensionInfo>(details).ptr();
+ const Extension* e = unloaded_info->extension;
unloaded_id_ = e->id();
+ unloaded_reason_ = unloaded_info->reason;
extensions::ExtensionList::iterator i =
std::find(loaded_.begin(), loaded_.end(), e);
// TODO(erikkay) fix so this can be an assert. Right now the tests
loaded_.erase(i);
break;
}
- case chrome::NOTIFICATION_EXTENSION_INSTALLED: {
+ case extensions::NOTIFICATION_EXTENSION_WILL_BE_INSTALLED_DEPRECATED: {
const extensions::InstalledExtensionInfo* installed_info =
content::Details<const extensions::InstalledExtensionInfo>(details)
.ptr();
void AddMockExternalProvider(
extensions::ExternalProviderInterface* provider) {
- service_->AddProviderForTesting(provider);
+ service()->AddProviderForTesting(provider);
}
void MockSyncStartFlare(bool* was_called,
protected:
// Paths to some of the fake extensions.
base::FilePath good0_path() {
- return data_dir_.AppendASCII("good").AppendASCII("Extensions")
- .AppendASCII(good0).AppendASCII("1.0.0.0");
+ return data_dir()
+ .AppendASCII("good")
+ .AppendASCII("Extensions")
+ .AppendASCII(good0)
+ .AppendASCII("1.0.0.0");
}
base::FilePath good1_path() {
- return data_dir_.AppendASCII("good").AppendASCII("Extensions")
- .AppendASCII(good1).AppendASCII("2");
+ return data_dir()
+ .AppendASCII("good")
+ .AppendASCII("Extensions")
+ .AppendASCII(good1)
+ .AppendASCII("2");
}
base::FilePath good2_path() {
- return data_dir_.AppendASCII("good").AppendASCII("Extensions")
- .AppendASCII(good2).AppendASCII("1.0");
+ return data_dir()
+ .AppendASCII("good")
+ .AppendASCII("Extensions")
+ .AppendASCII(good2)
+ .AppendASCII("1.0");
}
void TestExternalProvider(MockExtensionProvider* provider,
EXPECT_TRUE(base::PathExists(crx_path))
<< "Path does not exist: "<< crx_path.value().c_str();
// no client (silent install)
- scoped_refptr<CrxInstaller> installer(CrxInstaller::CreateSilent(service_));
+ scoped_refptr<CrxInstaller> installer(
+ CrxInstaller::CreateSilent(service()));
installer->set_install_source(install_location);
content::WindowedNotificationObserver observer(
- chrome::NOTIFICATION_CRX_INSTALLER_DONE,
+ extensions::NOTIFICATION_CRX_INSTALLER_DONE,
content::NotificationService::AllSources());
installer->InstallCrx(crx_path);
observer.Wait();
EXPECT_EQ(0u, loaded_.size()) << path.value();
} else {
EXPECT_EQ(1u, loaded_.size()) << path.value();
- size_t actual_extension_count = registry_->enabled_extensions().size() +
- registry_->disabled_extensions().size();
+ size_t actual_extension_count =
+ registry()->enabled_extensions().size() +
+ registry()->disabled_extensions().size();
EXPECT_EQ(expected_extensions_count_, actual_extension_count) <<
path.value();
extension = loaded_[0].get();
- EXPECT_TRUE(service_->GetExtensionById(extension->id(), false))
+ EXPECT_TRUE(service()->GetExtensionById(extension->id(), false))
<< path.value();
}
FAILED,
UPDATED,
INSTALLED,
+ DISABLED,
ENABLED
};
*installer;
}
+ void PackCRXAndUpdateExtension(const std::string& id,
+ const base::FilePath& dir_path,
+ const base::FilePath& pem_path,
+ UpdateState expected_state) {
+ base::ScopedTempDir temp_dir;
+ EXPECT_TRUE(temp_dir.CreateUniqueTempDir());
+ base::FilePath crx_path = temp_dir.path().AppendASCII("temp.crx");
+
+ PackCRX(dir_path, pem_path, crx_path);
+ UpdateExtension(id, crx_path, expected_state);
+ }
+
void UpdateExtension(const std::string& id,
const base::FilePath& in_path,
UpdateState expected_state) {
// We need to copy this to a temporary location because Update() will delete
// it.
- base::FilePath path = temp_dir_.path();
+ base::FilePath path = temp_dir().path();
path = path.Append(in_path.BaseName());
ASSERT_TRUE(base::CopyFile(in_path, path));
int previous_enabled_extension_count =
- registry_->enabled_extensions().size();
+ registry()->enabled_extensions().size();
int previous_installed_extension_count =
previous_enabled_extension_count +
- registry_->disabled_extensions().size();
+ registry()->disabled_extensions().size();
extensions::CrxInstaller* installer = NULL;
content::WindowedNotificationObserver observer(
- chrome::NOTIFICATION_CRX_INSTALLER_DONE,
+ extensions::NOTIFICATION_CRX_INSTALLER_DONE,
base::Bind(&IsCrxInstallerDone, &installer));
- service_->UpdateExtension(id, path, true, GURL(), &installer);
+ service()->UpdateExtension(id, path, true, &installer);
if (installer)
observer.Wait();
std::vector<base::string16> errors = GetErrors();
int error_count = errors.size();
- int enabled_extension_count = registry_->enabled_extensions().size();
+ int enabled_extension_count = registry()->enabled_extensions().size();
int installed_extension_count =
- enabled_extension_count + registry_->disabled_extensions().size();
+ enabled_extension_count + registry()->disabled_extensions().size();
int expected_error_count = (expected_state == FAILED) ? 1 : 0;
EXPECT_EQ(expected_error_count, error_count) << path.value();
}
void TerminateExtension(const std::string& id) {
- const Extension* extension = service_->GetInstalledExtension(id);
+ const Extension* extension = service()->GetInstalledExtension(id);
if (!extension) {
ADD_FAILURE();
return;
}
- service_->TrackTerminatedExtensionForTest(extension);
+ service()->TrackTerminatedExtensionForTest(extension);
}
size_t GetPrefKeyCount() {
const base::DictionaryValue* dict =
- profile_->GetPrefs()->GetDictionary("extensions.settings");
+ profile()->GetPrefs()->GetDictionary("extensions.settings");
if (!dict) {
ADD_FAILURE();
return 0;
void UninstallExtension(const std::string& id, bool use_helper) {
// Verify that the extension is installed.
- base::FilePath extension_path = extensions_install_dir_.AppendASCII(id);
+ base::FilePath extension_path = extensions_install_dir().AppendASCII(id);
EXPECT_TRUE(base::PathExists(extension_path));
size_t pref_key_count = GetPrefKeyCount();
EXPECT_GT(pref_key_count, 0u);
// Uninstall it.
if (use_helper) {
- EXPECT_TRUE(ExtensionService::UninstallExtensionHelper(service_, id));
+ EXPECT_TRUE(ExtensionService::UninstallExtensionHelper(
+ service(), id, extensions::UNINSTALL_REASON_FOR_TESTING));
} else {
- EXPECT_TRUE(service_->UninstallExtension(id, false, NULL));
+ EXPECT_TRUE(service()->UninstallExtension(
+ id,
+ extensions::UNINSTALL_REASON_FOR_TESTING,
+ base::Bind(&base::DoNothing),
+ NULL));
}
--expected_extensions_count_;
}
// The extension should not be in the service anymore.
- EXPECT_FALSE(service_->GetInstalledExtension(id));
+ EXPECT_FALSE(service()->GetInstalledExtension(id));
base::RunLoop().RunUntilIdle();
// The directory should be gone.
msg += " == ";
msg += expected_val ? "true" : "false";
- PrefService* prefs = profile_->GetPrefs();
+ PrefService* prefs = profile()->GetPrefs();
const base::DictionaryValue* dict =
prefs->GetDictionary("extensions.settings");
if (!dict) {
bool IsPrefExist(const std::string& extension_id,
const std::string& pref_path) {
const base::DictionaryValue* dict =
- profile_->GetPrefs()->GetDictionary("extensions.settings");
+ profile()->GetPrefs()->GetDictionary("extensions.settings");
if (dict == NULL) return false;
const base::DictionaryValue* pref = NULL;
if (!dict->GetDictionary(extension_id, &pref)) {
msg += " == ";
msg += base::IntToString(expected_val);
- PrefService* prefs = profile_->GetPrefs();
+ PrefService* prefs = profile()->GetPrefs();
const base::DictionaryValue* dict =
prefs->GetDictionary("extensions.settings");
ASSERT_TRUE(dict != NULL) << msg;
msg += expected_val;
const base::DictionaryValue* dict =
- profile_->GetPrefs()->GetDictionary("extensions.settings");
+ profile()->GetPrefs()->GetDictionary("extensions.settings");
ASSERT_TRUE(dict != NULL) << msg;
const base::DictionaryValue* pref = NULL;
std::string manifest_path = extension_id + ".manifest";
const std::string& pref_path,
base::Value* value,
const std::string& msg) {
- DictionaryPrefUpdate update(profile_->GetPrefs(), "extensions.settings");
+ DictionaryPrefUpdate update(profile()->GetPrefs(), "extensions.settings");
base::DictionaryValue* dict = update.Get();
ASSERT_TRUE(dict != NULL) << msg;
base::DictionaryValue* pref = NULL;
std::string msg = " while clearing: ";
msg += extension_id + " " + pref_path;
- DictionaryPrefUpdate update(profile_->GetPrefs(), "extensions.settings");
+ DictionaryPrefUpdate update(profile()->GetPrefs(), "extensions.settings");
base::DictionaryValue* dict = update.Get();
ASSERT_TRUE(dict != NULL) << msg;
base::DictionaryValue* pref = NULL;
#endif
}
+ void InitializeExtensionSyncService() {
+ extension_sync_service_.reset(new ExtensionSyncService(
+ profile(), ExtensionPrefs::Get(browser_context()), service()));
+ }
+
+ extensions::ManagementPolicy* GetManagementPolicy() {
+ return ExtensionSystem::Get(browser_context())->management_policy();
+ }
+
+ ExtensionSyncService* extension_sync_service() {
+ return extension_sync_service_.get();
+ }
+
protected:
+ scoped_ptr<ExtensionSyncService> extension_sync_service_;
extensions::ExtensionList loaded_;
std::string unloaded_id_;
+ UnloadedExtensionInfo::Reason unloaded_reason_;
const Extension* installed_;
bool was_update_;
std::string old_name_;
void InstallCRXInternal(const base::FilePath& crx_path, int creation_flags) {
ASSERT_TRUE(base::PathExists(crx_path))
<< "Path does not exist: "<< crx_path.value().c_str();
- scoped_refptr<CrxInstaller> installer(CrxInstaller::CreateSilent(service_));
+ scoped_refptr<CrxInstaller> installer(
+ CrxInstaller::CreateSilent(service()));
installer->set_creation_flags(creation_flags);
if (!(creation_flags & Extension::WAS_INSTALLED_BY_DEFAULT))
installer->set_allow_silent_install(true);
content::WindowedNotificationObserver observer(
- chrome::NOTIFICATION_CRX_INSTALLER_DONE,
+ extensions::NOTIFICATION_CRX_INSTALLER_DONE,
content::Source<extensions::CrxInstaller>(installer));
installer->InstallCrx(crx_path);
observer.Wait();
}
+ size_t expected_extensions_count_;
content::NotificationRegistrar registrar_;
};
TEST_F(ExtensionServiceTest, LoadAllExtensionsFromDirectorySuccess) {
InitPluginService();
InitializeGoodInstalledExtensionService();
- service_->Init();
+ service()->Init();
uint32 expected_num_extensions = 3u;
ASSERT_EQ(expected_num_extensions, loaded_.size());
EXPECT_EQ(std::string("The first extension that I made."),
loaded_[0]->description());
EXPECT_EQ(Manifest::INTERNAL, loaded_[0]->location());
- EXPECT_TRUE(service_->GetExtensionById(loaded_[0]->id(), false));
- EXPECT_EQ(expected_num_extensions, registry_->enabled_extensions().size());
+ EXPECT_TRUE(service()->GetExtensionById(loaded_[0]->id(), false));
+ EXPECT_EQ(expected_num_extensions, registry()->enabled_extensions().size());
ValidatePrefKeyCount(3);
ValidateIntegerPref(good0, "state", Extension::ENABLED);
expected_patterns.ClearPatterns();
AddPattern(&expected_patterns, "http://*.google.com/*");
AddPattern(&expected_patterns, "https://*.google.com/*");
- EXPECT_EQ(expected_patterns,
- extension->GetActivePermissions()->explicit_hosts());
+ EXPECT_EQ(
+ expected_patterns,
+ extension->permissions_data()->active_permissions()->explicit_hosts());
EXPECT_EQ(std::string(good1), loaded_[1]->id());
EXPECT_EQ(std::string("My extension 2"), loaded_[1]->name());
// Test loading bad extensions from the profile directory.
TEST_F(ExtensionServiceTest, LoadAllExtensionsFromDirectoryFail) {
// Initialize the test dir with a bad Preferences/extensions.
- base::FilePath source_install_dir = data_dir_
- .AppendASCII("bad")
- .AppendASCII("Extensions");
+ base::FilePath source_install_dir =
+ data_dir().AppendASCII("bad").AppendASCII("Extensions");
base::FilePath pref_path =
source_install_dir.DirName().Append(chrome::kPreferencesFilename);
InitializeInstalledExtensionService(pref_path, source_install_dir);
- service_->Init();
+ service()->Init();
ASSERT_EQ(4u, GetErrors().size());
ASSERT_EQ(0u, loaded_.size());
base::UTF16ToUTF8(GetErrors()[3]);
};
-// Test that partially deleted extensions are cleaned up during startup
-// Test loading bad extensions from the profile directory.
-TEST_F(ExtensionServiceTest, CleanupOnStartup) {
- InitPluginService();
- InitializeGoodInstalledExtensionService();
-
- // Simulate that one of them got partially deleted by clearing its pref.
- {
- DictionaryPrefUpdate update(profile_->GetPrefs(), "extensions.settings");
- base::DictionaryValue* dict = update.Get();
- ASSERT_TRUE(dict != NULL);
- dict->Remove("behllobkkfkfnphdnhnkndlbkcpglgmj", NULL);
- }
-
- service_->Init();
- // A delayed task to call GarbageCollectExtensions is posted by
- // ExtensionService::Init. As the test won't wait for the delayed task to
- // be called, call it manually instead.
- service_->GarbageCollectExtensions();
- // Wait for GarbageCollectExtensions task to complete.
- base::RunLoop().RunUntilIdle();
-
- base::FileEnumerator dirs(extensions_install_dir_, false,
- base::FileEnumerator::DIRECTORIES);
- size_t count = 0;
- while (!dirs.Next().empty())
- count++;
-
- // We should have only gotten two extensions now.
- EXPECT_EQ(2u, count);
-
- // And extension1 dir should now be toast.
- base::FilePath extension_dir = extensions_install_dir_
- .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj");
- ASSERT_FALSE(base::PathExists(extension_dir));
-}
-
-// Test that GarbageCollectExtensions deletes the right versions of an
-// extension.
-TEST_F(ExtensionServiceTest, GarbageCollectWithPendingUpdates) {
- InitPluginService();
-
- base::FilePath source_install_dir = data_dir_
- .AppendASCII("pending_updates")
- .AppendASCII("Extensions");
- base::FilePath pref_path =
- source_install_dir.DirName().Append(chrome::kPreferencesFilename);
-
- InitializeInstalledExtensionService(pref_path, source_install_dir);
-
- // This is the directory that is going to be deleted, so make sure it actually
- // is there before the garbage collection.
- ASSERT_TRUE(base::PathExists(extensions_install_dir_.AppendASCII(
- "hpiknbiabeeppbpihjehijgoemciehgk/3")));
-
- service_->GarbageCollectExtensions();
- // Wait for GarbageCollectExtensions task to complete.
- base::RunLoop().RunUntilIdle();
-
- // Verify that the pending update for the first extension didn't get
- // deleted.
- EXPECT_TRUE(base::PathExists(extensions_install_dir_.AppendASCII(
- "bjafgdebaacbbbecmhlhpofkepfkgcpa/1.0")));
- EXPECT_TRUE(base::PathExists(extensions_install_dir_.AppendASCII(
- "bjafgdebaacbbbecmhlhpofkepfkgcpa/2.0")));
- EXPECT_TRUE(base::PathExists(extensions_install_dir_.AppendASCII(
- "hpiknbiabeeppbpihjehijgoemciehgk/2")));
- EXPECT_FALSE(base::PathExists(extensions_install_dir_.AppendASCII(
- "hpiknbiabeeppbpihjehijgoemciehgk/3")));
-}
-
-// Test that pending updates are properly handled on startup.
-TEST_F(ExtensionServiceTest, UpdateOnStartup) {
- InitPluginService();
-
- base::FilePath source_install_dir = data_dir_
- .AppendASCII("pending_updates")
- .AppendASCII("Extensions");
- base::FilePath pref_path =
- source_install_dir.DirName().Append(chrome::kPreferencesFilename);
-
- InitializeInstalledExtensionService(pref_path, source_install_dir);
-
- // This is the directory that is going to be deleted, so make sure it actually
- // is there before the garbage collection.
- ASSERT_TRUE(base::PathExists(extensions_install_dir_.AppendASCII(
- "hpiknbiabeeppbpihjehijgoemciehgk/3")));
-
- service_->Init();
- // A delayed task to call GarbageCollectExtensions is posted by
- // ExtensionService::Init. As the test won't wait for the delayed task to
- // be called, call it manually instead.
- service_->GarbageCollectExtensions();
- // Wait for GarbageCollectExtensions task to complete.
- base::RunLoop().RunUntilIdle();
-
- // Verify that the pending update for the first extension got installed.
- EXPECT_FALSE(base::PathExists(extensions_install_dir_.AppendASCII(
- "bjafgdebaacbbbecmhlhpofkepfkgcpa/1.0")));
- EXPECT_TRUE(base::PathExists(extensions_install_dir_.AppendASCII(
- "bjafgdebaacbbbecmhlhpofkepfkgcpa/2.0")));
- EXPECT_TRUE(base::PathExists(extensions_install_dir_.AppendASCII(
- "hpiknbiabeeppbpihjehijgoemciehgk/2")));
- EXPECT_FALSE(base::PathExists(extensions_install_dir_.AppendASCII(
- "hpiknbiabeeppbpihjehijgoemciehgk/3")));
-
- // Make sure update information got deleted.
- ExtensionPrefs* prefs = service_->extension_prefs();
- EXPECT_FALSE(
- prefs->GetDelayedInstallInfo("bjafgdebaacbbbecmhlhpofkepfkgcpa"));
-}
-
// Test various cases for delayed install because of missing imports.
TEST_F(ExtensionServiceTest, PendingImports) {
InitPluginService();
- base::FilePath source_install_dir = data_dir_
- .AppendASCII("pending_updates_with_imports")
- .AppendASCII("Extensions");
+ base::FilePath source_install_dir =
+ data_dir().AppendASCII("pending_updates_with_imports").AppendASCII(
+ "Extensions");
base::FilePath pref_path =
source_install_dir.DirName().Append(chrome::kPreferencesFilename);
InitializeInstalledExtensionService(pref_path, source_install_dir);
// Verify there are no pending extensions initially.
- EXPECT_FALSE(service_->pending_extension_manager()->HasPendingExtensions());
+ EXPECT_FALSE(service()->pending_extension_manager()->HasPendingExtensions());
- service_->Init();
+ service()->Init();
// Wait for GarbageCollectExtensions task to complete.
base::RunLoop().RunUntilIdle();
// These extensions are used by the extensions we test below, they must be
// installed.
- EXPECT_TRUE(base::PathExists(extensions_install_dir_.AppendASCII(
+ EXPECT_TRUE(base::PathExists(extensions_install_dir().AppendASCII(
"bjafgdebaacbbbecmhlhpofkepfkgcpa/1.0")));
- EXPECT_TRUE(base::PathExists(extensions_install_dir_.AppendASCII(
+ EXPECT_TRUE(base::PathExists(extensions_install_dir().AppendASCII(
"hpiknbiabeeppbpihjehijgoemciehgk/2")));
// Each of these extensions should have been rejected because of dependencies
// that cannot be satisfied.
- ExtensionPrefs* prefs = service_->extension_prefs();
+ ExtensionPrefs* prefs = ExtensionPrefs::Get(profile());
EXPECT_FALSE(
prefs->GetDelayedInstallInfo("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"));
EXPECT_FALSE(
EXPECT_EQ(ExtensionPrefs::DELAY_REASON_WAIT_FOR_IMPORTS,
prefs->GetDelayedInstallReason("behllobkkfkfnphdnhnkndlbkcpglgmj"));
- EXPECT_FALSE(base::PathExists(extensions_install_dir_.AppendASCII(
+ EXPECT_FALSE(base::PathExists(extensions_install_dir().AppendASCII(
"behllobkkfkfnphdnhnkndlbkcpglgmj/1.0.0.0")));
- EXPECT_TRUE(service_->pending_extension_manager()->HasPendingExtensions());
+ EXPECT_TRUE(service()->pending_extension_manager()->HasPendingExtensions());
std::string pending_id("eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee");
- EXPECT_TRUE(service_->pending_extension_manager()->IsIdPending(pending_id));
+ EXPECT_TRUE(service()->pending_extension_manager()->IsIdPending(pending_id));
// Remove it because we are not testing the pending extension manager's
// ability to download and install extensions.
- EXPECT_TRUE(service_->pending_extension_manager()->Remove(pending_id));
+ EXPECT_TRUE(service()->pending_extension_manager()->Remove(pending_id));
}
// Test installing extensions. This test tries to install few extensions using
InitializeEmptyExtensionService();
// Extensions not enabled.
- set_extensions_enabled(false);
- base::FilePath path = data_dir_.AppendASCII("good.crx");
+ service()->set_extensions_enabled(false);
+ base::FilePath path = data_dir().AppendASCII("good.crx");
InstallCRX(path, INSTALL_FAILED);
- set_extensions_enabled(true);
+ service()->set_extensions_enabled(true);
ValidatePrefKeyCount(0);
// A simple extension that should install without error.
- path = data_dir_.AppendASCII("good.crx");
+ path = data_dir().AppendASCII("good.crx");
InstallCRX(path, INSTALL_NEW);
// TODO(erikkay): verify the contents of the installed extension.
ValidateIntegerPref(good_crx, "location", Manifest::INTERNAL);
// An extension with page actions.
- path = data_dir_.AppendASCII("page_action.crx");
+ path = data_dir().AppendASCII("page_action.crx");
InstallCRX(path, INSTALL_NEW);
ValidatePrefKeyCount(++pref_count);
ValidateIntegerPref(page_action, "state", Extension::ENABLED);
ValidateIntegerPref(page_action, "location", Manifest::INTERNAL);
// Bad signature.
- path = data_dir_.AppendASCII("bad_signature.crx");
+ path = data_dir().AppendASCII("bad_signature.crx");
InstallCRX(path, INSTALL_FAILED);
ValidatePrefKeyCount(pref_count);
// 0-length extension file.
- path = data_dir_.AppendASCII("not_an_extension.crx");
+ path = data_dir().AppendASCII("not_an_extension.crx");
InstallCRX(path, INSTALL_FAILED);
ValidatePrefKeyCount(pref_count);
// Bad magic number.
- path = data_dir_.AppendASCII("bad_magic.crx");
+ path = data_dir().AppendASCII("bad_magic.crx");
InstallCRX(path, INSTALL_FAILED);
ValidatePrefKeyCount(pref_count);
// Packed extensions may have folders or files that have underscores.
// This will only cause a warning, rather than a fatal error.
- path = data_dir_.AppendASCII("bad_underscore.crx");
+ path = data_dir().AppendASCII("bad_underscore.crx");
InstallCRX(path, INSTALL_NEW);
ValidatePrefKeyCount(++pref_count);
// A test for an extension with a 2048-bit public key.
- path = data_dir_.AppendASCII("good2048.crx");
+ path = data_dir().AppendASCII("good2048.crx");
InstallCRX(path, INSTALL_NEW);
ValidatePrefKeyCount(++pref_count);
ValidateIntegerPref(good2048, "state", Extension::ENABLED);
// TODO(erikkay): add tests for upgrade cases.
}
-struct MockInstallObserver : public extensions::InstallObserver {
- MockInstallObserver() {
- }
-
- virtual ~MockInstallObserver() {
- }
-
- virtual void OnBeginExtensionInstall(
- const ExtensionInstallParams& params) OVERRIDE {
- }
-
- virtual void OnDownloadProgress(const std::string& extension_id,
- int percent_downloaded) OVERRIDE {
- }
-
- virtual void OnExtensionInstalled(const Extension* extension) OVERRIDE {
+struct MockExtensionRegistryObserver
+ : public extensions::ExtensionRegistryObserver {
+ virtual void OnExtensionWillBeInstalled(
+ content::BrowserContext* browser_context,
+ const Extension* extension,
+ bool is_update,
+ bool from_ephemeral,
+ const std::string& old_name) OVERRIDE {
last_extension_installed = extension->id();
}
- virtual void OnInstallFailure(const std::string& extension_id) OVERRIDE {
- }
-
- virtual void OnExtensionLoaded(const Extension* extension) OVERRIDE {
- }
-
- virtual void OnExtensionUnloaded(const Extension* extension) OVERRIDE {
- }
-
- virtual void OnExtensionUninstalled(const Extension* extension) OVERRIDE {
+ virtual void OnExtensionUninstalled(
+ content::BrowserContext* browser_context,
+ const Extension* extension,
+ extensions::UninstallReason reason) OVERRIDE {
last_extension_uninstalled = extension->id();
}
- virtual void OnAppsReordered() OVERRIDE {
- }
-
- virtual void OnAppInstalledToAppList(
- const std::string& extension_id) OVERRIDE {
- }
-
- virtual void OnShutdown() OVERRIDE {
- }
-
std::string last_extension_installed;
std::string last_extension_uninstalled;
};
-// Test that correct notifications are sent to InstallTracker observers on
+// Test that correct notifications are sent to ExtensionRegistryObserver on
// extension install and uninstall.
TEST_F(ExtensionServiceTest, InstallObserverNotified) {
InitializeEmptyExtensionService();
- extensions::InstallTracker* tracker(
- extensions::InstallTrackerFactory::GetForProfile(profile_.get()));
- MockInstallObserver observer;
- tracker->AddObserver(&observer);
+ extensions::ExtensionRegistry* registry(
+ extensions::ExtensionRegistry::Get(profile()));
+ MockExtensionRegistryObserver observer;
+ registry->AddObserver(&observer);
// A simple extension that should install without error.
ASSERT_TRUE(observer.last_extension_installed.empty());
- base::FilePath path = data_dir_.AppendASCII("good.crx");
+ base::FilePath path = data_dir().AppendASCII("good.crx");
InstallCRX(path, INSTALL_NEW);
ASSERT_EQ(good_crx, observer.last_extension_installed);
UninstallExtension(good_crx, false);
ASSERT_EQ(good_crx, observer.last_extension_uninstalled);
- tracker->RemoveObserver(&observer);
+ registry->RemoveObserver(&observer);
}
// Tests that flags passed to OnExternalExtensionFileFound() make it to the
InitializeEmptyExtensionService();
- base::FilePath path = data_dir_.AppendASCII("good.crx");
- set_extensions_enabled(true);
+ base::FilePath path = data_dir().AppendASCII("good.crx");
+ service()->set_extensions_enabled(true);
// Register and install an external extension.
Version version("1.0.0.0");
content::WindowedNotificationObserver observer(
- chrome::NOTIFICATION_CRX_INSTALLER_DONE,
+ extensions::NOTIFICATION_CRX_INSTALLER_DONE,
content::NotificationService::AllSources());
- if (service_->OnExternalExtensionFileFound(
- good_crx,
- &version,
- path,
- Manifest::EXTERNAL_PREF,
- Extension::FROM_BOOKMARK,
- false /* mark_acknowledged */)) {
+ if (service()->OnExternalExtensionFileFound(good_crx,
+ &version,
+ path,
+ Manifest::EXTERNAL_PREF,
+ Extension::FROM_BOOKMARK,
+ false /* mark_acknowledged */)) {
observer.Wait();
}
- const Extension* extension = service_->GetExtensionById(good_crx, false);
+ const Extension* extension = service()->GetExtensionById(good_crx, false);
ASSERT_TRUE(extension);
ASSERT_TRUE(extension->from_bookmark());
ASSERT_TRUE(ValidateBooleanPref(good_crx, kPrefFromBookmark, true));
// Upgrade to version 2.0, the flag should be preserved.
- path = data_dir_.AppendASCII("good2.crx");
+ path = data_dir().AppendASCII("good2.crx");
UpdateExtension(good_crx, path, ENABLED);
ASSERT_TRUE(ValidateBooleanPref(good_crx, kPrefFromBookmark, true));
- extension = service_->GetExtensionById(good_crx, false);
+ extension = service()->GetExtensionById(good_crx, false);
ASSERT_TRUE(extension);
ASSERT_TRUE(extension->from_bookmark());
}
TEST_F(ExtensionServiceTest, UninstallingExternalExtensions) {
InitializeEmptyExtensionService();
- base::FilePath path = data_dir_.AppendASCII("good.crx");
- set_extensions_enabled(true);
+ base::FilePath path = data_dir().AppendASCII("good.crx");
+ service()->set_extensions_enabled(true);
// Install an external extension.
Version version("1.0.0.0");
content::WindowedNotificationObserver observer(
- chrome::NOTIFICATION_CRX_INSTALLER_DONE,
+ extensions::NOTIFICATION_CRX_INSTALLER_DONE,
content::NotificationService::AllSources());
- if (service_->OnExternalExtensionFileFound(good_crx, &version,
- path, Manifest::EXTERNAL_PREF,
- Extension::NO_FLAGS, false)) {
+ if (service()->OnExternalExtensionFileFound(good_crx,
+ &version,
+ path,
+ Manifest::EXTERNAL_PREF,
+ Extension::NO_FLAGS,
+ false)) {
observer.Wait();
}
- ASSERT_TRUE(service_->GetExtensionById(good_crx, false));
+ ASSERT_TRUE(service()->GetExtensionById(good_crx, false));
// Uninstall it and check that its killbit gets set.
UninstallExtension(good_crx, false);
Extension::EXTERNAL_EXTENSION_UNINSTALLED);
// Try to re-install it externally. This should fail because of the killbit.
- service_->OnExternalExtensionFileFound(good_crx, &version,
- path, Manifest::EXTERNAL_PREF,
- Extension::NO_FLAGS, false);
+ service()->OnExternalExtensionFileFound(good_crx,
+ &version,
+ path,
+ Manifest::EXTERNAL_PREF,
+ Extension::NO_FLAGS,
+ false);
base::RunLoop().RunUntilIdle();
- ASSERT_TRUE(NULL == service_->GetExtensionById(good_crx, false));
+ ASSERT_TRUE(NULL == service()->GetExtensionById(good_crx, false));
ValidateIntegerPref(good_crx, "location",
Extension::EXTERNAL_EXTENSION_UNINSTALLED);
version = Version("1.0.0.1");
// Repeat the same thing with a newer version of the extension.
- path = data_dir_.AppendASCII("good2.crx");
- service_->OnExternalExtensionFileFound(good_crx, &version,
- path, Manifest::EXTERNAL_PREF,
- Extension::NO_FLAGS, false);
+ path = data_dir().AppendASCII("good2.crx");
+ service()->OnExternalExtensionFileFound(good_crx,
+ &version,
+ path,
+ Manifest::EXTERNAL_PREF,
+ Extension::NO_FLAGS,
+ false);
base::RunLoop().RunUntilIdle();
- ASSERT_TRUE(NULL == service_->GetExtensionById(good_crx, false));
+ ASSERT_TRUE(NULL == service()->GetExtensionById(good_crx, false));
ValidateIntegerPref(good_crx, "location",
Extension::EXTERNAL_EXTENSION_UNINSTALLED);
// Try adding the same extension from an external update URL.
- ASSERT_FALSE(service_->pending_extension_manager()->AddFromExternalUpdateUrl(
+ ASSERT_FALSE(service()->pending_extension_manager()->AddFromExternalUpdateUrl(
good_crx,
+ std::string(),
GURL("http:://fake.update/url"),
Manifest::EXTERNAL_PREF_DOWNLOAD,
Extension::NO_FLAGS,
false));
- ASSERT_FALSE(service_->pending_extension_manager()->IsIdPending(good_crx));
+ ASSERT_FALSE(service()->pending_extension_manager()->IsIdPending(good_crx));
}
// Test that uninstalling an external extension does not crash when
// This extension shown in preferences file requires an experimental permission.
// It could not be loaded without such permission.
TEST_F(ExtensionServiceTest, UninstallingNotLoadedExtension) {
- base::FilePath source_install_dir = data_dir_
- .AppendASCII("good")
- .AppendASCII("Extensions");
+ base::FilePath source_install_dir =
+ data_dir().AppendASCII("good").AppendASCII("Extensions");
// The preference contains an external extension
// that requires 'experimental' permission.
base::FilePath pref_path = source_install_dir
// there is no '--enable-experimental-extension-apis' command line flag.
InitializeInstalledExtensionService(pref_path, source_install_dir);
- service_->Init();
+ service()->Init();
// Check and try to uninstall it.
// If we don't check whether the extension is loaded before we uninstall it
// in CheckExternalUninstall, a crash will happen here because we will get or
// dereference a NULL pointer (extension) inside UninstallExtension.
MockExtensionProvider provider(NULL, Manifest::EXTERNAL_REGISTRY);
- service_->OnExternalProviderReady(&provider);
+ service()->OnExternalProviderReady(&provider);
}
// Test that external extensions with incorrect IDs are not installed.
TEST_F(ExtensionServiceTest, FailOnWrongId) {
InitializeEmptyExtensionService();
- base::FilePath path = data_dir_.AppendASCII("good.crx");
- set_extensions_enabled(true);
+ base::FilePath path = data_dir().AppendASCII("good.crx");
+ service()->set_extensions_enabled(true);
Version version("1.0.0.0");
// Install an external extension with an ID from the external
// source that is not equal to the ID in the extension manifest.
content::WindowedNotificationObserver observer(
- chrome::NOTIFICATION_CRX_INSTALLER_DONE,
+ extensions::NOTIFICATION_CRX_INSTALLER_DONE,
content::NotificationService::AllSources());
- service_->OnExternalExtensionFileFound(
- wrong_id, &version, path, Manifest::EXTERNAL_PREF,
- Extension::NO_FLAGS, false);
+ service()->OnExternalExtensionFileFound(wrong_id,
+ &version,
+ path,
+ Manifest::EXTERNAL_PREF,
+ Extension::NO_FLAGS,
+ false);
observer.Wait();
- ASSERT_FALSE(service_->GetExtensionById(good_crx, false));
+ ASSERT_FALSE(service()->GetExtensionById(good_crx, false));
// Try again with the right ID. Expect success.
content::WindowedNotificationObserver observer2(
- chrome::NOTIFICATION_CRX_INSTALLER_DONE,
+ extensions::NOTIFICATION_CRX_INSTALLER_DONE,
content::NotificationService::AllSources());
- if (service_->OnExternalExtensionFileFound(
- correct_id, &version, path, Manifest::EXTERNAL_PREF,
- Extension::NO_FLAGS, false)) {
+ if (service()->OnExternalExtensionFileFound(correct_id,
+ &version,
+ path,
+ Manifest::EXTERNAL_PREF,
+ Extension::NO_FLAGS,
+ false)) {
observer2.Wait();
}
- ASSERT_TRUE(service_->GetExtensionById(good_crx, false));
+ ASSERT_TRUE(service()->GetExtensionById(good_crx, false));
}
// Test that external extensions with incorrect versions are not installed.
TEST_F(ExtensionServiceTest, FailOnWrongVersion) {
InitializeEmptyExtensionService();
- base::FilePath path = data_dir_.AppendASCII("good.crx");
- set_extensions_enabled(true);
+ base::FilePath path = data_dir().AppendASCII("good.crx");
+ service()->set_extensions_enabled(true);
// Install an external extension with a version from the external
// source that is not equal to the version in the extension manifest.
Version wrong_version("1.2.3.4");
content::WindowedNotificationObserver observer(
- chrome::NOTIFICATION_CRX_INSTALLER_DONE,
+ extensions::NOTIFICATION_CRX_INSTALLER_DONE,
content::NotificationService::AllSources());
- service_->OnExternalExtensionFileFound(
- good_crx, &wrong_version, path, Manifest::EXTERNAL_PREF,
- Extension::NO_FLAGS, false);
+ service()->OnExternalExtensionFileFound(good_crx,
+ &wrong_version,
+ path,
+ Manifest::EXTERNAL_PREF,
+ Extension::NO_FLAGS,
+ false);
observer.Wait();
- ASSERT_FALSE(service_->GetExtensionById(good_crx, false));
+ ASSERT_FALSE(service()->GetExtensionById(good_crx, false));
// Try again with the right version. Expect success.
- service_->pending_extension_manager()->Remove(good_crx);
+ service()->pending_extension_manager()->Remove(good_crx);
Version correct_version("1.0.0.0");
content::WindowedNotificationObserver observer2(
- chrome::NOTIFICATION_CRX_INSTALLER_DONE,
+ extensions::NOTIFICATION_CRX_INSTALLER_DONE,
content::NotificationService::AllSources());
- if (service_->OnExternalExtensionFileFound(
- good_crx, &correct_version, path, Manifest::EXTERNAL_PREF,
- Extension::NO_FLAGS, false)) {
+ if (service()->OnExternalExtensionFileFound(good_crx,
+ &correct_version,
+ path,
+ Manifest::EXTERNAL_PREF,
+ Extension::NO_FLAGS,
+ false)) {
observer2.Wait();
}
- ASSERT_TRUE(service_->GetExtensionById(good_crx, false));
+ ASSERT_TRUE(service()->GetExtensionById(good_crx, false));
}
// Install a user script (they get converted automatically to an extension)
// integration with ExtensionService.
InitializeEmptyExtensionService();
- base::FilePath path = data_dir_
- .AppendASCII("user_script_basic.user.js");
+ base::FilePath path = data_dir().AppendASCII("user_script_basic.user.js");
ASSERT_TRUE(base::PathExists(path));
- scoped_refptr<CrxInstaller> installer(CrxInstaller::CreateSilent(service_));
+ scoped_refptr<CrxInstaller> installer(CrxInstaller::CreateSilent(service()));
installer->set_allow_silent_install(true);
installer->InstallUserScript(
path,
ASSERT_EQ(1u, loaded_.size()) << "Nothing was loaded.";
EXPECT_EQ(0u, errors.size()) << "There were errors: "
<< JoinString(errors, ',');
- EXPECT_TRUE(service_->GetExtensionById(loaded_[0]->id(), false)) <<
- path.value();
+ EXPECT_TRUE(service()->GetExtensionById(loaded_[0]->id(), false))
+ << path.value();
installed_ = NULL;
was_update_ = false;
InitializeEmptyExtensionService();
// Simulate shutdown.
- service_->set_browser_terminating_for_test(true);
+ service()->set_browser_terminating_for_test(true);
- base::FilePath path = data_dir_.AppendASCII("good.crx");
- scoped_refptr<CrxInstaller> installer(CrxInstaller::CreateSilent(service_));
+ base::FilePath path = data_dir().AppendASCII("good.crx");
+ scoped_refptr<CrxInstaller> installer(CrxInstaller::CreateSilent(service()));
installer->set_allow_silent_install(true);
installer->InstallCrx(path);
base::RunLoop().RunUntilIdle();
// installing an extension.
TEST_F(ExtensionServiceTest, GrantedPermissions) {
InitializeEmptyExtensionService();
- base::FilePath path = data_dir_
- .AppendASCII("permissions");
+ base::FilePath path = data_dir().AppendASCII("permissions");
base::FilePath pem_path = path.AppendASCII("unknown.pem");
path = path.AppendASCII("unknown");
ASSERT_TRUE(base::PathExists(pem_path));
ASSERT_TRUE(base::PathExists(path));
- ExtensionPrefs* prefs = service_->extension_prefs();
+ ExtensionPrefs* prefs = ExtensionPrefs::Get(profile());
APIPermissionSet expected_api_perms;
URLPatternSet expected_host_perms;
const Extension* extension = PackAndInstallCRX(path, pem_path, INSTALL_NEW);
EXPECT_EQ(0u, GetErrors().size());
- ASSERT_EQ(1u, registry_->enabled_extensions().size());
+ ASSERT_EQ(1u, registry()->enabled_extensions().size());
EXPECT_EQ(permissions_crx, extension->id());
// Verify that the valid API permissions have been recognized.
// default apps.
TEST_F(ExtensionServiceTest, DefaultAppsGrantedPermissions) {
InitializeEmptyExtensionService();
- base::FilePath path = data_dir_
- .AppendASCII("permissions");
+ base::FilePath path = data_dir().AppendASCII("permissions");
base::FilePath pem_path = path.AppendASCII("unknown.pem");
path = path.AppendASCII("unknown");
ASSERT_TRUE(base::PathExists(pem_path));
ASSERT_TRUE(base::PathExists(path));
- ExtensionPrefs* prefs = service_->extension_prefs();
+ ExtensionPrefs* prefs = ExtensionPrefs::Get(profile());
APIPermissionSet expected_api_perms;
URLPatternSet expected_host_perms;
path, pem_path, INSTALL_NEW, Extension::WAS_INSTALLED_BY_DEFAULT);
EXPECT_EQ(0u, GetErrors().size());
- ASSERT_EQ(1u, registry_->enabled_extensions().size());
+ ASSERT_EQ(1u, registry()->enabled_extensions().size());
EXPECT_EQ(permissions_crx, extension->id());
// Verify that the valid API permissions have been recognized.
}
#endif
-#if !defined(OS_CHROMEOS)
+#if !defined(OS_POSIX) || defined(OS_MACOSX)
// Tests that the granted permissions full_access bit gets set correctly when
-// an extension contains an NPAPI plugin. Don't run this test on Chrome OS
-// since they don't support plugins.
+// an extension contains an NPAPI plugin.
+// Only run this on platforms that support NPAPI plugins.
TEST_F(ExtensionServiceTest, GrantedFullAccessPermissions) {
InitPluginService();
ASSERT_TRUE(base::PathExists(good1_path()));
const Extension* extension = PackAndInstallCRX(good1_path(), INSTALL_NEW);
EXPECT_EQ(0u, GetErrors().size());
- EXPECT_EQ(1u, registry_->enabled_extensions().size());
- ExtensionPrefs* prefs = service_->extension_prefs();
+ EXPECT_EQ(1u, registry()->enabled_extensions().size());
+ ExtensionPrefs* prefs = ExtensionPrefs::Get(profile());
scoped_refptr<PermissionSet> permissions(
prefs->GetGrantedPermissions(extension->id()));
TEST_F(ExtensionServiceTest, GrantedAPIAndHostPermissions) {
InitializeEmptyExtensionService();
- base::FilePath path = data_dir_
- .AppendASCII("permissions")
- .AppendASCII("unknown");
+ base::FilePath path =
+ data_dir().AppendASCII("permissions").AppendASCII("unknown");
ASSERT_TRUE(base::PathExists(path));
const Extension* extension = PackAndInstallCRX(path, INSTALL_NEW);
EXPECT_EQ(0u, GetErrors().size());
- EXPECT_EQ(1u, registry_->enabled_extensions().size());
+ EXPECT_EQ(1u, registry()->enabled_extensions().size());
std::string extension_id = extension->id();
- ExtensionPrefs* prefs = service_->extension_prefs();
+ ExtensionPrefs* prefs = ExtensionPrefs::Get(profile());
APIPermissionSet expected_api_permissions;
URLPatternSet expected_host_permissions;
// updating the browser to a version which recognizes a new API permission).
SetPref(extension_id, "granted_permissions.api",
new base::ListValue(), "granted_permissions.api");
- service_->ReloadExtensionsForTest();
+ service()->ReloadExtensionsForTest();
- EXPECT_EQ(1u, registry_->disabled_extensions().size());
- extension = registry_->disabled_extensions().begin()->get();
+ EXPECT_EQ(1u, registry()->disabled_extensions().size());
+ extension = registry()->disabled_extensions().begin()->get();
ASSERT_TRUE(prefs->IsExtensionDisabled(extension_id));
- ASSERT_FALSE(service_->IsExtensionEnabled(extension_id));
+ ASSERT_FALSE(service()->IsExtensionEnabled(extension_id));
ASSERT_TRUE(prefs->DidExtensionEscalatePermissions(extension_id));
// Now grant and re-enable the extension, making sure the prefs are updated.
- service_->GrantPermissionsAndEnableExtension(extension);
+ service()->GrantPermissionsAndEnableExtension(extension);
ASSERT_FALSE(prefs->IsExtensionDisabled(extension_id));
- ASSERT_TRUE(service_->IsExtensionEnabled(extension_id));
+ ASSERT_TRUE(service()->IsExtensionEnabled(extension_id));
ASSERT_FALSE(prefs->DidExtensionEscalatePermissions(extension_id));
scoped_refptr<PermissionSet> current_perms(
SetPrefStringSet(
extension_id, "granted_permissions.scriptable_host", host_permissions);
- service_->ReloadExtensionsForTest();
+ service()->ReloadExtensionsForTest();
- EXPECT_EQ(1u, registry_->disabled_extensions().size());
- extension = registry_->disabled_extensions().begin()->get();
+ EXPECT_EQ(1u, registry()->disabled_extensions().size());
+ extension = registry()->disabled_extensions().begin()->get();
ASSERT_TRUE(prefs->IsExtensionDisabled(extension_id));
- ASSERT_FALSE(service_->IsExtensionEnabled(extension_id));
+ ASSERT_FALSE(service()->IsExtensionEnabled(extension_id));
ASSERT_TRUE(prefs->DidExtensionEscalatePermissions(extension_id));
// Now grant and re-enable the extension, making sure the prefs are updated.
- service_->GrantPermissionsAndEnableExtension(extension);
+ service()->GrantPermissionsAndEnableExtension(extension);
- ASSERT_TRUE(service_->IsExtensionEnabled(extension_id));
+ ASSERT_TRUE(service()->IsExtensionEnabled(extension_id));
ASSERT_FALSE(prefs->DidExtensionEscalatePermissions(extension_id));
current_perms = prefs->GetGrantedPermissions(extension_id);
// Test Packaging and installing an extension.
TEST_F(ExtensionServiceTest, PackExtension) {
InitializeEmptyExtensionService();
- base::FilePath input_directory = data_dir_
- .AppendASCII("good")
- .AppendASCII("Extensions")
- .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj")
- .AppendASCII("1.0.0.0");
+ base::FilePath input_directory =
+ data_dir()
+ .AppendASCII("good")
+ .AppendASCII("Extensions")
+ .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj")
+ .AppendASCII("1.0.0.0");
base::ScopedTempDir temp_dir;
ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
// Try packing with an invalid manifest.
std::string invalid_manifest_content = "I am not a manifest.";
- ASSERT_TRUE(file_util::WriteFile(
+ ASSERT_TRUE(base::WriteFile(
temp_dir2.path().Append(extensions::kManifestFilename),
invalid_manifest_content.c_str(), invalid_manifest_content.size()));
creator.reset(new ExtensionCreator());
// Try packing with a private key that is a valid key, but invalid for the
// extension.
- base::FilePath bad_private_key_dir = data_dir_.AppendASCII("bad_private_key");
+ base::FilePath bad_private_key_dir =
+ data_dir().AppendASCII("bad_private_key");
crx_path = output_directory.AppendASCII("bad_private_key.crx");
- privkey_path = data_dir_.AppendASCII("bad_private_key.pem");
+ privkey_path = data_dir().AppendASCII("bad_private_key.pem");
ASSERT_FALSE(creator->Run(bad_private_key_dir, crx_path, base::FilePath(),
privkey_path, ExtensionCreator::kOverwriteCRX));
}
// Test Packaging and installing an extension whose name contains punctuation.
TEST_F(ExtensionServiceTest, PackPunctuatedExtension) {
InitializeEmptyExtensionService();
- base::FilePath input_directory = data_dir_
- .AppendASCII("good")
- .AppendASCII("Extensions")
- .AppendASCII(good0)
- .AppendASCII("1.0.0.0");
+ base::FilePath input_directory = data_dir()
+ .AppendASCII("good")
+ .AppendASCII("Extensions")
+ .AppendASCII(good0)
+ .AppendASCII("1.0.0.0");
base::ScopedTempDir temp_dir;
ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
base::ScopedTempDir extension_temp_dir;
ASSERT_TRUE(extension_temp_dir.CreateUniqueTempDir());
base::FilePath input_directory = extension_temp_dir.path().AppendASCII("ext");
- ASSERT_TRUE(base::CopyDirectory(
- data_dir_
- .AppendASCII("good")
- .AppendASCII("Extensions")
- .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj")
- .AppendASCII("1.0.0.0"),
- input_directory,
- /*recursive=*/true));
+ ASSERT_TRUE(
+ base::CopyDirectory(data_dir()
+ .AppendASCII("good")
+ .AppendASCII("Extensions")
+ .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj")
+ .AppendASCII("1.0.0.0"),
+ input_directory,
+ /*recursive=*/true));
base::ScopedTempDir output_temp_dir;
ASSERT_TRUE(output_temp_dir.CreateUniqueTempDir());
// PrivateKeyInfo ASN.1 structure, we our RSAPrivateKey expects.
TEST_F(ExtensionServiceTest, PackExtensionOpenSSLKey) {
InitializeEmptyExtensionService();
- base::FilePath input_directory = data_dir_
- .AppendASCII("good")
- .AppendASCII("Extensions")
- .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj")
- .AppendASCII("1.0.0.0");
- base::FilePath privkey_path(data_dir_.AppendASCII(
- "openssl_privkey_asn1.pem"));
+ base::FilePath input_directory =
+ data_dir()
+ .AppendASCII("good")
+ .AppendASCII("Extensions")
+ .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj")
+ .AppendASCII("1.0.0.0");
+ base::FilePath privkey_path(
+ data_dir().AppendASCII("openssl_privkey_asn1.pem"));
ASSERT_TRUE(base::PathExists(privkey_path));
base::ScopedTempDir temp_dir;
InstallCRX(crx_path, INSTALL_NEW);
}
-TEST_F(ExtensionServiceTest, InstallTheme) {
+#if defined(THREAD_SANITIZER)
+// Flaky under Tsan. http://crbug.com/377702
+#define MAYBE_InstallTheme DISABLED_InstallTheme
+#else
+#define MAYBE_InstallTheme InstallTheme
+#endif
+
+TEST_F(ExtensionServiceTest, MAYBE_InstallTheme) {
InitializeEmptyExtensionService();
- service_->Init();
+ service()->Init();
// A theme.
- base::FilePath path = data_dir_.AppendASCII("theme.crx");
+ base::FilePath path = data_dir().AppendASCII("theme.crx");
InstallCRX(path, INSTALL_NEW);
int pref_count = 0;
ValidatePrefKeyCount(++pref_count);
// A theme when extensions are disabled. Themes can be installed, even when
// extensions are disabled.
- set_extensions_enabled(false);
- path = data_dir_.AppendASCII("theme2.crx");
+ service()->set_extensions_enabled(false);
+ path = data_dir().AppendASCII("theme2.crx");
InstallCRX(path, INSTALL_NEW);
ValidatePrefKeyCount(++pref_count);
ValidateIntegerPref(theme2_crx, "state", Extension::ENABLED);
// A theme with extension elements. Themes cannot have extension elements,
// so any such elements (like content scripts) should be ignored.
- set_extensions_enabled(true);
+ service()->set_extensions_enabled(true);
{
- path = data_dir_.AppendASCII("theme_with_extension.crx");
+ path = data_dir().AppendASCII("theme_with_extension.crx");
const Extension* extension = InstallCRX(path, INSTALL_NEW);
ValidatePrefKeyCount(++pref_count);
ASSERT_TRUE(extension);
}
// A theme with image resources missing (misspelt path).
- path = data_dir_.AppendASCII("theme_missing_image.crx");
+ path = data_dir().AppendASCII("theme_missing_image.crx");
InstallCRX(path, INSTALL_FAILED);
ValidatePrefKeyCount(pref_count);
}
TEST_F(ExtensionServiceTest, LoadLocalizedTheme) {
// Load.
InitializeEmptyExtensionService();
- service_->Init();
+ service()->Init();
- base::FilePath extension_path = data_dir_
- .AppendASCII("theme_i18n");
+ base::FilePath extension_path = data_dir().AppendASCII("theme_i18n");
- extensions::UnpackedInstaller::Create(service_)->Load(extension_path);
+ extensions::UnpackedInstaller::Create(service())->Load(extension_path);
base::RunLoop().RunUntilIdle();
EXPECT_EQ(0u, GetErrors().size());
ASSERT_EQ(1u, loaded_.size());
- EXPECT_EQ(1u, registry_->enabled_extensions().size());
- const Extension* theme = registry_->enabled_extensions().begin()->get();
+ EXPECT_EQ(1u, registry()->enabled_extensions().size());
+ const Extension* theme = registry()->enabled_extensions().begin()->get();
EXPECT_EQ("name", theme->name());
EXPECT_EQ("description", theme->description());
base::FilePath extension_path = temp.path();
base::FilePath manifest_path =
extension_path.Append(extensions::kManifestFilename);
- base::FilePath manifest_no_key = data_dir_.
- AppendASCII("unpacked").
- AppendASCII("manifest_no_key.json");
+ base::FilePath manifest_no_key =
+ data_dir().AppendASCII("unpacked").AppendASCII("manifest_no_key.json");
- base::FilePath manifest_with_key = data_dir_.
- AppendASCII("unpacked").
- AppendASCII("manifest_with_key.json");
+ base::FilePath manifest_with_key =
+ data_dir().AppendASCII("unpacked").AppendASCII("manifest_with_key.json");
ASSERT_TRUE(base::PathExists(manifest_no_key));
ASSERT_TRUE(base::PathExists(manifest_with_key));
// Load the unpacked extension with no key.
base::CopyFile(manifest_no_key, manifest_path);
- extensions::UnpackedInstaller::Create(service_)->Load(extension_path);
+ extensions::UnpackedInstaller::Create(service())->Load(extension_path);
base::RunLoop().RunUntilIdle();
EXPECT_EQ(0u, GetErrors().size());
ASSERT_EQ(1u, loaded_.size());
- EXPECT_EQ(1u, registry_->enabled_extensions().size());
+ EXPECT_EQ(1u, registry()->enabled_extensions().size());
// Add the key to the manifest.
base::CopyFile(manifest_with_key, manifest_path);
loaded_.clear();
// Reload the extensions.
- service_->ReloadExtensionsForTest();
- const Extension* extension = service_->GetExtensionById(unpacked, false);
+ service()->ReloadExtensionsForTest();
+ const Extension* extension = service()->GetExtensionById(unpacked, false);
EXPECT_EQ(unpacked, extension->id());
ASSERT_EQ(1u, loaded_.size());
#if defined(OS_POSIX)
TEST_F(ExtensionServiceTest, UnpackedExtensionMayContainSymlinkedFiles) {
- base::FilePath source_data_dir = data_dir_.
- AppendASCII("unpacked").
- AppendASCII("symlinks_allowed");
+ base::FilePath source_data_dir =
+ data_dir().AppendASCII("unpacked").AppendASCII("symlinks_allowed");
// Paths to test data files.
base::FilePath source_manifest = source_data_dir.AppendASCII("manifest.json");
// Load extension.
InitializeEmptyExtensionService();
- extensions::UnpackedInstaller::Create(service_)->Load(extension_path);
+ extensions::UnpackedInstaller::Create(service())->Load(extension_path);
base::RunLoop().RunUntilIdle();
EXPECT_TRUE(GetErrors().empty());
ASSERT_EQ(1u, loaded_.size());
- EXPECT_EQ(1u, registry_->enabled_extensions().size());
+ EXPECT_EQ(1u, registry()->enabled_extensions().size());
}
#endif
TEST_F(ExtensionServiceTest, UnpackedExtensionMayNotHaveUnderscore) {
InitializeEmptyExtensionService();
- base::FilePath extension_path = data_dir_
- .AppendASCII("underscore_name");
- extensions::UnpackedInstaller::Create(service_)->Load(extension_path);
+ base::FilePath extension_path = data_dir().AppendASCII("underscore_name");
+ extensions::UnpackedInstaller::Create(service())->Load(extension_path);
base::RunLoop().RunUntilIdle();
EXPECT_EQ(1u, GetErrors().size());
- EXPECT_EQ(0u, registry_->enabled_extensions().size());
+ EXPECT_EQ(0u, registry()->enabled_extensions().size());
}
TEST_F(ExtensionServiceTest, InstallLocalizedTheme) {
InitializeEmptyExtensionService();
- service_->Init();
+ service()->Init();
- base::FilePath theme_path = data_dir_
- .AppendASCII("theme_i18n");
+ base::FilePath theme_path = data_dir().AppendASCII("theme_i18n");
const Extension* theme = PackAndInstallCRX(theme_path, INSTALL_NEW);
EXPECT_EQ(0u, GetErrors().size());
- EXPECT_EQ(1u, registry_->enabled_extensions().size());
+ EXPECT_EQ(1u, registry()->enabled_extensions().size());
EXPECT_EQ("name", theme->name());
EXPECT_EQ("description", theme->description());
}
InitializeEmptyExtensionService();
// An empty app.
- const Extension* app = PackAndInstallCRX(data_dir_.AppendASCII("app1"),
- INSTALL_NEW);
+ const Extension* app =
+ PackAndInstallCRX(data_dir().AppendASCII("app1"), INSTALL_NEW);
int pref_count = 0;
ValidatePrefKeyCount(++pref_count);
- ASSERT_EQ(1u, registry_->enabled_extensions().size());
+ ASSERT_EQ(1u, registry()->enabled_extensions().size());
ValidateIntegerPref(app->id(), "state", Extension::ENABLED);
ValidateIntegerPref(app->id(), "location", Manifest::INTERNAL);
// Another app with non-overlapping extent. Should succeed.
- PackAndInstallCRX(data_dir_.AppendASCII("app2"), INSTALL_NEW);
+ PackAndInstallCRX(data_dir().AppendASCII("app2"), INSTALL_NEW);
ValidatePrefKeyCount(++pref_count);
// A third app whose extent overlaps the first. Should fail.
- PackAndInstallCRX(data_dir_.AppendASCII("app3"), INSTALL_FAILED);
+ PackAndInstallCRX(data_dir().AppendASCII("app3"), INSTALL_FAILED);
ValidatePrefKeyCount(pref_count);
}
// Tests that file access is OFF by default.
TEST_F(ExtensionServiceTest, DefaultFileAccess) {
InitializeEmptyExtensionService();
- const Extension* extension =
- PackAndInstallCRX(data_dir_
- .AppendASCII("permissions")
- .AppendASCII("files"),
- INSTALL_NEW);
+ const Extension* extension = PackAndInstallCRX(
+ data_dir().AppendASCII("permissions").AppendASCII("files"), INSTALL_NEW);
EXPECT_EQ(0u, GetErrors().size());
- EXPECT_EQ(1u, registry_->enabled_extensions().size());
- EXPECT_FALSE(service_->extension_prefs()->AllowFileAccess(extension->id()));
+ EXPECT_EQ(1u, registry()->enabled_extensions().size());
+ EXPECT_FALSE(
+ ExtensionPrefs::Get(profile())->AllowFileAccess(extension->id()));
}
TEST_F(ExtensionServiceTest, UpdateApps) {
InitializeEmptyExtensionService();
- base::FilePath extensions_path = data_dir_.AppendASCII("app_update");
+ base::FilePath extensions_path = data_dir().AppendASCII("app_update");
// First install v1 of a hosted app.
const Extension* extension =
InstallCRX(extensions_path.AppendASCII("v1.crx"), INSTALL_NEW);
- ASSERT_EQ(1u, registry_->enabled_extensions().size());
+ ASSERT_EQ(1u, registry()->enabled_extensions().size());
std::string id = extension->id();
ASSERT_EQ(std::string("1"), extension->version()->GetString());
extensions_path.AppendASCII("v2.crx"),
ENABLED);
ASSERT_EQ(std::string("2"),
- service_->GetExtensionById(id, false)->version()->GetString());
+ service()->GetExtensionById(id, false)->version()->GetString());
}
// Verifies that the NTP page and launch ordinals are kept when updating apps.
TEST_F(ExtensionServiceTest, UpdateAppsRetainOrdinals) {
InitializeEmptyExtensionService();
- AppSorting* sorting = service_->extension_prefs()->app_sorting();
- base::FilePath extensions_path = data_dir_.AppendASCII("app_update");
+ AppSorting* sorting = ExtensionPrefs::Get(profile())->app_sorting();
+ base::FilePath extensions_path = data_dir().AppendASCII("app_update");
// First install v1 of a hosted app.
const Extension* extension =
InstallCRX(extensions_path.AppendASCII("v1.crx"), INSTALL_NEW);
- ASSERT_EQ(1u, registry_->enabled_extensions().size());
+ ASSERT_EQ(1u, registry()->enabled_extensions().size());
std::string id = extension->id();
ASSERT_EQ(std::string("1"), extension->version()->GetString());
// Now try updating to v2.
UpdateExtension(id, extensions_path.AppendASCII("v2.crx"), ENABLED);
ASSERT_EQ(std::string("2"),
- service_->GetExtensionById(id, false)->version()->GetString());
+ service()->GetExtensionById(id, false)->version()->GetString());
// Verify that the ordinals match.
ASSERT_TRUE(new_page_ordinal.Equals(sorting->GetPageOrdinal(id)));
// Ensures that the CWS has properly initialized ordinals.
TEST_F(ExtensionServiceTest, EnsureCWSOrdinalsInitialized) {
InitializeEmptyExtensionService();
- service_->component_loader()->Add(
+ service()->component_loader()->Add(
IDR_WEBSTORE_MANIFEST, base::FilePath(FILE_PATH_LITERAL("web_store")));
- service_->Init();
+ service()->Init();
- AppSorting* sorting = service_->extension_prefs()->app_sorting();
+ AppSorting* sorting = ExtensionPrefs::Get(profile())->app_sorting();
EXPECT_TRUE(
sorting->GetPageOrdinal(extension_misc::kWebStoreAppId).IsValid());
EXPECT_TRUE(
TEST_F(ExtensionServiceTest, InstallAppsWithUnlimitedStorage) {
InitializeEmptyExtensionService();
- EXPECT_TRUE(registry_->enabled_extensions().is_empty());
+ EXPECT_TRUE(registry()->enabled_extensions().is_empty());
int pref_count = 0;
// Install app1 with unlimited storage.
const Extension* extension =
- PackAndInstallCRX(data_dir_.AppendASCII("app1"), INSTALL_NEW);
+ PackAndInstallCRX(data_dir().AppendASCII("app1"), INSTALL_NEW);
ValidatePrefKeyCount(++pref_count);
- ASSERT_EQ(1u, registry_->enabled_extensions().size());
+ ASSERT_EQ(1u, registry()->enabled_extensions().size());
const std::string id1 = extension->id();
- EXPECT_TRUE(extension->HasAPIPermission(
+ EXPECT_TRUE(extension->permissions_data()->HasAPIPermission(
APIPermission::kUnlimitedStorage));
EXPECT_TRUE(extension->web_extent().MatchesURL(
extensions::AppLaunchInfo::GetFullLaunchURL(extension)));
const GURL origin1(
extensions::AppLaunchInfo::GetFullLaunchURL(extension).GetOrigin());
- EXPECT_TRUE(profile_->GetExtensionSpecialStoragePolicy()->
- IsStorageUnlimited(origin1));
+ EXPECT_TRUE(profile()->GetExtensionSpecialStoragePolicy()->IsStorageUnlimited(
+ origin1));
// Install app2 from the same origin with unlimited storage.
- extension = PackAndInstallCRX(data_dir_.AppendASCII("app2"), INSTALL_NEW);
+ extension = PackAndInstallCRX(data_dir().AppendASCII("app2"), INSTALL_NEW);
ValidatePrefKeyCount(++pref_count);
- ASSERT_EQ(2u, registry_->enabled_extensions().size());
+ ASSERT_EQ(2u, registry()->enabled_extensions().size());
const std::string id2 = extension->id();
- EXPECT_TRUE(extension->HasAPIPermission(
+ EXPECT_TRUE(extension->permissions_data()->HasAPIPermission(
APIPermission::kUnlimitedStorage));
EXPECT_TRUE(extension->web_extent().MatchesURL(
extensions::AppLaunchInfo::GetFullLaunchURL(extension)));
const GURL origin2(
extensions::AppLaunchInfo::GetFullLaunchURL(extension).GetOrigin());
EXPECT_EQ(origin1, origin2);
- EXPECT_TRUE(profile_->GetExtensionSpecialStoragePolicy()->
- IsStorageUnlimited(origin2));
-
+ EXPECT_TRUE(profile()->GetExtensionSpecialStoragePolicy()->IsStorageUnlimited(
+ origin2));
// Uninstall one of them, unlimited storage should still be granted
// to the origin.
UninstallExtension(id1, false);
- EXPECT_EQ(1u, registry_->enabled_extensions().size());
- EXPECT_TRUE(profile_->GetExtensionSpecialStoragePolicy()->
- IsStorageUnlimited(origin1));
+ EXPECT_EQ(1u, registry()->enabled_extensions().size());
+ EXPECT_TRUE(profile()->GetExtensionSpecialStoragePolicy()->IsStorageUnlimited(
+ origin1));
// Uninstall the other, unlimited storage should be revoked.
UninstallExtension(id2, false);
- EXPECT_EQ(0u, registry_->enabled_extensions().size());
- EXPECT_FALSE(profile_->GetExtensionSpecialStoragePolicy()->
- IsStorageUnlimited(origin2));
+ EXPECT_EQ(0u, registry()->enabled_extensions().size());
+ EXPECT_FALSE(
+ profile()->GetExtensionSpecialStoragePolicy()->IsStorageUnlimited(
+ origin2));
}
TEST_F(ExtensionServiceTest, InstallAppsAndCheckStorageProtection) {
InitializeEmptyExtensionService();
- EXPECT_TRUE(registry_->enabled_extensions().is_empty());
+ EXPECT_TRUE(registry()->enabled_extensions().is_empty());
int pref_count = 0;
const Extension* extension =
- PackAndInstallCRX(data_dir_.AppendASCII("app1"), INSTALL_NEW);
+ PackAndInstallCRX(data_dir().AppendASCII("app1"), INSTALL_NEW);
ValidatePrefKeyCount(++pref_count);
- ASSERT_EQ(1u, registry_->enabled_extensions().size());
+ ASSERT_EQ(1u, registry()->enabled_extensions().size());
EXPECT_TRUE(extension->is_app());
const std::string id1 = extension->id();
const GURL origin1(
extensions::AppLaunchInfo::GetFullLaunchURL(extension).GetOrigin());
- EXPECT_TRUE(profile_->GetExtensionSpecialStoragePolicy()->
- IsStorageProtected(origin1));
+ EXPECT_TRUE(profile()->GetExtensionSpecialStoragePolicy()->IsStorageProtected(
+ origin1));
// App 4 has a different origin (maps.google.com).
- extension = PackAndInstallCRX(data_dir_.AppendASCII("app4"), INSTALL_NEW);
+ extension = PackAndInstallCRX(data_dir().AppendASCII("app4"), INSTALL_NEW);
ValidatePrefKeyCount(++pref_count);
- ASSERT_EQ(2u, registry_->enabled_extensions().size());
+ ASSERT_EQ(2u, registry()->enabled_extensions().size());
const std::string id2 = extension->id();
const GURL origin2(
extensions::AppLaunchInfo::GetFullLaunchURL(extension).GetOrigin());
ASSERT_NE(origin1, origin2);
- EXPECT_TRUE(profile_->GetExtensionSpecialStoragePolicy()->
- IsStorageProtected(origin2));
+ EXPECT_TRUE(profile()->GetExtensionSpecialStoragePolicy()->IsStorageProtected(
+ origin2));
UninstallExtension(id1, false);
- EXPECT_EQ(1u, registry_->enabled_extensions().size());
+ EXPECT_EQ(1u, registry()->enabled_extensions().size());
UninstallExtension(id2, false);
- EXPECT_TRUE(registry_->enabled_extensions().is_empty());
- EXPECT_FALSE(profile_->GetExtensionSpecialStoragePolicy()->
- IsStorageProtected(origin1));
- EXPECT_FALSE(profile_->GetExtensionSpecialStoragePolicy()->
- IsStorageProtected(origin2));
+ EXPECT_TRUE(registry()->enabled_extensions().is_empty());
+ EXPECT_FALSE(
+ profile()->GetExtensionSpecialStoragePolicy()->IsStorageProtected(
+ origin1));
+ EXPECT_FALSE(
+ profile()->GetExtensionSpecialStoragePolicy()->IsStorageProtected(
+ origin2));
}
// Test that when an extension version is reinstalled, nothing happens.
InitializeEmptyExtensionService();
// A simple extension that should install without error.
- base::FilePath path = data_dir_.AppendASCII("good.crx");
+ base::FilePath path = data_dir().AppendASCII("good.crx");
InstallCRX(path, INSTALL_NEW);
ValidatePrefKeyCount(1);
InitializeEmptyExtensionService();
// A simple extension that should install without error.
- base::FilePath path = data_dir_.AppendASCII("good.crx");
+ base::FilePath path = data_dir().AppendASCII("good.crx");
// Not from web store.
const Extension* extension = InstallCRX(path, INSTALL_NEW);
std::string id = extension->id();
ASSERT_TRUE(ValidateBooleanPref(good_crx, "from_webstore", true));
// Reload so extension gets reinitialized with new value.
- service_->ReloadExtensionsForTest();
- extension = service_->GetExtensionById(id, false);
+ service()->ReloadExtensionsForTest();
+ extension = service()->GetExtensionById(id, false);
ASSERT_TRUE(extension->from_webstore());
// Upgrade to version 2.0
- path = data_dir_.AppendASCII("good2.crx");
+ path = data_dir().AppendASCII("good2.crx");
UpdateExtension(good_crx, path, ENABLED);
ValidatePrefKeyCount(1);
ASSERT_TRUE(ValidateBooleanPref(good_crx, "from_webstore", true));
TEST_F(ExtensionServiceTest, UpgradeSignedGood) {
InitializeEmptyExtensionService();
- base::FilePath path = data_dir_.AppendASCII("good.crx");
+ base::FilePath path = data_dir().AppendASCII("good.crx");
const Extension* extension = InstallCRX(path, INSTALL_NEW);
std::string id = extension->id();
// Upgrade to version 1.0.0.1.
// Also test that the extension's old and new title are correctly retrieved.
- path = data_dir_.AppendASCII("good2.crx");
+ path = data_dir().AppendASCII("good2.crx");
InstallCRX(path, INSTALL_UPDATED, Extension::NO_FLAGS, "My extension 1");
- extension = service_->GetExtensionById(id, false);
+ extension = service()->GetExtensionById(id, false);
ASSERT_EQ("1.0.0.1", extension->version()->GetString());
ASSERT_EQ("My updated extension 1", extension->name());
TEST_F(ExtensionServiceTest, UpgradeSignedBad) {
InitializeEmptyExtensionService();
- base::FilePath path = data_dir_.AppendASCII("good.crx");
+ base::FilePath path = data_dir().AppendASCII("good.crx");
InstallCRX(path, INSTALL_NEW);
// Try upgrading with a bad signature. This should fail during the unpack,
// because the key will not match the signature.
- path = data_dir_.AppendASCII("bad_signature.crx");
+ path = data_dir().AppendASCII("bad_signature.crx");
InstallCRX(path, INSTALL_FAILED);
}
TEST_F(ExtensionServiceTest, UpdateExtension) {
InitializeEmptyExtensionService();
- base::FilePath path = data_dir_.AppendASCII("good.crx");
+ base::FilePath path = data_dir().AppendASCII("good.crx");
const Extension* good = InstallCRX(path, INSTALL_NEW);
ASSERT_EQ("1.0.0.0", good->VersionString());
ASSERT_EQ(good_crx, good->id());
- path = data_dir_.AppendASCII("good2.crx");
+ path = data_dir().AppendASCII("good2.crx");
UpdateExtension(good_crx, path, ENABLED);
- ASSERT_EQ("1.0.0.1",
- service_->GetExtensionById(good_crx, false)->
- version()->GetString());
+ ASSERT_EQ(
+ "1.0.0.1",
+ service()->GetExtensionById(good_crx, false)->version()->GetString());
}
// Extensions should not be updated during browser shutdown.
InitializeEmptyExtensionService();
// Install an extension.
- base::FilePath path = data_dir_.AppendASCII("good.crx");
+ base::FilePath path = data_dir().AppendASCII("good.crx");
const Extension* good = InstallCRX(path, INSTALL_NEW);
ASSERT_EQ(good_crx, good->id());
// Simulate shutdown.
- service_->set_browser_terminating_for_test(true);
+ service()->set_browser_terminating_for_test(true);
// Update should fail and extension should not be updated.
- path = data_dir_.AppendASCII("good2.crx");
- bool updated = service_->UpdateExtension(good_crx, path, true, GURL(), NULL);
+ path = data_dir().AppendASCII("good2.crx");
+ bool updated = service()->UpdateExtension(good_crx, path, true, NULL);
ASSERT_FALSE(updated);
- ASSERT_EQ("1.0.0.0",
- service_->GetExtensionById(good_crx, false)->
- version()->GetString());
+ ASSERT_EQ(
+ "1.0.0.0",
+ service()->GetExtensionById(good_crx, false)->version()->GetString());
}
// Test updating a not-already-installed extension - this should fail
TEST_F(ExtensionServiceTest, UpdateNotInstalledExtension) {
InitializeEmptyExtensionService();
- base::FilePath path = data_dir_.AppendASCII("good.crx");
+ base::FilePath path = data_dir().AppendASCII("good.crx");
UpdateExtension(good_crx, path, UPDATED);
base::RunLoop().RunUntilIdle();
- ASSERT_EQ(0u, registry_->enabled_extensions().size());
+ ASSERT_EQ(0u, registry()->enabled_extensions().size());
ASSERT_FALSE(installed_);
ASSERT_EQ(0u, loaded_.size());
}
TEST_F(ExtensionServiceTest, UpdateWillNotDowngrade) {
InitializeEmptyExtensionService();
- base::FilePath path = data_dir_.AppendASCII("good2.crx");
+ base::FilePath path = data_dir().AppendASCII("good2.crx");
const Extension* good = InstallCRX(path, INSTALL_NEW);
ASSERT_EQ("1.0.0.1", good->VersionString());
ASSERT_EQ(good_crx, good->id());
// Change path from good2.crx -> good.crx
- path = data_dir_.AppendASCII("good.crx");
+ path = data_dir().AppendASCII("good.crx");
UpdateExtension(good_crx, path, FAILED);
- ASSERT_EQ("1.0.0.1",
- service_->GetExtensionById(good_crx, false)->
- version()->GetString());
+ ASSERT_EQ(
+ "1.0.0.1",
+ service()->GetExtensionById(good_crx, false)->version()->GetString());
}
// Make sure calling update with an identical version does nothing
TEST_F(ExtensionServiceTest, UpdateToSameVersionIsNoop) {
InitializeEmptyExtensionService();
- base::FilePath path = data_dir_.AppendASCII("good.crx");
+ base::FilePath path = data_dir().AppendASCII("good.crx");
const Extension* good = InstallCRX(path, INSTALL_NEW);
ASSERT_EQ(good_crx, good->id());
TEST_F(ExtensionServiceTest, UpdateExtensionPreservesState) {
InitializeEmptyExtensionService();
- base::FilePath path = data_dir_.AppendASCII("good.crx");
+ base::FilePath path = data_dir().AppendASCII("good.crx");
const Extension* good = InstallCRX(path, INSTALL_NEW);
ASSERT_EQ("1.0.0.0", good->VersionString());
// Disable it and allow it to run in incognito. These settings should carry
// over to the updated version.
- service_->DisableExtension(good->id(), Extension::DISABLE_USER_ACTION);
- extensions::util::SetIsIncognitoEnabled(good->id(), profile_.get(), true);
- service_->extension_prefs()->SetDidExtensionEscalatePermissions(good, true);
+ service()->DisableExtension(good->id(), Extension::DISABLE_USER_ACTION);
+ extensions::util::SetIsIncognitoEnabled(good->id(), profile(), true);
+ ExtensionPrefs::Get(profile())
+ ->SetDidExtensionEscalatePermissions(good, true);
- path = data_dir_.AppendASCII("good2.crx");
+ path = data_dir().AppendASCII("good2.crx");
UpdateExtension(good_crx, path, INSTALLED);
- ASSERT_EQ(1u, registry_->disabled_extensions().size());
- const Extension* good2 = service_->GetExtensionById(good_crx, true);
+ ASSERT_EQ(1u, registry()->disabled_extensions().size());
+ const Extension* good2 = service()->GetExtensionById(good_crx, true);
ASSERT_EQ("1.0.0.1", good2->version()->GetString());
- EXPECT_TRUE(extensions::util::IsIncognitoEnabled(
- good2->id(), profile_.get()));
- EXPECT_TRUE(service_->extension_prefs()->DidExtensionEscalatePermissions(
- good2->id()));
+ EXPECT_TRUE(extensions::util::IsIncognitoEnabled(good2->id(), profile()));
+ EXPECT_TRUE(ExtensionPrefs::Get(profile())
+ ->DidExtensionEscalatePermissions(good2->id()));
}
// Tests that updating preserves extension location.
TEST_F(ExtensionServiceTest, UpdateExtensionPreservesLocation) {
InitializeEmptyExtensionService();
- base::FilePath path = data_dir_.AppendASCII("good.crx");
+ base::FilePath path = data_dir().AppendASCII("good.crx");
const Extension* good =
InstallCRXWithLocation(path, Manifest::EXTERNAL_PREF, INSTALL_NEW);
ASSERT_EQ("1.0.0.0", good->VersionString());
ASSERT_EQ(good_crx, good->id());
- path = data_dir_.AppendASCII("good2.crx");
+ path = data_dir().AppendASCII("good2.crx");
UpdateExtension(good_crx, path, ENABLED);
- const Extension* good2 = service_->GetExtensionById(good_crx, false);
+ const Extension* good2 = service()->GetExtensionById(good_crx, false);
ASSERT_EQ("1.0.0.1", good2->version()->GetString());
EXPECT_EQ(good2->location(), Manifest::EXTERNAL_PREF);
}
JSONFileValueSerializer serializer(manifest_path);
ASSERT_TRUE(serializer.Serialize(manifest));
- extensions::UnpackedInstaller::Create(service_)->Load(extension_path);
+ extensions::UnpackedInstaller::Create(service())->Load(extension_path);
base::RunLoop().RunUntilIdle();
EXPECT_EQ(0u, GetErrors().size());
ASSERT_EQ(1u, loaded_.size());
EXPECT_EQ(Manifest::UNPACKED, loaded_[0]->location());
- EXPECT_EQ(1u, registry_->enabled_extensions().size());
+ EXPECT_EQ(1u, registry()->enabled_extensions().size());
EXPECT_EQ("2.0", loaded_[0]->VersionString());
// Now set the version number to 1.0, reload the extensions and verify that
manifest.SetString("version", "1.0");
ASSERT_TRUE(serializer.Serialize(manifest));
- extensions::UnpackedInstaller::Create(service_)->Load(extension_path);
+ extensions::UnpackedInstaller::Create(service())->Load(extension_path);
base::RunLoop().RunUntilIdle();
EXPECT_EQ(0u, GetErrors().size());
ASSERT_EQ(1u, loaded_.size());
EXPECT_EQ(Manifest::UNPACKED, loaded_[0]->location());
- EXPECT_EQ(1u, registry_->enabled_extensions().size());
+ EXPECT_EQ(1u, registry()->enabled_extensions().size());
EXPECT_EQ("1.0", loaded_[0]->VersionString());
}
-#if !defined(OS_CHROMEOS)
+#if !defined(OS_POSIX) || defined(OS_MACOSX)
// LOAD extensions with plugins require approval.
+// Only run this on platforms that support NPAPI plugins.
TEST_F(ExtensionServiceTest, LoadExtensionsWithPlugins) {
base::FilePath extension_with_plugin_path = good1_path();
base::FilePath extension_no_plugin_path = good2_path();
InitPluginService();
InitializeEmptyExtensionService();
InitializeProcessManager();
- service_->set_show_extensions_prompts(true);
+ service()->set_show_extensions_prompts(true);
// Start by canceling any install prompts.
- CommandLine::ForCurrentProcess()->AppendSwitchASCII(
- switches::kAppsGalleryInstallAutoConfirmForTests,
- "cancel");
+ ExtensionInstallPrompt::g_auto_confirm_for_tests =
+ ExtensionInstallPrompt::CANCEL;
// The extension that has a plugin should not install.
- extensions::UnpackedInstaller::Create(service_)->Load(
- extension_with_plugin_path);
+ extensions::UnpackedInstaller::Create(service())
+ ->Load(extension_with_plugin_path);
base::RunLoop().RunUntilIdle();
EXPECT_EQ(0u, GetErrors().size());
EXPECT_EQ(0u, loaded_.size());
- EXPECT_EQ(0u, registry_->enabled_extensions().size());
- EXPECT_EQ(0u, registry_->disabled_extensions().size());
+ EXPECT_EQ(0u, registry()->enabled_extensions().size());
+ EXPECT_EQ(0u, registry()->disabled_extensions().size());
// But the extension with no plugin should since there's no prompt.
ExtensionErrorReporter::GetInstance()->ClearErrors();
- extensions::UnpackedInstaller::Create(service_)->Load(
- extension_no_plugin_path);
+ extensions::UnpackedInstaller::Create(service())
+ ->Load(extension_no_plugin_path);
base::RunLoop().RunUntilIdle();
EXPECT_EQ(0u, GetErrors().size());
EXPECT_EQ(1u, loaded_.size());
- EXPECT_EQ(1u, registry_->enabled_extensions().size());
- EXPECT_EQ(0u, registry_->disabled_extensions().size());
- EXPECT_TRUE(registry_->enabled_extensions().Contains(good2));
+ EXPECT_EQ(1u, registry()->enabled_extensions().size());
+ EXPECT_EQ(0u, registry()->disabled_extensions().size());
+ EXPECT_TRUE(registry()->enabled_extensions().Contains(good2));
// The plugin extension should install if we accept the dialog.
- CommandLine::ForCurrentProcess()->AppendSwitchASCII(
- switches::kAppsGalleryInstallAutoConfirmForTests,
- "accept");
+ ExtensionInstallPrompt::g_auto_confirm_for_tests =
+ ExtensionInstallPrompt::ACCEPT;
ExtensionErrorReporter::GetInstance()->ClearErrors();
- extensions::UnpackedInstaller::Create(service_)->Load(
- extension_with_plugin_path);
+ extensions::UnpackedInstaller::Create(service())
+ ->Load(extension_with_plugin_path);
base::RunLoop().RunUntilIdle();
EXPECT_EQ(0u, GetErrors().size());
EXPECT_EQ(2u, loaded_.size());
- EXPECT_EQ(2u, registry_->enabled_extensions().size());
- EXPECT_EQ(0u, registry_->disabled_extensions().size());
- EXPECT_TRUE(registry_->enabled_extensions().Contains(good1));
- EXPECT_TRUE(registry_->enabled_extensions().Contains(good2));
+ EXPECT_EQ(2u, registry()->enabled_extensions().size());
+ EXPECT_EQ(0u, registry()->disabled_extensions().size());
+ EXPECT_TRUE(registry()->enabled_extensions().Contains(good1));
+ EXPECT_TRUE(registry()->enabled_extensions().Contains(good2));
// Make sure the granted permissions have been setup.
scoped_refptr<PermissionSet> permissions(
- service_->extension_prefs()->GetGrantedPermissions(good1));
+ ExtensionPrefs::Get(profile())->GetGrantedPermissions(good1));
EXPECT_FALSE(permissions->IsEmpty());
EXPECT_TRUE(permissions->HasEffectiveFullAccess());
EXPECT_FALSE(permissions->apis().empty());
// We should be able to reload the extension without getting another prompt.
loaded_.clear();
- CommandLine::ForCurrentProcess()->AppendSwitchASCII(
- switches::kAppsGalleryInstallAutoConfirmForTests,
- "cancel");
+ ExtensionInstallPrompt::g_auto_confirm_for_tests =
+ ExtensionInstallPrompt::CANCEL;
- service_->ReloadExtension(good1);
+ service()->ReloadExtension(good1);
base::RunLoop().RunUntilIdle();
EXPECT_EQ(1u, loaded_.size());
- EXPECT_EQ(2u, registry_->enabled_extensions().size());
- EXPECT_EQ(0u, registry_->disabled_extensions().size());
+ EXPECT_EQ(2u, registry()->enabled_extensions().size());
+ EXPECT_EQ(0u, registry()->disabled_extensions().size());
}
-#endif // !defined(OS_CHROMEOS)
+#endif // !defined(OS_POSIX) || defined(OS_MACOSX)
namespace {
return extension->GetType() == Manifest::TYPE_EXTENSION;
}
+#if defined(ENABLE_BLACKLIST_TESTS)
+std::set<std::string> StringSet(const std::string& s) {
+ std::set<std::string> set;
+ set.insert(s);
+ return set;
+}
+std::set<std::string> StringSet(const std::string& s1, const std::string& s2) {
+ std::set<std::string> set = StringSet(s1);
+ set.insert(s2);
+ return set;
+}
+#endif // defined(ENABLE_BLACKLIST_TESTS)
+
} // namespace
// Test adding a pending extension.
const std::string kFakeId(all_zero);
const GURL kFakeUpdateURL("http:://fake.update/url");
const bool kFakeInstallSilently(true);
+ const bool kFakeRemoteInstall(false);
+ const bool kFakeInstalledByCustodian(false);
- EXPECT_TRUE(service_->pending_extension_manager()->AddFromSync(
- kFakeId, kFakeUpdateURL, &IsExtension,
- kFakeInstallSilently));
+ EXPECT_TRUE(
+ service()->pending_extension_manager()->AddFromSync(
+ kFakeId,
+ kFakeUpdateURL,
+ &IsExtension,
+ kFakeInstallSilently,
+ kFakeRemoteInstall,
+ kFakeInstalledByCustodian));
const extensions::PendingExtensionInfo* pending_extension_info;
- ASSERT_TRUE((pending_extension_info = service_->pending_extension_manager()->
- GetById(kFakeId)));
+ ASSERT_TRUE((pending_extension_info =
+ service()->pending_extension_manager()->GetById(kFakeId)));
EXPECT_EQ(kFakeUpdateURL, pending_extension_info->update_url());
EXPECT_EQ(&IsExtension, pending_extension_info->should_allow_install_);
EXPECT_EQ(kFakeInstallSilently, pending_extension_info->install_silently());
+ // Use
+ // EXPECT_TRUE(kFakeRemoteInstall == pending_extension_info->remote_install())
+ // instead of
+ // EXPECT_EQ(kFakeRemoteInstall, pending_extension_info->remote_install())
+ // as gcc 4.7 issues the following warning on EXPECT_EQ(false, x), which is
+ // turned into an error with -Werror=conversion-null:
+ // converting 'false' to pointer type for argument 1 of
+ // 'char testing::internal::IsNullLiteralHelper(testing::internal::Secret*)'
+ // https://code.google.com/p/googletest/issues/detail?id=458
+ EXPECT_TRUE(kFakeRemoteInstall == pending_extension_info->remote_install());
}
namespace {
const char kGoodUpdateURL[] = "http://good.update/url";
const bool kGoodIsFromSync = true;
const bool kGoodInstallSilently = true;
+const bool kGoodRemoteInstall = false;
+const bool kGoodInstalledByCustodian = false;
} // namespace
// Test updating a pending extension.
TEST_F(ExtensionServiceTest, UpdatePendingExtension) {
InitializeEmptyExtensionService();
- EXPECT_TRUE(service_->pending_extension_manager()->AddFromSync(
- kGoodId, GURL(kGoodUpdateURL), &IsExtension,
- kGoodInstallSilently));
- EXPECT_TRUE(service_->pending_extension_manager()->IsIdPending(kGoodId));
-
- base::FilePath path = data_dir_.AppendASCII("good.crx");
+ EXPECT_TRUE(
+ service()->pending_extension_manager()->AddFromSync(
+ kGoodId,
+ GURL(kGoodUpdateURL),
+ &IsExtension,
+ kGoodInstallSilently,
+ kGoodRemoteInstall,
+ kGoodInstalledByCustodian));
+ EXPECT_TRUE(service()->pending_extension_manager()->IsIdPending(kGoodId));
+
+ base::FilePath path = data_dir().AppendASCII("good.crx");
UpdateExtension(kGoodId, path, ENABLED);
- EXPECT_FALSE(service_->pending_extension_manager()->IsIdPending(kGoodId));
+ EXPECT_FALSE(service()->pending_extension_manager()->IsIdPending(kGoodId));
- const Extension* extension = service_->GetExtensionById(kGoodId, true);
+ const Extension* extension = service()->GetExtensionById(kGoodId, true);
ASSERT_TRUE(extension);
}
// Disabled due to ASAN failure. http://crbug.com/108320
TEST_F(ExtensionServiceTest, DISABLED_UpdatePendingTheme) {
InitializeEmptyExtensionService();
- EXPECT_TRUE(service_->pending_extension_manager()->AddFromSync(
- theme_crx, GURL(), &IsTheme, false));
- EXPECT_TRUE(service_->pending_extension_manager()->IsIdPending(theme_crx));
+ EXPECT_TRUE(service()->pending_extension_manager()->AddFromSync(
+ theme_crx, GURL(), &IsTheme, false, false, false));
+ EXPECT_TRUE(service()->pending_extension_manager()->IsIdPending(theme_crx));
- base::FilePath path = data_dir_.AppendASCII("theme.crx");
+ base::FilePath path = data_dir().AppendASCII("theme.crx");
UpdateExtension(theme_crx, path, ENABLED);
- EXPECT_FALSE(service_->pending_extension_manager()->IsIdPending(theme_crx));
+ EXPECT_FALSE(service()->pending_extension_manager()->IsIdPending(theme_crx));
- const Extension* extension = service_->GetExtensionById(theme_crx, true);
+ const Extension* extension = service()->GetExtensionById(theme_crx, true);
ASSERT_TRUE(extension);
EXPECT_FALSE(
- service_->extension_prefs()->IsExtensionDisabled(extension->id()));
- EXPECT_TRUE(service_->IsExtensionEnabled(theme_crx));
+ ExtensionPrefs::Get(profile())->IsExtensionDisabled(extension->id()));
+ EXPECT_TRUE(service()->IsExtensionEnabled(theme_crx));
}
#if defined(OS_CHROMEOS)
// or not.
TEST_F(ExtensionServiceTest, MAYBE_UpdatePendingExternalCrx) {
InitializeEmptyExtensionService();
- EXPECT_TRUE(service_->pending_extension_manager()->AddFromExternalUpdateUrl(
- theme_crx, GURL(), Manifest::EXTERNAL_PREF_DOWNLOAD, Extension::NO_FLAGS,
+ EXPECT_TRUE(service()->pending_extension_manager()->AddFromExternalUpdateUrl(
+ theme_crx,
+ std::string(),
+ GURL(),
+ Manifest::EXTERNAL_PREF_DOWNLOAD,
+ Extension::NO_FLAGS,
false));
- EXPECT_TRUE(service_->pending_extension_manager()->IsIdPending(theme_crx));
+ EXPECT_TRUE(service()->pending_extension_manager()->IsIdPending(theme_crx));
- base::FilePath path = data_dir_.AppendASCII("theme.crx");
+ base::FilePath path = data_dir().AppendASCII("theme.crx");
UpdateExtension(theme_crx, path, ENABLED);
- EXPECT_FALSE(service_->pending_extension_manager()->IsIdPending(theme_crx));
+ EXPECT_FALSE(service()->pending_extension_manager()->IsIdPending(theme_crx));
- const Extension* extension = service_->GetExtensionById(theme_crx, true);
+ const Extension* extension = service()->GetExtensionById(theme_crx, true);
ASSERT_TRUE(extension);
EXPECT_FALSE(
- service_->extension_prefs()->IsExtensionDisabled(extension->id()));
- EXPECT_TRUE(service_->IsExtensionEnabled(extension->id()));
- EXPECT_FALSE(extensions::util::IsIncognitoEnabled(extension->id(),
- profile_.get()));
+ ExtensionPrefs::Get(profile())->IsExtensionDisabled(extension->id()));
+ EXPECT_TRUE(service()->IsExtensionEnabled(extension->id()));
+ EXPECT_FALSE(
+ extensions::util::IsIncognitoEnabled(extension->id(), profile()));
}
// Test updating a pending CRX as if the source is an external extension
InitializeEmptyExtensionService();
// Add a crx to be installed from the update mechanism.
- EXPECT_TRUE(service_->pending_extension_manager()->AddFromSync(
- kGoodId, GURL(kGoodUpdateURL), &IsExtension,
- kGoodInstallSilently));
+ EXPECT_TRUE(
+ service()->pending_extension_manager()->AddFromSync(
+ kGoodId,
+ GURL(kGoodUpdateURL),
+ &IsExtension,
+ kGoodInstallSilently,
+ kGoodRemoteInstall,
+ kGoodInstalledByCustodian));
// Check that there is a pending crx, with is_from_sync set to true.
const extensions::PendingExtensionInfo* pending_extension_info;
- ASSERT_TRUE((pending_extension_info = service_->pending_extension_manager()->
- GetById(kGoodId)));
+ ASSERT_TRUE((pending_extension_info =
+ service()->pending_extension_manager()->GetById(kGoodId)));
EXPECT_TRUE(pending_extension_info->is_from_sync());
// Add a crx to be updated, with the same ID, from a non-sync source.
- EXPECT_TRUE(service_->pending_extension_manager()->AddFromExternalUpdateUrl(
- kGoodId, GURL(kGoodUpdateURL), Manifest::EXTERNAL_PREF_DOWNLOAD,
- Extension::NO_FLAGS, false));
+ EXPECT_TRUE(service()->pending_extension_manager()->AddFromExternalUpdateUrl(
+ kGoodId,
+ std::string(),
+ GURL(kGoodUpdateURL),
+ Manifest::EXTERNAL_PREF_DOWNLOAD,
+ Extension::NO_FLAGS,
+ false));
// Check that there is a pending crx, with is_from_sync set to false.
- ASSERT_TRUE((pending_extension_info = service_->pending_extension_manager()->
- GetById(kGoodId)));
+ ASSERT_TRUE((pending_extension_info =
+ service()->pending_extension_manager()->GetById(kGoodId)));
EXPECT_FALSE(pending_extension_info->is_from_sync());
EXPECT_EQ(Manifest::EXTERNAL_PREF_DOWNLOAD,
pending_extension_info->install_source());
// Add a crx to be installed from the update mechanism.
- EXPECT_FALSE(service_->pending_extension_manager()->AddFromSync(
- kGoodId, GURL(kGoodUpdateURL), &IsExtension,
- kGoodInstallSilently));
+ EXPECT_FALSE(
+ service()->pending_extension_manager()->AddFromSync(
+ kGoodId,
+ GURL(kGoodUpdateURL),
+ &IsExtension,
+ kGoodInstallSilently,
+ kGoodRemoteInstall,
+ kGoodInstalledByCustodian));
// Check that the external, non-sync update was not overridden.
- ASSERT_TRUE((pending_extension_info = service_->pending_extension_manager()->
- GetById(kGoodId)));
+ ASSERT_TRUE((pending_extension_info =
+ service()->pending_extension_manager()->GetById(kGoodId)));
EXPECT_FALSE(pending_extension_info->is_from_sync());
EXPECT_EQ(Manifest::EXTERNAL_PREF_DOWNLOAD,
pending_extension_info->install_source());
// the CRX is not a theme.
TEST_F(ExtensionServiceTest, UpdatePendingCrxThemeMismatch) {
InitializeEmptyExtensionService();
- EXPECT_TRUE(service_->pending_extension_manager()->AddFromSync(
- theme_crx, GURL(), &IsExtension, true));
+ EXPECT_TRUE(service()->pending_extension_manager()->AddFromSync(
+ theme_crx, GURL(), &IsExtension, true, false, false));
- EXPECT_TRUE(service_->pending_extension_manager()->IsIdPending(theme_crx));
+ EXPECT_TRUE(service()->pending_extension_manager()->IsIdPending(theme_crx));
- base::FilePath path = data_dir_.AppendASCII("theme.crx");
+ base::FilePath path = data_dir().AppendASCII("theme.crx");
UpdateExtension(theme_crx, path, FAILED_SILENTLY);
- EXPECT_FALSE(service_->pending_extension_manager()->IsIdPending(theme_crx));
+ EXPECT_FALSE(service()->pending_extension_manager()->IsIdPending(theme_crx));
- const Extension* extension = service_->GetExtensionById(theme_crx, true);
+ const Extension* extension = service()->GetExtensionById(theme_crx, true);
ASSERT_FALSE(extension);
}
TEST_F(ExtensionServiceTest, UpdatePendingExtensionFailedShouldInstallTest) {
InitializeEmptyExtensionService();
// Add pending extension with a flipped is_theme.
- EXPECT_TRUE(service_->pending_extension_manager()->AddFromSync(
- kGoodId, GURL(kGoodUpdateURL), &IsTheme, kGoodInstallSilently));
- EXPECT_TRUE(service_->pending_extension_manager()->IsIdPending(kGoodId));
-
- base::FilePath path = data_dir_.AppendASCII("good.crx");
+ EXPECT_TRUE(
+ service()->pending_extension_manager()->AddFromSync(
+ kGoodId,
+ GURL(kGoodUpdateURL),
+ &IsTheme,
+ kGoodInstallSilently,
+ kGoodRemoteInstall,
+ kGoodInstalledByCustodian));
+ EXPECT_TRUE(service()->pending_extension_manager()->IsIdPending(kGoodId));
+
+ base::FilePath path = data_dir().AppendASCII("good.crx");
UpdateExtension(kGoodId, path, UPDATED);
// TODO(akalin): Figure out how to check that the extensions
// directory is cleaned up properly in OnExtensionInstalled().
- EXPECT_FALSE(service_->pending_extension_manager()->IsIdPending(kGoodId));
+ EXPECT_FALSE(service()->pending_extension_manager()->IsIdPending(kGoodId));
}
// TODO(akalin): Figure out how to test that installs of pending
TEST_F(ExtensionServiceTest, UpdatePendingExtensionNotPending) {
InitializeEmptyExtensionService();
- base::FilePath path = data_dir_.AppendASCII("good.crx");
+ base::FilePath path = data_dir().AppendASCII("good.crx");
UpdateExtension(kGoodId, path, UPDATED);
- EXPECT_FALSE(service_->pending_extension_manager()->IsIdPending(kGoodId));
+ EXPECT_FALSE(service()->pending_extension_manager()->IsIdPending(kGoodId));
}
// Test updating a pending extension for one that is already
TEST_F(ExtensionServiceTest, UpdatePendingExtensionAlreadyInstalled) {
InitializeEmptyExtensionService();
- base::FilePath path = data_dir_.AppendASCII("good.crx");
+ base::FilePath path = data_dir().AppendASCII("good.crx");
const Extension* good = InstallCRX(path, INSTALL_NEW);
- ASSERT_EQ(1u, registry_->enabled_extensions().size());
+ ASSERT_EQ(1u, registry()->enabled_extensions().size());
EXPECT_FALSE(good->is_theme());
// Use AddExtensionImpl() as AddFrom*() would balk.
- service_->pending_extension_manager()->AddExtensionImpl(
- good->id(), extensions::ManifestURL::GetUpdateURL(good),
- Version(), &IsExtension, kGoodIsFromSync,
- kGoodInstallSilently, Manifest::INTERNAL,
- Extension::NO_FLAGS, false);
+ service()->pending_extension_manager()->AddExtensionImpl(
+ good->id(),
+ std::string(),
+ extensions::ManifestURL::GetUpdateURL(good),
+ Version(),
+ &IsExtension,
+ kGoodIsFromSync,
+ kGoodInstallSilently,
+ Manifest::INTERNAL,
+ Extension::NO_FLAGS,
+ false,
+ kGoodRemoteInstall);
UpdateExtension(good->id(), path, ENABLED);
- EXPECT_FALSE(service_->pending_extension_manager()->IsIdPending(kGoodId));
+ EXPECT_FALSE(service()->pending_extension_manager()->IsIdPending(kGoodId));
}
#if defined(ENABLE_BLACKLIST_TESTS)
extensions::TestBlacklist test_blacklist;
// A profile with 3 extensions installed: good0, good1, and good2.
InitializeGoodInstalledExtensionService();
- test_blacklist.Attach(service_->blacklist_);
- service_->Init();
+ test_blacklist.Attach(service()->blacklist_);
+ service()->Init();
const extensions::ExtensionSet& enabled_extensions =
- registry_->enabled_extensions();
+ registry()->enabled_extensions();
const extensions::ExtensionSet& blacklisted_extensions =
- registry_->blacklisted_extensions();
+ registry()->blacklisted_extensions();
EXPECT_TRUE(enabled_extensions.Contains(good0) &&
!blacklisted_extensions.Contains(good0));
Blacklist::ScopedDatabaseManagerForTest scoped_blacklist_db(blacklist_db);
InitializeEmptyExtensionService();
- service_->Init();
+ service()->Init();
// After blacklisting good_crx, we cannot install it.
blacklist_db->SetUnsafe(good_crx).NotifyUpdate();
base::RunLoop().RunUntilIdle();
- base::FilePath path = data_dir_.AppendASCII("good.crx");
+ base::FilePath path = data_dir().AppendASCII("good.crx");
// HACK: specify WAS_INSTALLED_BY_DEFAULT so that test machinery doesn't
// decide to install this silently. Somebody should fix these tests, all
// 6,000 lines of them. Hah!
InstallCRX(path, INSTALL_FAILED, Extension::WAS_INSTALLED_BY_DEFAULT);
- EXPECT_EQ(0u, registry_->enabled_extensions().size());
+ EXPECT_EQ(0u, registry()->enabled_extensions().size());
}
#endif // defined(ENABLE_BLACKLIST_TESTS)
// A profile with no extensions installed.
InitializeEmptyExtensionService();
- test_blacklist.Attach(service_->blacklist_);
+ test_blacklist.Attach(service()->blacklist_);
- base::FilePath path = data_dir_.AppendASCII("good.crx");
+ base::FilePath path = data_dir().AppendASCII("good.crx");
const Extension* good = InstallCRX(path, INSTALL_NEW);
EXPECT_EQ(good_crx, good->id());
UpdateExtension(good_crx, path, FAILED_SILENTLY);
- EXPECT_EQ(1u, registry_->enabled_extensions().size());
+ EXPECT_EQ(1u, registry()->enabled_extensions().size());
base::ListValue whitelist;
- PrefService* prefs = service_->extension_prefs()->pref_service();
+ PrefService* prefs = ExtensionPrefs::Get(profile())->pref_service();
whitelist.Append(new base::StringValue(good_crx));
prefs->Set(extensions::pref_names::kInstallAllowList, whitelist);
// The good_crx is blacklisted and the whitelist doesn't negate it.
ASSERT_TRUE(ValidateBooleanPref(good_crx, "blacklist", true));
- EXPECT_EQ(0u, registry_->enabled_extensions().size());
+ EXPECT_EQ(0u, registry()->enabled_extensions().size());
}
#endif // defined(ENABLE_BLACKLIST_TESTS)
// A profile with 3 extensions installed: good0, good1, and good2.
InitializeGoodInstalledExtensionService();
- test_blacklist.Attach(service_->blacklist_);
+ test_blacklist.Attach(service()->blacklist_);
// Blacklist good1 before the service initializes.
test_blacklist.SetBlacklistState(
good1, extensions::BLACKLISTED_MALWARE, false);
// Load extensions.
- service_->Init();
+ service()->Init();
ASSERT_EQ(3u, loaded_.size()); // hasn't had time to blacklist yet
base::RunLoop().RunUntilIdle();
- ASSERT_EQ(1u, registry_->blacklisted_extensions().size());
- ASSERT_EQ(2u, registry_->enabled_extensions().size());
+ 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));
+ 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)
extensions::TestBlacklist test_blacklist;
InitializeGoodInstalledExtensionService();
- test_blacklist.Attach(service_->blacklist_);
- service_->extension_prefs()->SetExtensionBlacklisted(good0, true);
- service_->extension_prefs()->SetExtensionBlacklisted(good1, true);
+ test_blacklist.Attach(service()->blacklist_);
+ ExtensionPrefs::Get(profile())->SetExtensionBlacklisted(good0, true);
+ ExtensionPrefs::Get(profile())->SetExtensionBlacklisted(good1, true);
test_blacklist.SetBlacklistState(
good1, extensions::BLACKLISTED_MALWARE, false);
- service_->Init();
+ // Extension service hasn't loaded yet, but IsExtensionEnabled reads out of
+ // prefs. Ensure it takes into account the blacklist state (crbug.com/373842).
+ EXPECT_FALSE(service()->IsExtensionEnabled(good0));
+ EXPECT_FALSE(service()->IsExtensionEnabled(good1));
+ EXPECT_TRUE(service()->IsExtensionEnabled(good2));
+
+ service()->Init();
- ASSERT_EQ(2u, registry_->blacklisted_extensions().size());
- ASSERT_EQ(1u, registry_->enabled_extensions().size());
+ EXPECT_EQ(2u, registry()->blacklisted_extensions().size());
+ EXPECT_EQ(1u, registry()->enabled_extensions().size());
- ASSERT_TRUE(registry_->blacklisted_extensions().Contains(good0));
- ASSERT_TRUE(registry_->blacklisted_extensions().Contains(good1));
- ASSERT_TRUE(registry_->enabled_extensions().Contains(good2));
+ EXPECT_TRUE(registry()->blacklisted_extensions().Contains(good0));
+ EXPECT_TRUE(registry()->blacklisted_extensions().Contains(good1));
+ EXPECT_TRUE(registry()->enabled_extensions().Contains(good2));
// Give time for the blacklist to update.
base::RunLoop().RunUntilIdle();
- ASSERT_EQ(1u, registry_->blacklisted_extensions().size());
- ASSERT_EQ(2u, registry_->enabled_extensions().size());
+ EXPECT_EQ(1u, registry()->blacklisted_extensions().size());
+ EXPECT_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));
+ EXPECT_TRUE(registry()->enabled_extensions().Contains(good0));
+ EXPECT_TRUE(registry()->blacklisted_extensions().Contains(good1));
+ EXPECT_TRUE(registry()->enabled_extensions().Contains(good2));
}
#endif // defined(ENABLE_BLACKLIST_TESTS)
extensions::TestBlacklist test_blacklist;
// A profile with 3 extensions installed: good0, good1, and good2.
InitializeGoodInstalledExtensionService();
- test_blacklist.Attach(service_->blacklist_);
- service_->Init();
+ test_blacklist.Attach(service()->blacklist_);
+ service()->Init();
const extensions::ExtensionSet& enabled_extensions =
- registry_->enabled_extensions();
+ registry()->enabled_extensions();
const extensions::ExtensionSet& disabled_extensions =
- registry_->disabled_extensions();
+ registry()->disabled_extensions();
EXPECT_TRUE(enabled_extensions.Contains(good0));
EXPECT_TRUE(enabled_extensions.Contains(good1));
good1, "blacklist_state", extensions::BLACKLISTED_POTENTIALLY_UNWANTED);
// Now user enables good0.
- service_->EnableExtension(good0);
+ service()->EnableExtension(good0);
EXPECT_TRUE(enabled_extensions.Contains(good0));
EXPECT_FALSE(disabled_extensions.Contains(good0));
extensions::TestBlacklist test_blacklist;
// A profile with 3 extensions installed: good0, good1, and good2.
InitializeGoodInstalledExtensionService();
- test_blacklist.Attach(service_->blacklist_);
- service_->Init();
+ test_blacklist.Attach(service()->blacklist_);
+ service()->Init();
const extensions::ExtensionSet& enabled_extensions =
- registry_->enabled_extensions();
+ registry()->enabled_extensions();
const extensions::ExtensionSet& disabled_extensions =
- registry_->disabled_extensions();
+ registry()->disabled_extensions();
// Manually disable.
- service_->DisableExtension(good0, extensions::Extension::DISABLE_USER_ACTION);
+ service()->DisableExtension(good0,
+ extensions::Extension::DISABLE_USER_ACTION);
test_blacklist.SetBlacklistState(
good0, extensions::BLACKLISTED_CWS_POLICY_VIOLATION, true);
EXPECT_TRUE(disabled_extensions.Contains(good2));
// Greylisted extension can be enabled.
- service_->EnableExtension(good1);
+ service()->EnableExtension(good1);
EXPECT_TRUE(enabled_extensions.Contains(good1));
EXPECT_FALSE(disabled_extensions.Contains(good1));
// good1 is now manually disabled.
- service_->DisableExtension(good1, extensions::Extension::DISABLE_USER_ACTION);
+ service()->DisableExtension(good1,
+ extensions::Extension::DISABLE_USER_ACTION);
EXPECT_FALSE(enabled_extensions.Contains(good1));
EXPECT_TRUE(disabled_extensions.Contains(good1));
extensions::TestBlacklist test_blacklist;
// A profile with 3 extensions installed: good0, good1, and good2.
InitializeGoodInstalledExtensionService();
- test_blacklist.Attach(service_->blacklist_);
- service_->Init();
+ test_blacklist.Attach(service()->blacklist_);
+ service()->Init();
const extensions::ExtensionSet& enabled_extensions =
- registry_->enabled_extensions();
+ registry()->enabled_extensions();
const extensions::ExtensionSet& disabled_extensions =
- registry_->disabled_extensions();
+ registry()->disabled_extensions();
test_blacklist.SetBlacklistState(
good0, extensions::BLACKLISTED_CWS_POLICY_VIOLATION, true);
EXPECT_TRUE(enabled_extensions.Contains(good2));
EXPECT_FALSE(disabled_extensions.Contains(good2));
}
+
+// Tests that blacklisted extensions cannot be reloaded, both those loaded
+// before and after extension service startup.
+TEST_F(ExtensionServiceTest, ReloadBlacklistedExtension) {
+ extensions::TestBlacklist test_blacklist;
+
+ InitializeGoodInstalledExtensionService();
+ test_blacklist.Attach(service()->blacklist_);
+
+ test_blacklist.SetBlacklistState(
+ good1, extensions::BLACKLISTED_MALWARE, false);
+ service()->Init();
+ test_blacklist.SetBlacklistState(
+ good2, extensions::BLACKLISTED_MALWARE, false);
+ base::RunLoop().RunUntilIdle();
+
+ EXPECT_EQ(StringSet(good0), registry()->enabled_extensions().GetIDs());
+ EXPECT_EQ(StringSet(good1, good2),
+ registry()->blacklisted_extensions().GetIDs());
+
+ service()->ReloadExtension(good1);
+ service()->ReloadExtension(good2);
+ base::RunLoop().RunUntilIdle();
+
+ EXPECT_EQ(StringSet(good0), registry()->enabled_extensions().GetIDs());
+ EXPECT_EQ(StringSet(good1, good2),
+ registry()->blacklisted_extensions().GetIDs());
+}
+
#endif // defined(ENABLE_BLACKLIST_TESTS)
// Will not install extension blacklisted by policy.
// Blacklist everything.
{
- ListPrefUpdate update(profile_->GetPrefs(),
+ ListPrefUpdate update(profile()->GetPrefs(),
extensions::pref_names::kInstallDenyList);
base::ListValue* blacklist = update.Get();
blacklist->Append(new base::StringValue("*"));
}
// Blacklist prevents us from installing good_crx.
- base::FilePath path = data_dir_.AppendASCII("good.crx");
+ base::FilePath path = data_dir().AppendASCII("good.crx");
InstallCRX(path, INSTALL_FAILED);
- EXPECT_EQ(0u, registry_->enabled_extensions().size());
+ EXPECT_EQ(0u, registry()->enabled_extensions().size());
// Now whitelist this particular extension.
{
- ListPrefUpdate update(profile_->GetPrefs(),
+ ListPrefUpdate update(profile()->GetPrefs(),
extensions::pref_names::kInstallAllowList);
base::ListValue* whitelist = update.Get();
whitelist->Append(new base::StringValue(good_crx));
// Ensure we can now install good_crx.
InstallCRX(path, INSTALL_NEW);
- EXPECT_EQ(1u, registry_->enabled_extensions().size());
+ EXPECT_EQ(1u, registry()->enabled_extensions().size());
}
// Extension blacklisted by policy get unloaded after installing.
InitializeEmptyExtensionService();
// Install good_crx.
- base::FilePath path = data_dir_.AppendASCII("good.crx");
+ base::FilePath path = data_dir().AppendASCII("good.crx");
InstallCRX(path, INSTALL_NEW);
- EXPECT_EQ(1u, registry_->enabled_extensions().size());
+ EXPECT_EQ(1u, registry()->enabled_extensions().size());
{ // Scope for pref update notification.
- PrefService* prefs = profile_->GetPrefs();
+ PrefService* prefs = profile()->GetPrefs();
ListPrefUpdate update(prefs, extensions::pref_names::kInstallDenyList);
base::ListValue* blacklist = update.Get();
ASSERT_TRUE(blacklist != NULL);
// Extension should not be running now.
base::RunLoop().RunUntilIdle();
- EXPECT_EQ(0u, registry_->enabled_extensions().size());
+ EXPECT_EQ(0u, registry()->enabled_extensions().size());
}
// Tests that component extensions are not blacklisted by policy.
// Blacklist everything.
{
- ListPrefUpdate update(profile_->GetPrefs(),
+ ListPrefUpdate update(profile()->GetPrefs(),
extensions::pref_names::kInstallDenyList);
base::ListValue* blacklist = update.Get();
blacklist->Append(new base::StringValue("*"));
}
// Install a component extension.
- base::FilePath path = data_dir_
- .AppendASCII("good")
- .AppendASCII("Extensions")
- .AppendASCII(good0)
- .AppendASCII("1.0.0.0");
+ base::FilePath path = data_dir()
+ .AppendASCII("good")
+ .AppendASCII("Extensions")
+ .AppendASCII(good0)
+ .AppendASCII("1.0.0.0");
std::string manifest;
ASSERT_TRUE(base::ReadFileToString(
path.Append(extensions::kManifestFilename), &manifest));
- service_->component_loader()->Add(manifest, path);
- service_->Init();
+ service()->component_loader()->Add(manifest, path);
+ service()->Init();
// Extension should be installed despite blacklist.
- ASSERT_EQ(1u, registry_->enabled_extensions().size());
- EXPECT_TRUE(service_->GetExtensionById(good0, false));
+ ASSERT_EQ(1u, registry()->enabled_extensions().size());
+ EXPECT_TRUE(service()->GetExtensionById(good0, false));
// Poke external providers and make sure the extension is still present.
- service_->CheckForExternalUpdates();
- ASSERT_EQ(1u, registry_->enabled_extensions().size());
- EXPECT_TRUE(service_->GetExtensionById(good0, false));
+ service()->CheckForExternalUpdates();
+ ASSERT_EQ(1u, registry()->enabled_extensions().size());
+ EXPECT_TRUE(service()->GetExtensionById(good0, false));
// Extension should not be uninstalled on blacklist changes.
{
- ListPrefUpdate update(profile_->GetPrefs(),
+ ListPrefUpdate update(profile()->GetPrefs(),
extensions::pref_names::kInstallDenyList);
base::ListValue* blacklist = update.Get();
blacklist->Append(new base::StringValue(good0));
}
base::RunLoop().RunUntilIdle();
- ASSERT_EQ(1u, registry_->enabled_extensions().size());
- EXPECT_TRUE(service_->GetExtensionById(good0, false));
+ ASSERT_EQ(1u, registry()->enabled_extensions().size());
+ EXPECT_TRUE(service()->GetExtensionById(good0, false));
}
// Tests that policy-installed extensions are not blacklisted by policy.
{
// Blacklist everything.
- ListPrefUpdate blacklist_update(
- profile_->GetPrefs(), extensions::pref_names::kInstallDenyList);
+ ListPrefUpdate blacklist_update(profile()->GetPrefs(),
+ extensions::pref_names::kInstallDenyList);
base::ListValue* blacklist = blacklist_update.Get();
blacklist->AppendString("*");
// Mark good.crx for force-installation.
DictionaryPrefUpdate forcelist_update(
- profile_->GetPrefs(),
- extensions::pref_names::kInstallForceList);
+ profile()->GetPrefs(), extensions::pref_names::kInstallForceList);
extensions::ExternalPolicyLoader::AddExtension(
forcelist_update.Get(), good_crx, "http://example.com/update_url");
}
// Have policy force-install an extension.
MockExtensionProvider* provider =
- new MockExtensionProvider(service_,
- Manifest::EXTERNAL_POLICY_DOWNLOAD);
+ new MockExtensionProvider(service(), Manifest::EXTERNAL_POLICY_DOWNLOAD);
AddMockExternalProvider(provider);
- provider->UpdateOrAddExtension(good_crx, "1.0.0.0",
- data_dir_.AppendASCII("good.crx"));
+ provider->UpdateOrAddExtension(
+ good_crx, "1.0.0.0", data_dir().AppendASCII("good.crx"));
// Reloading extensions should find our externally registered extension
// and install it.
content::WindowedNotificationObserver observer(
- chrome::NOTIFICATION_CRX_INSTALLER_DONE,
+ extensions::NOTIFICATION_CRX_INSTALLER_DONE,
content::NotificationService::AllSources());
- service_->CheckForExternalUpdates();
+ service()->CheckForExternalUpdates();
observer.Wait();
// Extension should be installed despite blacklist.
- ASSERT_EQ(1u, registry_->enabled_extensions().size());
- EXPECT_TRUE(service_->GetExtensionById(good_crx, false));
+ ASSERT_EQ(1u, registry()->enabled_extensions().size());
+ EXPECT_TRUE(service()->GetExtensionById(good_crx, false));
// Blacklist update should not uninstall the extension.
{
- ListPrefUpdate update(profile_->GetPrefs(),
+ ListPrefUpdate update(profile()->GetPrefs(),
extensions::pref_names::kInstallDenyList);
base::ListValue* blacklist = update.Get();
blacklist->Append(new base::StringValue(good0));
}
base::RunLoop().RunUntilIdle();
- ASSERT_EQ(1u, registry_->enabled_extensions().size());
- EXPECT_TRUE(service_->GetExtensionById(good_crx, false));
+ ASSERT_EQ(1u, registry()->enabled_extensions().size());
+ EXPECT_TRUE(service()->GetExtensionById(good_crx, false));
}
// Tests that extensions cannot be installed if the policy provider prohibits
TEST_F(ExtensionServiceTest, ManagementPolicyProhibitsInstall) {
InitializeEmptyExtensionService();
- management_policy_->UnregisterAllProviders();
+ GetManagementPolicy()->UnregisterAllProviders();
extensions::TestManagementPolicyProvider provider_(
extensions::TestManagementPolicyProvider::PROHIBIT_LOAD);
- management_policy_->RegisterProvider(&provider_);
+ GetManagementPolicy()->RegisterProvider(&provider_);
- InstallCRX(data_dir_.AppendASCII("good.crx"), INSTALL_FAILED);
- EXPECT_EQ(0u, registry_->enabled_extensions().size());
+ InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_FAILED);
+ EXPECT_EQ(0u, registry()->enabled_extensions().size());
}
// Tests that extensions cannot be loaded from prefs if the policy provider
InitializeEmptyExtensionService();
// Create a fake extension to be loaded as though it were read from prefs.
- base::FilePath path = data_dir_.AppendASCII("management")
- .AppendASCII("simple_extension");
+ base::FilePath path =
+ data_dir().AppendASCII("management").AppendASCII("simple_extension");
base::DictionaryValue manifest;
manifest.SetString(keys::kName, "simple_extension");
manifest.SetString(keys::kVersion, "1");
&manifest, std::string(), path, Manifest::UNPACKED);
// Ensure we can load it with no management policy in place.
- management_policy_->UnregisterAllProviders();
- EXPECT_EQ(0u, registry_->enabled_extensions().size());
- extensions::InstalledLoader(service_).Load(extension_info, false);
- EXPECT_EQ(1u, registry_->enabled_extensions().size());
+ GetManagementPolicy()->UnregisterAllProviders();
+ EXPECT_EQ(0u, registry()->enabled_extensions().size());
+ extensions::InstalledLoader(service()).Load(extension_info, false);
+ EXPECT_EQ(1u, registry()->enabled_extensions().size());
- const Extension* extension = (registry_->enabled_extensions().begin())->get();
- EXPECT_TRUE(service_->UninstallExtension(extension->id(), false, NULL));
- EXPECT_EQ(0u, registry_->enabled_extensions().size());
+ const Extension* extension =
+ (registry()->enabled_extensions().begin())->get();
+ EXPECT_TRUE(
+ service()->UninstallExtension(extension->id(),
+ extensions::UNINSTALL_REASON_FOR_TESTING,
+ base::Bind(&base::DoNothing),
+ NULL));
+ EXPECT_EQ(0u, registry()->enabled_extensions().size());
// Ensure we cannot load it if management policy prohibits installation.
extensions::TestManagementPolicyProvider provider_(
extensions::TestManagementPolicyProvider::PROHIBIT_LOAD);
- management_policy_->RegisterProvider(&provider_);
+ GetManagementPolicy()->RegisterProvider(&provider_);
- extensions::InstalledLoader(service_).Load(extension_info, false);
- EXPECT_EQ(0u, registry_->enabled_extensions().size());
+ extensions::InstalledLoader(service()).Load(extension_info, false);
+ EXPECT_EQ(0u, registry()->enabled_extensions().size());
}
// Tests disabling an extension when prohibited by the ManagementPolicy.
TEST_F(ExtensionServiceTest, ManagementPolicyProhibitsDisable) {
InitializeEmptyExtensionService();
- InstallCRX(data_dir_.AppendASCII("good.crx"), INSTALL_NEW);
- EXPECT_EQ(1u, registry_->enabled_extensions().size());
- EXPECT_EQ(0u, registry_->disabled_extensions().size());
+ InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
+ EXPECT_EQ(1u, registry()->enabled_extensions().size());
+ EXPECT_EQ(0u, registry()->disabled_extensions().size());
- management_policy_->UnregisterAllProviders();
+ GetManagementPolicy()->UnregisterAllProviders();
extensions::TestManagementPolicyProvider provider(
extensions::TestManagementPolicyProvider::PROHIBIT_MODIFY_STATUS);
- management_policy_->RegisterProvider(&provider);
+ GetManagementPolicy()->RegisterProvider(&provider);
// Attempt to disable it.
- service_->DisableExtension(good_crx, Extension::DISABLE_USER_ACTION);
+ service()->DisableExtension(good_crx, Extension::DISABLE_USER_ACTION);
- EXPECT_EQ(1u, registry_->enabled_extensions().size());
- EXPECT_TRUE(service_->GetExtensionById(good_crx, false));
- EXPECT_EQ(0u, registry_->disabled_extensions().size());
+ EXPECT_EQ(1u, registry()->enabled_extensions().size());
+ EXPECT_TRUE(service()->GetExtensionById(good_crx, false));
+ EXPECT_EQ(0u, registry()->disabled_extensions().size());
}
// Tests uninstalling an extension when prohibited by the ManagementPolicy.
TEST_F(ExtensionServiceTest, ManagementPolicyProhibitsUninstall) {
InitializeEmptyExtensionService();
- InstallCRX(data_dir_.AppendASCII("good.crx"), INSTALL_NEW);
- EXPECT_EQ(1u, registry_->enabled_extensions().size());
- EXPECT_EQ(0u, registry_->disabled_extensions().size());
+ InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
+ EXPECT_EQ(1u, registry()->enabled_extensions().size());
+ EXPECT_EQ(0u, registry()->disabled_extensions().size());
- management_policy_->UnregisterAllProviders();
+ GetManagementPolicy()->UnregisterAllProviders();
extensions::TestManagementPolicyProvider provider(
extensions::TestManagementPolicyProvider::PROHIBIT_MODIFY_STATUS);
- management_policy_->RegisterProvider(&provider);
+ GetManagementPolicy()->RegisterProvider(&provider);
// Attempt to uninstall it.
- EXPECT_FALSE(service_->UninstallExtension(good_crx, false, NULL));
+ EXPECT_FALSE(
+ service()->UninstallExtension(good_crx,
+ extensions::UNINSTALL_REASON_FOR_TESTING,
+ base::Bind(&base::DoNothing),
+ NULL));
- EXPECT_EQ(1u, registry_->enabled_extensions().size());
- EXPECT_TRUE(service_->GetExtensionById(good_crx, false));
+ EXPECT_EQ(1u, registry()->enabled_extensions().size());
+ EXPECT_TRUE(service()->GetExtensionById(good_crx, false));
}
// Tests that previously installed extensions that are now prohibited from
TEST_F(ExtensionServiceTest, ManagementPolicyUnloadsAllProhibited) {
InitializeEmptyExtensionService();
- InstallCRX(data_dir_.AppendASCII("good.crx"), INSTALL_NEW);
- InstallCRX(data_dir_.AppendASCII("page_action.crx"), INSTALL_NEW);
- EXPECT_EQ(2u, registry_->enabled_extensions().size());
- EXPECT_EQ(0u, registry_->disabled_extensions().size());
+ InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
+ InstallCRX(data_dir().AppendASCII("page_action.crx"), INSTALL_NEW);
+ EXPECT_EQ(2u, registry()->enabled_extensions().size());
+ EXPECT_EQ(0u, registry()->disabled_extensions().size());
- management_policy_->UnregisterAllProviders();
+ GetManagementPolicy()->UnregisterAllProviders();
extensions::TestManagementPolicyProvider provider(
extensions::TestManagementPolicyProvider::PROHIBIT_LOAD);
- management_policy_->RegisterProvider(&provider);
+ GetManagementPolicy()->RegisterProvider(&provider);
// Run the policy check.
- service_->CheckManagementPolicy();
- EXPECT_EQ(0u, registry_->enabled_extensions().size());
- EXPECT_EQ(0u, registry_->disabled_extensions().size());
+ service()->CheckManagementPolicy();
+ EXPECT_EQ(0u, registry()->enabled_extensions().size());
+ EXPECT_EQ(0u, registry()->disabled_extensions().size());
}
// Tests that previously disabled extensions that are now required to be
InitializeEmptyExtensionService();
// Install, then disable, an extension.
- InstallCRX(data_dir_.AppendASCII("good.crx"), INSTALL_NEW);
- EXPECT_EQ(1u, registry_->enabled_extensions().size());
- service_->DisableExtension(good_crx, Extension::DISABLE_USER_ACTION);
- EXPECT_EQ(1u, registry_->disabled_extensions().size());
+ InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
+ EXPECT_EQ(1u, registry()->enabled_extensions().size());
+ service()->DisableExtension(good_crx, Extension::DISABLE_USER_ACTION);
+ EXPECT_EQ(1u, registry()->disabled_extensions().size());
// Register an ExtensionMnagementPolicy that requires the extension to remain
// enabled.
- management_policy_->UnregisterAllProviders();
+ GetManagementPolicy()->UnregisterAllProviders();
extensions::TestManagementPolicyProvider provider(
extensions::TestManagementPolicyProvider::MUST_REMAIN_ENABLED);
- management_policy_->RegisterProvider(&provider);
+ GetManagementPolicy()->RegisterProvider(&provider);
// Reinstall the extension.
- InstallCRX(data_dir_.AppendASCII("good.crx"), INSTALL_UPDATED);
- EXPECT_EQ(1u, registry_->enabled_extensions().size());
- EXPECT_EQ(0u, registry_->disabled_extensions().size());
+ InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_UPDATED);
+ EXPECT_EQ(1u, registry()->enabled_extensions().size());
+ EXPECT_EQ(0u, registry()->disabled_extensions().size());
}
// Flaky on windows; http://crbug.com/309833
#endif
TEST_F(ExtensionServiceTest, MAYBE_ExternalExtensionAutoAcknowledgement) {
InitializeEmptyExtensionService();
- set_extensions_enabled(true);
+ service()->set_extensions_enabled(true);
{
// Register and install an external extension.
MockExtensionProvider* provider =
- new MockExtensionProvider(service_, Manifest::EXTERNAL_PREF);
+ new MockExtensionProvider(service(), Manifest::EXTERNAL_PREF);
AddMockExternalProvider(provider);
- provider->UpdateOrAddExtension(good_crx, "1.0.0.0",
- data_dir_.AppendASCII("good.crx"));
+ provider->UpdateOrAddExtension(
+ good_crx, "1.0.0.0", data_dir().AppendASCII("good.crx"));
}
{
// Have policy force-install an extension.
- MockExtensionProvider* provider =
- new MockExtensionProvider(service_,
- Manifest::EXTERNAL_POLICY_DOWNLOAD);
+ MockExtensionProvider* provider = new MockExtensionProvider(
+ service(), Manifest::EXTERNAL_POLICY_DOWNLOAD);
AddMockExternalProvider(provider);
- provider->UpdateOrAddExtension(page_action, "1.0.0.0",
- data_dir_.AppendASCII("page_action.crx"));
+ provider->UpdateOrAddExtension(
+ page_action, "1.0.0.0", data_dir().AppendASCII("page_action.crx"));
}
// Providers are set up. Let them run.
int count = 2;
content::WindowedNotificationObserver observer(
- chrome::NOTIFICATION_CRX_INSTALLER_DONE,
+ extensions::NOTIFICATION_CRX_INSTALLER_DONE,
base::Bind(&WaitForCountNotificationsCallback, &count));
- service_->CheckForExternalUpdates();
+ service()->CheckForExternalUpdates();
observer.Wait();
- ASSERT_EQ(2u, registry_->enabled_extensions().size());
- EXPECT_TRUE(service_->GetExtensionById(good_crx, false));
- EXPECT_TRUE(service_->GetExtensionById(page_action, false));
- ExtensionPrefs* prefs = service_->extension_prefs();
+ ASSERT_EQ(2u, registry()->enabled_extensions().size());
+ EXPECT_TRUE(service()->GetExtensionById(good_crx, false));
+ EXPECT_TRUE(service()->GetExtensionById(page_action, false));
+ ExtensionPrefs* prefs = ExtensionPrefs::Get(profile());
ASSERT_TRUE(!prefs->IsExternalExtensionAcknowledged(good_crx));
ASSERT_TRUE(prefs->IsExternalExtensionAcknowledged(page_action));
}
// This tests if default apps are installed correctly.
TEST_F(ExtensionServiceTest, DefaultAppsInstall) {
InitializeEmptyExtensionService();
- set_extensions_enabled(true);
+ service()->set_extensions_enabled(true);
{
std::string json_data =
" \"is_bookmark_app\": false"
" }"
"}";
- default_apps::Provider* provider =
- new default_apps::Provider(
- profile_.get(),
- service_,
- new extensions::ExternalTestingLoader(json_data, data_dir_),
- Manifest::INTERNAL,
- Manifest::INVALID_LOCATION,
- Extension::FROM_WEBSTORE | Extension::WAS_INSTALLED_BY_DEFAULT);
+ default_apps::Provider* provider = new default_apps::Provider(
+ profile(),
+ service(),
+ new extensions::ExternalTestingLoader(json_data, data_dir()),
+ Manifest::INTERNAL,
+ Manifest::INVALID_LOCATION,
+ Extension::FROM_WEBSTORE | Extension::WAS_INSTALLED_BY_DEFAULT);
AddMockExternalProvider(provider);
}
- ASSERT_EQ(0u, registry_->enabled_extensions().size());
+ ASSERT_EQ(0u, registry()->enabled_extensions().size());
content::WindowedNotificationObserver observer(
- chrome::NOTIFICATION_CRX_INSTALLER_DONE,
+ extensions::NOTIFICATION_CRX_INSTALLER_DONE,
content::NotificationService::AllSources());
- service_->CheckForExternalUpdates();
+ service()->CheckForExternalUpdates();
observer.Wait();
- ASSERT_EQ(1u, registry_->enabled_extensions().size());
- EXPECT_TRUE(service_->GetExtensionById(good_crx, false));
- const Extension* extension = service_->GetExtensionById(good_crx, false);
+ ASSERT_EQ(1u, registry()->enabled_extensions().size());
+ EXPECT_TRUE(service()->GetExtensionById(good_crx, false));
+ const Extension* extension = service()->GetExtensionById(good_crx, false);
EXPECT_TRUE(extension->from_webstore());
EXPECT_TRUE(extension->was_installed_by_default());
}
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));
+ 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, 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());
+ 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);
+ 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, 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());
+ EXPECT_TRUE(service()->GetExtensionById(good_crx, true));
+ EXPECT_FALSE(service()->GetExtensionById(good_crx, false));
+ 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, 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());
+ InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
+ 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, 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());
+ 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);
+ InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
TerminateExtension(good_crx);
- EXPECT_TRUE(service_->GetTerminatedExtension(good_crx));
+ EXPECT_TRUE(registry()->GetExtensionById(
+ good_crx, extensions::ExtensionRegistry::TERMINATED));
// Disable it.
- service_->DisableExtension(good_crx, Extension::DISABLE_USER_ACTION);
+ service()->DisableExtension(good_crx, Extension::DISABLE_USER_ACTION);
- EXPECT_FALSE(service_->GetTerminatedExtension(good_crx));
- EXPECT_TRUE(service_->GetExtensionById(good_crx, true));
+ EXPECT_FALSE(registry()->GetExtensionById(
+ good_crx, extensions::ExtensionRegistry::TERMINATED));
+ EXPECT_TRUE(service()->GetExtensionById(good_crx, true));
- 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());
+ 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");
+ base::FilePath path = data_dir().AppendASCII("good.crx");
InstallCRX(path, INSTALL_NEW);
- EXPECT_EQ(1u, registry_->enabled_extensions().size());
- EXPECT_EQ(0u, registry_->disabled_extensions().size());
+ EXPECT_EQ(1u, registry()->enabled_extensions().size());
+ EXPECT_EQ(0u, registry()->disabled_extensions().size());
// Disable extensions.
- service_->set_extensions_enabled(false);
- service_->ReloadExtensionsForTest();
+ service()->set_extensions_enabled(false);
+ service()->ReloadExtensionsForTest();
// There shouldn't be extensions in either list.
- EXPECT_EQ(0u, registry_->enabled_extensions().size());
- EXPECT_EQ(0u, registry_->disabled_extensions().size());
+ EXPECT_EQ(0u, registry()->enabled_extensions().size());
+ EXPECT_EQ(0u, registry()->disabled_extensions().size());
// This shouldn't do anything when all extensions are disabled.
- service_->EnableExtension(good_crx);
- service_->ReloadExtensionsForTest();
+ service()->EnableExtension(good_crx);
+ service()->ReloadExtensionsForTest();
// There still shouldn't be extensions in either list.
- EXPECT_EQ(0u, registry_->enabled_extensions().size());
- EXPECT_EQ(0u, registry_->disabled_extensions().size());
+ EXPECT_EQ(0u, registry()->enabled_extensions().size());
+ EXPECT_EQ(0u, registry()->disabled_extensions().size());
// And then re-enable the extensions.
- service_->set_extensions_enabled(true);
- service_->ReloadExtensionsForTest();
+ service()->set_extensions_enabled(true);
+ service()->ReloadExtensionsForTest();
- EXPECT_EQ(1u, registry_->enabled_extensions().size());
- EXPECT_EQ(0u, registry_->disabled_extensions().size());
+ EXPECT_EQ(1u, registry()->enabled_extensions().size());
+ EXPECT_EQ(0u, registry()->disabled_extensions().size());
}
// Tests reloading extensions.
InitializeEmptyExtensionService();
// Simple extension that should install without error.
- base::FilePath path = data_dir_.AppendASCII("good.crx");
+ base::FilePath path = data_dir().AppendASCII("good.crx");
InstallCRX(path, INSTALL_NEW,
Extension::FROM_WEBSTORE | Extension::WAS_INSTALLED_BY_DEFAULT);
const char* extension_id = good_crx;
- service_->DisableExtension(extension_id, Extension::DISABLE_USER_ACTION);
+ service()->DisableExtension(extension_id, Extension::DISABLE_USER_ACTION);
- EXPECT_EQ(0u, registry_->enabled_extensions().size());
- EXPECT_EQ(1u, registry_->disabled_extensions().size());
+ EXPECT_EQ(0u, registry()->enabled_extensions().size());
+ EXPECT_EQ(1u, registry()->disabled_extensions().size());
- service_->ReloadExtensionsForTest();
+ service()->ReloadExtensionsForTest();
// The creation flags should not change when reloading the extension.
- const Extension* extension = service_->GetExtensionById(good_crx, true);
+ const Extension* extension = service()->GetExtensionById(good_crx, true);
EXPECT_TRUE(extension->from_webstore());
EXPECT_TRUE(extension->was_installed_by_default());
EXPECT_FALSE(extension->from_bookmark());
// Extension counts shouldn't change.
- EXPECT_EQ(0u, registry_->enabled_extensions().size());
- EXPECT_EQ(1u, registry_->disabled_extensions().size());
+ EXPECT_EQ(0u, registry()->enabled_extensions().size());
+ EXPECT_EQ(1u, registry()->disabled_extensions().size());
- service_->EnableExtension(extension_id);
+ service()->EnableExtension(extension_id);
- EXPECT_EQ(1u, registry_->enabled_extensions().size());
- EXPECT_EQ(0u, registry_->disabled_extensions().size());
+ EXPECT_EQ(1u, registry()->enabled_extensions().size());
+ EXPECT_EQ(0u, registry()->disabled_extensions().size());
// Need to clear |loaded_| manually before reloading as the
// EnableExtension() call above inserted into it and
// UnloadAllExtensions() doesn't send out notifications.
loaded_.clear();
- service_->ReloadExtensionsForTest();
+ service()->ReloadExtensionsForTest();
// Extension counts shouldn't change.
- EXPECT_EQ(1u, registry_->enabled_extensions().size());
- EXPECT_EQ(0u, registry_->disabled_extensions().size());
+ EXPECT_EQ(1u, registry()->enabled_extensions().size());
+ EXPECT_EQ(0u, registry()->disabled_extensions().size());
}
// Tests reloading an extension.
// Simple extension that should install without error.
const char* extension_id = "behllobkkfkfnphdnhnkndlbkcpglgmj";
- base::FilePath ext = data_dir_
- .AppendASCII("good")
- .AppendASCII("Extensions")
- .AppendASCII(extension_id)
- .AppendASCII("1.0.0.0");
- extensions::UnpackedInstaller::Create(service_)->Load(ext);
+ base::FilePath ext = data_dir()
+ .AppendASCII("good")
+ .AppendASCII("Extensions")
+ .AppendASCII(extension_id)
+ .AppendASCII("1.0.0.0");
+ extensions::UnpackedInstaller::Create(service())->Load(ext);
base::RunLoop().RunUntilIdle();
- EXPECT_EQ(1u, registry_->enabled_extensions().size());
- EXPECT_EQ(0u, registry_->disabled_extensions().size());
+ EXPECT_EQ(1u, registry()->enabled_extensions().size());
+ EXPECT_EQ(0u, registry()->disabled_extensions().size());
- service_->ReloadExtension(extension_id);
+ service()->ReloadExtension(extension_id);
// Extension should be disabled now, waiting to be reloaded.
- EXPECT_EQ(0u, registry_->enabled_extensions().size());
- EXPECT_EQ(1u, registry_->disabled_extensions().size());
+ EXPECT_EQ(0u, registry()->enabled_extensions().size());
+ EXPECT_EQ(1u, registry()->disabled_extensions().size());
EXPECT_EQ(Extension::DISABLE_RELOAD,
- service_->extension_prefs()->GetDisableReasons(extension_id));
+ ExtensionPrefs::Get(profile())->GetDisableReasons(extension_id));
// Reloading again should not crash.
- service_->ReloadExtension(extension_id);
+ service()->ReloadExtension(extension_id);
// Finish reloading
base::RunLoop().RunUntilIdle();
// Extension should be enabled again.
- EXPECT_EQ(1u, registry_->enabled_extensions().size());
- EXPECT_EQ(0u, registry_->disabled_extensions().size());
+ EXPECT_EQ(1u, registry()->enabled_extensions().size());
+ EXPECT_EQ(0u, registry()->disabled_extensions().size());
}
TEST_F(ExtensionServiceTest, UninstallExtension) {
InitializeEmptyExtensionService();
- InstallCRX(data_dir_.AppendASCII("good.crx"), INSTALL_NEW);
- EXPECT_EQ(1u, registry_->enabled_extensions().size());
+ InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
+ EXPECT_EQ(1u, registry()->enabled_extensions().size());
UninstallExtension(good_crx, false);
- EXPECT_EQ(0u, registry_->enabled_extensions().size());
+ EXPECT_EQ(0u, registry()->enabled_extensions().size());
+ EXPECT_EQ(UnloadedExtensionInfo::REASON_UNINSTALL, unloaded_reason_);
}
TEST_F(ExtensionServiceTest, UninstallTerminatedExtension) {
InitializeEmptyExtensionService();
- InstallCRX(data_dir_.AppendASCII("good.crx"), INSTALL_NEW);
+ InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
TerminateExtension(good_crx);
UninstallExtension(good_crx, false);
+ EXPECT_EQ(UnloadedExtensionInfo::REASON_TERMINATE, unloaded_reason_);
}
// Tests the uninstaller helper.
TEST_F(ExtensionServiceTest, UninstallExtensionHelper) {
InitializeEmptyExtensionService();
- InstallCRX(data_dir_.AppendASCII("good.crx"), INSTALL_NEW);
+ InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
UninstallExtension(good_crx, true);
+ EXPECT_EQ(UnloadedExtensionInfo::REASON_UNINSTALL, unloaded_reason_);
}
TEST_F(ExtensionServiceTest, UninstallExtensionHelperTerminated) {
InitializeEmptyExtensionService();
- InstallCRX(data_dir_.AppendASCII("good.crx"), INSTALL_NEW);
+ InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
TerminateExtension(good_crx);
UninstallExtension(good_crx, true);
+ EXPECT_EQ(UnloadedExtensionInfo::REASON_TERMINATE, unloaded_reason_);
}
// An extension disabled because of unsupported requirements should re-enabled
InitializeEmptyExtensionService();
BlackListWebGL();
- base::FilePath path = data_dir_.AppendASCII("requirements");
- base::FilePath pem_path = data_dir_.AppendASCII("requirements")
- .AppendASCII("v1_good.pem");
+ base::FilePath path = data_dir().AppendASCII("requirements");
+ base::FilePath pem_path =
+ data_dir().AppendASCII("requirements").AppendASCII("v1_good.pem");
const Extension* extension_v1 = PackAndInstallCRX(path.AppendASCII("v1_good"),
pem_path,
INSTALL_NEW);
std::string id = extension_v1->id();
- EXPECT_TRUE(service_->IsExtensionEnabled(id));
+ EXPECT_TRUE(service()->IsExtensionEnabled(id));
base::FilePath v2_bad_requirements_crx = GetTemporaryFile();
pem_path,
v2_bad_requirements_crx);
UpdateExtension(id, v2_bad_requirements_crx, INSTALLED);
- EXPECT_FALSE(service_->IsExtensionEnabled(id));
+ EXPECT_FALSE(service()->IsExtensionEnabled(id));
base::FilePath v3_good_crx = GetTemporaryFile();
PackCRX(path.AppendASCII("v3_good"), pem_path, v3_good_crx);
UpdateExtension(id, v3_good_crx, ENABLED);
- EXPECT_TRUE(service_->IsExtensionEnabled(id));
+ EXPECT_TRUE(service()->IsExtensionEnabled(id));
}
// Extensions disabled through user action should stay disabled.
InitializeEmptyExtensionService();
BlackListWebGL();
- base::FilePath path = data_dir_.AppendASCII("requirements");
- base::FilePath pem_path = data_dir_.AppendASCII("requirements")
- .AppendASCII("v1_good.pem");
+ base::FilePath path = data_dir().AppendASCII("requirements");
+ base::FilePath pem_path =
+ data_dir().AppendASCII("requirements").AppendASCII("v1_good.pem");
const Extension* extension_v1 = PackAndInstallCRX(path.AppendASCII("v1_good"),
pem_path,
INSTALL_NEW);
std::string id = extension_v1->id();
- service_->DisableExtension(id, Extension::DISABLE_USER_ACTION);
- EXPECT_FALSE(service_->IsExtensionEnabled(id));
+ service()->DisableExtension(id, Extension::DISABLE_USER_ACTION);
+ EXPECT_FALSE(service()->IsExtensionEnabled(id));
base::FilePath v2_bad_requirements_crx = GetTemporaryFile();
pem_path,
v2_bad_requirements_crx);
UpdateExtension(id, v2_bad_requirements_crx, INSTALLED);
- EXPECT_FALSE(service_->IsExtensionEnabled(id));
+ EXPECT_FALSE(service()->IsExtensionEnabled(id));
base::FilePath v3_good_crx = GetTemporaryFile();
PackCRX(path.AppendASCII("v3_good"), pem_path, v3_good_crx);
UpdateExtension(id, v3_good_crx, INSTALLED);
- EXPECT_FALSE(service_->IsExtensionEnabled(id));
+ EXPECT_FALSE(service()->IsExtensionEnabled(id));
}
// The extension should not re-enabled because it was disabled from a
InitializeEmptyExtensionService();
BlackListWebGL();
- base::FilePath path = data_dir_.AppendASCII("requirements");
- base::FilePath pem_path = data_dir_.AppendASCII("requirements")
- .AppendASCII("v1_good.pem");
+ base::FilePath path = data_dir().AppendASCII("requirements");
+ base::FilePath pem_path =
+ data_dir().AppendASCII("requirements").AppendASCII("v1_good.pem");
const Extension* extension_v1 = PackAndInstallCRX(path.AppendASCII("v1_good"),
pem_path,
INSTALL_NEW);
std::string id = extension_v1->id();
- EXPECT_TRUE(service_->IsExtensionEnabled(id));
+ EXPECT_TRUE(service()->IsExtensionEnabled(id));
base::FilePath v2_bad_requirements_and_permissions_crx = GetTemporaryFile();
pem_path,
v2_bad_requirements_and_permissions_crx);
UpdateExtension(id, v2_bad_requirements_and_permissions_crx, INSTALLED);
- EXPECT_FALSE(service_->IsExtensionEnabled(id));
+ EXPECT_FALSE(service()->IsExtensionEnabled(id));
base::FilePath v3_bad_permissions_crx = GetTemporaryFile();
pem_path,
v3_bad_permissions_crx);
UpdateExtension(id, v3_bad_permissions_crx, INSTALLED);
- EXPECT_FALSE(service_->IsExtensionEnabled(id));
+ EXPECT_FALSE(service()->IsExtensionEnabled(id));
}
// Unpacked extensions are not allowed to be installed if they have unsupported
InitializeEmptyExtensionService();
BlackListWebGL();
- base::FilePath path = data_dir_.AppendASCII("requirements")
- .AppendASCII("v2_bad_requirements");
- extensions::UnpackedInstaller::Create(service_)->Load(path);
+ base::FilePath path =
+ data_dir().AppendASCII("requirements").AppendASCII("v2_bad_requirements");
+ extensions::UnpackedInstaller::Create(service())->Load(path);
base::RunLoop().RunUntilIdle();
EXPECT_EQ(1u, GetErrors().size());
- EXPECT_EQ(0u, registry_->enabled_extensions().size());
+ EXPECT_EQ(0u, registry()->enabled_extensions().size());
}
class ExtensionCookieCallback {
ExtensionCookieCallback callback;
// Load a test extension.
- base::FilePath path = data_dir_;
+ base::FilePath path = data_dir();
path = path.AppendASCII("good.crx");
const Extension* extension = InstallCRX(path, INSTALL_NEW);
ASSERT_TRUE(extension);
std::string origin_id = webkit_database::GetIdentifierFromOrigin(ext_url);
// Set a cookie for the extension.
- net::CookieMonster* cookie_monster =
- profile_->GetRequestContextForExtensions()->GetURLRequestContext()->
- cookie_store()->GetCookieMonster();
+ net::CookieMonster* cookie_monster = profile()
+ ->GetRequestContextForExtensions()
+ ->GetURLRequestContext()
+ ->cookie_store()
+ ->GetCookieMonster();
ASSERT_TRUE(cookie_monster);
net::CookieOptions options;
cookie_monster->SetCookieWithOptionsAsync(
// Open a database.
webkit_database::DatabaseTracker* db_tracker =
- BrowserContext::GetDefaultStoragePartition(profile_.get())->
- GetDatabaseTracker();
+ BrowserContext::GetDefaultStoragePartition(profile())
+ ->GetDatabaseTracker();
base::string16 db_name = base::UTF8ToUTF16("db");
base::string16 description = base::UTF8ToUTF16("db_description");
int64 size;
// Note: This test depends on details of how the dom_storage library
// stores data in the host file system.
base::FilePath lso_dir_path =
- profile_->GetPath().AppendASCII("Local Storage");
+ profile()->GetPath().AppendASCII("Local Storage");
base::FilePath lso_file_path = lso_dir_path.AppendASCII(origin_id)
.AddExtension(FILE_PATH_LITERAL(".localstorage"));
EXPECT_TRUE(base::CreateDirectory(lso_dir_path));
- EXPECT_EQ(0, file_util::WriteFile(lso_file_path, NULL, 0));
+ EXPECT_EQ(0, base::WriteFile(lso_file_path, NULL, 0));
EXPECT_TRUE(base::PathExists(lso_file_path));
// Create indexed db. Similarly, it is enough to only simulate this by
// creating the directory on the disk.
- IndexedDBContext* idb_context =
- BrowserContext::GetDefaultStoragePartition(profile_.get())->
- GetIndexedDBContext();
+ IndexedDBContext* idb_context = BrowserContext::GetDefaultStoragePartition(
+ profile())->GetIndexedDBContext();
idb_context->SetTaskRunnerForTesting(
base::MessageLoop::current()->message_loop_proxy().get());
base::FilePath idb_path = idb_context->GetFilePathForTesting(origin_id);
EXPECT_TRUE(base::DirectoryExists(idb_path));
// Uninstall the extension.
- service_->UninstallExtension(good_crx, false, NULL);
- base::RunLoop().RunUntilIdle();
+ base::RunLoop run_loop;
+ ASSERT_TRUE(
+ service()->UninstallExtension(good_crx,
+ extensions::UNINSTALL_REASON_FOR_TESTING,
+ run_loop.QuitClosure(),
+ NULL));
+ // The data deletion happens on the IO thread.
+ run_loop.Run();
// Check that the cookie is gone.
cookie_monster->GetAllCookiesForURLAsync(
// Install app1 with unlimited storage.
const Extension* extension =
- PackAndInstallCRX(data_dir_.AppendASCII("app1"), INSTALL_NEW);
+ PackAndInstallCRX(data_dir().AppendASCII("app1"), INSTALL_NEW);
ValidatePrefKeyCount(++pref_count);
- ASSERT_EQ(1u, registry_->enabled_extensions().size());
+ ASSERT_EQ(1u, registry()->enabled_extensions().size());
const std::string id1 = extension->id();
- EXPECT_TRUE(extension->HasAPIPermission(
+ EXPECT_TRUE(extension->permissions_data()->HasAPIPermission(
APIPermission::kUnlimitedStorage));
const GURL origin1(
extensions::AppLaunchInfo::GetFullLaunchURL(extension).GetOrigin());
- EXPECT_TRUE(profile_->GetExtensionSpecialStoragePolicy()->
- IsStorageUnlimited(origin1));
+ EXPECT_TRUE(profile()->GetExtensionSpecialStoragePolicy()->IsStorageUnlimited(
+ origin1));
std::string origin_id = webkit_database::GetIdentifierFromOrigin(origin1);
// Install app2 from the same origin with unlimited storage.
- extension = PackAndInstallCRX(data_dir_.AppendASCII("app2"), INSTALL_NEW);
+ extension = PackAndInstallCRX(data_dir().AppendASCII("app2"), INSTALL_NEW);
ValidatePrefKeyCount(++pref_count);
- ASSERT_EQ(2u, registry_->enabled_extensions().size());
+ ASSERT_EQ(2u, registry()->enabled_extensions().size());
const std::string id2 = extension->id();
- EXPECT_TRUE(extension->HasAPIPermission(
+ EXPECT_TRUE(extension->permissions_data()->HasAPIPermission(
APIPermission::kUnlimitedStorage));
EXPECT_TRUE(extension->web_extent().MatchesURL(
extensions::AppLaunchInfo::GetFullLaunchURL(extension)));
const GURL origin2(
extensions::AppLaunchInfo::GetFullLaunchURL(extension).GetOrigin());
EXPECT_EQ(origin1, origin2);
- EXPECT_TRUE(profile_->GetExtensionSpecialStoragePolicy()->
- IsStorageUnlimited(origin2));
+ EXPECT_TRUE(profile()->GetExtensionSpecialStoragePolicy()->IsStorageUnlimited(
+ origin2));
// Set a cookie for the extension.
- net::CookieMonster* cookie_monster =
- profile_->GetRequestContext()->GetURLRequestContext()->
- cookie_store()->GetCookieMonster();
+ net::CookieMonster* cookie_monster = profile()
+ ->GetRequestContext()
+ ->GetURLRequestContext()
+ ->cookie_store()
+ ->GetCookieMonster();
ASSERT_TRUE(cookie_monster);
net::CookieOptions options;
cookie_monster->SetCookieWithOptionsAsync(
// Open a database.
webkit_database::DatabaseTracker* db_tracker =
- BrowserContext::GetDefaultStoragePartition(profile_.get())->
- GetDatabaseTracker();
+ BrowserContext::GetDefaultStoragePartition(profile())
+ ->GetDatabaseTracker();
base::string16 db_name = base::UTF8ToUTF16("db");
base::string16 description = base::UTF8ToUTF16("db_description");
int64 size;
// Note: This test depends on details of how the dom_storage library
// stores data in the host file system.
base::FilePath lso_dir_path =
- profile_->GetPath().AppendASCII("Local Storage");
+ profile()->GetPath().AppendASCII("Local Storage");
base::FilePath lso_file_path = lso_dir_path.AppendASCII(origin_id)
.AddExtension(FILE_PATH_LITERAL(".localstorage"));
EXPECT_TRUE(base::CreateDirectory(lso_dir_path));
- EXPECT_EQ(0, file_util::WriteFile(lso_file_path, NULL, 0));
+ EXPECT_EQ(0, base::WriteFile(lso_file_path, NULL, 0));
EXPECT_TRUE(base::PathExists(lso_file_path));
// Create indexed db. Similarly, it is enough to only simulate this by
// creating the directory on the disk.
- IndexedDBContext* idb_context =
- BrowserContext::GetDefaultStoragePartition(profile_.get())->
- GetIndexedDBContext();
+ IndexedDBContext* idb_context = BrowserContext::GetDefaultStoragePartition(
+ profile())->GetIndexedDBContext();
idb_context->SetTaskRunnerForTesting(
base::MessageLoop::current()->message_loop_proxy().get());
base::FilePath idb_path = idb_context->GetFilePathForTesting(origin_id);
// Uninstall one of them, unlimited storage should still be granted
// to the origin.
UninstallExtension(id1, false);
- EXPECT_EQ(1u, registry_->enabled_extensions().size());
- EXPECT_TRUE(profile_->GetExtensionSpecialStoragePolicy()->
- IsStorageUnlimited(origin1));
+ EXPECT_EQ(1u, registry()->enabled_extensions().size());
+ EXPECT_TRUE(profile()->GetExtensionSpecialStoragePolicy()->IsStorageUnlimited(
+ origin1));
// Check that the cookie is still there.
cookie_monster->GetAllCookiesForURLAsync(
// Now uninstall the other. Storage should be cleared for the apps.
UninstallExtension(id2, false);
- EXPECT_EQ(0u, registry_->enabled_extensions().size());
- EXPECT_FALSE(profile_->GetExtensionSpecialStoragePolicy()->
- IsStorageUnlimited(origin1));
+ EXPECT_EQ(0u, registry()->enabled_extensions().size());
+ EXPECT_FALSE(
+ profile()->GetExtensionSpecialStoragePolicy()->IsStorageUnlimited(
+ origin1));
// Check that the cookie is gone.
cookie_monster->GetAllCookiesForURLAsync(
TEST_F(ExtensionServiceTest, DISABLED_LoadExtension) {
InitializeEmptyExtensionService();
- base::FilePath ext1 = data_dir_
- .AppendASCII("good")
- .AppendASCII("Extensions")
- .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj")
- .AppendASCII("1.0.0.0");
- extensions::UnpackedInstaller::Create(service_)->Load(ext1);
+ base::FilePath ext1 = data_dir()
+ .AppendASCII("good")
+ .AppendASCII("Extensions")
+ .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj")
+ .AppendASCII("1.0.0.0");
+ extensions::UnpackedInstaller::Create(service())->Load(ext1);
base::RunLoop().RunUntilIdle();
EXPECT_EQ(0u, GetErrors().size());
ASSERT_EQ(1u, loaded_.size());
EXPECT_EQ(Manifest::UNPACKED, loaded_[0]->location());
- EXPECT_EQ(1u, registry_->enabled_extensions().size());
+ EXPECT_EQ(1u, registry()->enabled_extensions().size());
ValidatePrefKeyCount(1);
- base::FilePath no_manifest = data_dir_
- .AppendASCII("bad")
- // .AppendASCII("Extensions")
- .AppendASCII("cccccccccccccccccccccccccccccccc")
- .AppendASCII("1");
- extensions::UnpackedInstaller::Create(service_)->Load(no_manifest);
+ base::FilePath no_manifest =
+ data_dir()
+ .AppendASCII("bad")
+ // .AppendASCII("Extensions")
+ .AppendASCII("cccccccccccccccccccccccccccccccc")
+ .AppendASCII("1");
+ extensions::UnpackedInstaller::Create(service())->Load(no_manifest);
base::RunLoop().RunUntilIdle();
EXPECT_EQ(1u, GetErrors().size());
ASSERT_EQ(1u, loaded_.size());
- EXPECT_EQ(1u, registry_->enabled_extensions().size());
+ EXPECT_EQ(1u, registry()->enabled_extensions().size());
// Test uninstall.
std::string id = loaded_[0]->id();
EXPECT_FALSE(unloaded_id_.length());
- service_->UninstallExtension(id, false, NULL);
+ service()->UninstallExtension(id,
+ extensions::UNINSTALL_REASON_FOR_TESTING,
+ base::Bind(&base::DoNothing),
+ NULL);
base::RunLoop().RunUntilIdle();
EXPECT_EQ(id, unloaded_id_);
ASSERT_EQ(0u, loaded_.size());
- EXPECT_EQ(0u, registry_->enabled_extensions().size());
+ EXPECT_EQ(0u, registry()->enabled_extensions().size());
}
// Tests that we generate IDs when they are not specified in the manifest for
TEST_F(ExtensionServiceTest, GenerateID) {
InitializeEmptyExtensionService();
- base::FilePath no_id_ext = data_dir_.AppendASCII("no_id");
- extensions::UnpackedInstaller::Create(service_)->Load(no_id_ext);
+ base::FilePath no_id_ext = data_dir().AppendASCII("no_id");
+ extensions::UnpackedInstaller::Create(service())->Load(no_id_ext);
base::RunLoop().RunUntilIdle();
EXPECT_EQ(0u, GetErrors().size());
ASSERT_EQ(1u, loaded_.size());
std::string previous_id = loaded_[0]->id();
// If we reload the same path, we should get the same extension ID.
- extensions::UnpackedInstaller::Create(service_)->Load(no_id_ext);
+ extensions::UnpackedInstaller::Create(service())->Load(no_id_ext);
base::RunLoop().RunUntilIdle();
ASSERT_EQ(1u, loaded_.size());
ASSERT_EQ(previous_id, loaded_[0]->id());
TEST_F(ExtensionServiceTest, UnpackedValidatesLocales) {
InitializeEmptyExtensionService();
- base::FilePath bad_locale = data_dir_.AppendASCII("unpacked").
- AppendASCII("bad_messages_file");
- extensions::UnpackedInstaller::Create(service_)->Load(bad_locale);
+ base::FilePath bad_locale =
+ data_dir().AppendASCII("unpacked").AppendASCII("bad_messages_file");
+ extensions::UnpackedInstaller::Create(service())->Load(bad_locale);
base::RunLoop().RunUntilIdle();
EXPECT_EQ(1u, GetErrors().size());
base::FilePath ms_messages_file = bad_locale.AppendASCII("_locales")
void ExtensionServiceTest::TestExternalProvider(
MockExtensionProvider* provider, Manifest::Location location) {
// Verify that starting with no providers loads no extensions.
- service_->Init();
+ service()->Init();
ASSERT_EQ(0u, loaded_.size());
provider->set_visit_count(0);
// Register a test extension externally using the mock registry provider.
- base::FilePath source_path = data_dir_.AppendASCII("good.crx");
+ base::FilePath source_path = data_dir().AppendASCII("good.crx");
// Add the extension.
provider->UpdateOrAddExtension(good_crx, "1.0.0.0", source_path);
// Reloading extensions should find our externally registered extension
// and install it.
content::WindowedNotificationObserver observer(
- chrome::NOTIFICATION_CRX_INSTALLER_DONE,
+ extensions::NOTIFICATION_CRX_INSTALLER_DONE,
content::NotificationService::AllSources());
- service_->CheckForExternalUpdates();
+ service()->CheckForExternalUpdates();
observer.Wait();
ASSERT_EQ(0u, GetErrors().size());
// Reload extensions without changing anything. The extension should be
// loaded again.
loaded_.clear();
- service_->ReloadExtensionsForTest();
+ service()->ReloadExtensionsForTest();
base::RunLoop().RunUntilIdle();
ASSERT_EQ(0u, GetErrors().size());
ASSERT_EQ(1u, loaded_.size());
loaded_.clear();
content::WindowedNotificationObserver observer_2(
- chrome::NOTIFICATION_CRX_INSTALLER_DONE,
+ extensions::NOTIFICATION_CRX_INSTALLER_DONE,
content::NotificationService::AllSources());
- service_->CheckForExternalUpdates();
+ service()->CheckForExternalUpdates();
observer_2.Wait();
ASSERT_EQ(0u, GetErrors().size());
ASSERT_EQ(1u, loaded_.size());
// preference should prevent us from reinstalling.
std::string id = loaded_[0]->id();
bool no_uninstall =
- management_policy_->MustRemainEnabled(loaded_[0].get(), NULL);
- service_->UninstallExtension(id, false, NULL);
+ GetManagementPolicy()->MustRemainEnabled(loaded_[0].get(), NULL);
+ service()->UninstallExtension(id,
+ extensions::UNINSTALL_REASON_FOR_TESTING,
+ base::Bind(&base::DoNothing),
+ NULL);
base::RunLoop().RunUntilIdle();
- base::FilePath install_path = extensions_install_dir_.AppendASCII(id);
+ base::FilePath install_path = extensions_install_dir().AppendASCII(id);
if (no_uninstall) {
// Policy controlled extensions should not have been touched by uninstall.
ASSERT_TRUE(base::PathExists(install_path));
// The extension should also be gone from the install directory.
ASSERT_FALSE(base::PathExists(install_path));
loaded_.clear();
- service_->CheckForExternalUpdates();
+ service()->CheckForExternalUpdates();
base::RunLoop().RunUntilIdle();
ASSERT_EQ(0u, loaded_.size());
ValidatePrefKeyCount(1);
loaded_.clear();
content::WindowedNotificationObserver observer(
- chrome::NOTIFICATION_CRX_INSTALLER_DONE,
+ extensions::NOTIFICATION_CRX_INSTALLER_DONE,
content::NotificationService::AllSources());
- service_->CheckForExternalUpdates();
+ service()->CheckForExternalUpdates();
observer.Wait();
ASSERT_EQ(1u, loaded_.size());
}
ValidateIntegerPref(good_crx, "state", Extension::ENABLED);
ValidateIntegerPref(good_crx, "location", location);
- if (management_policy_->MustRemainEnabled(loaded_[0].get(), NULL)) {
+ if (GetManagementPolicy()->MustRemainEnabled(loaded_[0].get(), NULL)) {
EXPECT_EQ(2, provider->visit_count());
} else {
// Now test an externally triggered uninstall (deleting the registry key or
provider->RemoveExtension(good_crx);
loaded_.clear();
- service_->OnExternalProviderReady(provider);
+ service()->OnExternalProviderReady(provider);
base::RunLoop().RunUntilIdle();
ASSERT_EQ(0u, loaded_.size());
ValidatePrefKeyCount(0);
// Now test the case where user uninstalls and then the extension is removed
// from the external provider.
content::WindowedNotificationObserver observer(
- chrome::NOTIFICATION_CRX_INSTALLER_DONE,
+ extensions::NOTIFICATION_CRX_INSTALLER_DONE,
content::NotificationService::AllSources());
provider->UpdateOrAddExtension(good_crx, "1.0.0.1", source_path);
- service_->CheckForExternalUpdates();
+ service()->CheckForExternalUpdates();
observer.Wait();
ASSERT_EQ(1u, loaded_.size());
// User uninstalls.
loaded_.clear();
- service_->UninstallExtension(id, false, NULL);
+ service()->UninstallExtension(id,
+ extensions::UNINSTALL_REASON_FOR_TESTING,
+ base::Bind(&base::DoNothing),
+ NULL);
base::RunLoop().RunUntilIdle();
ASSERT_EQ(0u, loaded_.size());
// Should still be at 0.
loaded_.clear();
- extensions::InstalledLoader(service_).LoadAllExtensions();
+ extensions::InstalledLoader(service()).LoadAllExtensions();
base::RunLoop().RunUntilIdle();
ASSERT_EQ(0u, loaded_.size());
ValidatePrefKeyCount(1);
TEST_F(ExtensionServiceTest, ExternalInstallRegistry) {
// This should all work, even when normal extension installation is disabled.
InitializeEmptyExtensionService();
- set_extensions_enabled(false);
+ service()->set_extensions_enabled(false);
// Now add providers. Extension system takes ownership of the objects.
MockExtensionProvider* reg_provider =
- new MockExtensionProvider(service_, Manifest::EXTERNAL_REGISTRY);
+ new MockExtensionProvider(service(), Manifest::EXTERNAL_REGISTRY);
AddMockExternalProvider(reg_provider);
TestExternalProvider(reg_provider, Manifest::EXTERNAL_REGISTRY);
}
// Now add providers. Extension system takes ownership of the objects.
MockExtensionProvider* pref_provider =
- new MockExtensionProvider(service_, Manifest::EXTERNAL_PREF);
+ new MockExtensionProvider(service(), Manifest::EXTERNAL_PREF);
AddMockExternalProvider(pref_provider);
TestExternalProvider(pref_provider, Manifest::EXTERNAL_PREF);
TEST_F(ExtensionServiceTest, ExternalInstallPrefUpdateUrl) {
// This should all work, even when normal extension installation is disabled.
InitializeEmptyExtensionService();
- set_extensions_enabled(false);
+ service()->set_extensions_enabled(false);
// TODO(skerner): The mock provider is not a good model of a provider
// that works with update URLs, because it adds file and version info.
// what the visitor does results in an extension being downloaded and
// installed.
MockExtensionProvider* pref_provider =
- new MockExtensionProvider(service_,
- Manifest::EXTERNAL_PREF_DOWNLOAD);
+ new MockExtensionProvider(service(), Manifest::EXTERNAL_PREF_DOWNLOAD);
AddMockExternalProvider(pref_provider);
TestExternalProvider(pref_provider, Manifest::EXTERNAL_PREF_DOWNLOAD);
}
TEST_F(ExtensionServiceTest, ExternalInstallPolicyUpdateUrl) {
// This should all work, even when normal extension installation is disabled.
InitializeEmptyExtensionService();
- set_extensions_enabled(false);
+ service()->set_extensions_enabled(false);
// TODO(skerner): The mock provider is not a good model of a provider
// that works with update URLs, because it adds file and version info.
// what the visitor does results in an extension being downloaded and
// installed.
MockExtensionProvider* pref_provider =
- new MockExtensionProvider(service_,
- Manifest::EXTERNAL_POLICY_DOWNLOAD);
+ new MockExtensionProvider(service(), Manifest::EXTERNAL_POLICY_DOWNLOAD);
AddMockExternalProvider(pref_provider);
TestExternalProvider(pref_provider, Manifest::EXTERNAL_POLICY_DOWNLOAD);
}
// providers can't account for them.
TEST_F(ExtensionServiceTest, ExternalUninstall) {
// Start the extensions service with one external extension already installed.
- base::FilePath source_install_dir = data_dir_
- .AppendASCII("good")
- .AppendASCII("Extensions");
+ base::FilePath source_install_dir =
+ data_dir().AppendASCII("good").AppendASCII("Extensions");
base::FilePath pref_path = source_install_dir
.DirName()
.AppendASCII("PreferencesExternal");
// This initializes the extensions service with no ExternalProviders.
InitializeInstalledExtensionService(pref_path, source_install_dir);
- set_extensions_enabled(false);
+ service()->set_extensions_enabled(false);
- service_->Init();
+ service()->Init();
ASSERT_EQ(0u, GetErrors().size());
ASSERT_EQ(0u, loaded_.size());
// Verify that it's not the disabled extensions flag causing it not to load.
- set_extensions_enabled(true);
- service_->ReloadExtensionsForTest();
+ service()->set_extensions_enabled(true);
+ service()->ReloadExtensionsForTest();
base::RunLoop().RunUntilIdle();
ASSERT_EQ(0u, GetErrors().size());
InitializeEmptyExtensionService();
MockExtensionProvider* provider =
- new MockExtensionProvider(service_, Manifest::EXTERNAL_PREF);
+ new MockExtensionProvider(service(), Manifest::EXTERNAL_PREF);
AddMockExternalProvider(provider);
// Verify that starting with no providers loads no extensions.
- service_->Init();
+ service()->Init();
ASSERT_EQ(0u, loaded_.size());
// Start two checks for updates.
provider->set_visit_count(0);
- service_->CheckForExternalUpdates();
- service_->CheckForExternalUpdates();
+ service()->CheckForExternalUpdates();
+ service()->CheckForExternalUpdates();
base::RunLoop().RunUntilIdle();
// Two calls should cause two checks for external extensions.
EXPECT_EQ(0u, loaded_.size());
// Register a test extension externally using the mock registry provider.
- base::FilePath source_path = data_dir_.AppendASCII("good.crx");
+ base::FilePath source_path = data_dir().AppendASCII("good.crx");
provider->UpdateOrAddExtension(good_crx, "1.0.0.0", source_path);
// Two checks for external updates should find the extension, and install it
// once.
content::WindowedNotificationObserver observer(
- chrome::NOTIFICATION_CRX_INSTALLER_DONE,
+ extensions::NOTIFICATION_CRX_INSTALLER_DONE,
content::NotificationService::AllSources());
provider->set_visit_count(0);
- service_->CheckForExternalUpdates();
- service_->CheckForExternalUpdates();
+ service()->CheckForExternalUpdates();
+ service()->CheckForExternalUpdates();
observer.Wait();
EXPECT_EQ(2, provider->visit_count());
ASSERT_EQ(0u, GetErrors().size());
provider->RemoveExtension(good_crx);
provider->set_visit_count(0);
- service_->CheckForExternalUpdates();
- service_->CheckForExternalUpdates();
+ service()->CheckForExternalUpdates();
+ service()->CheckForExternalUpdates();
base::RunLoop().RunUntilIdle();
// Two calls should cause two checks for external extensions.
" \"external_version\": \"2.0\""
" },"
" \"cccccccccccccccccccccccccccccccc\": {"
- " \"external_update_url\": \"http:\\\\foo.com/update\""
+ " \"external_update_url\": \"http:\\\\foo.com/update\","
+ " \"install_parameter\": \"id\""
" }"
"}";
EXPECT_EQ(3, visitor.Visit(json_data));
" }"
"}";
EXPECT_EQ(1, from_webstore_visitor.Visit(json_data));
+
+ // Test was_installed_by_eom.
+ MockProviderVisitor was_installed_by_eom_visitor(
+ base_path, Extension::WAS_INSTALLED_BY_OEM);
+ json_data =
+ "{"
+ " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\": {"
+ " \"external_crx\": \"RandomExtension.crx\","
+ " \"external_version\": \"1.0\","
+ " \"was_installed_by_oem\": true"
+ " }"
+ "}";
+ EXPECT_EQ(1, was_installed_by_eom_visitor.Visit(json_data));
}
// Test loading good extensions from the profile directory.
extension_l10n_util::ScopedLocaleForTest testLocale("en");
// Initialize the test dir with a good Preferences/extensions.
- base::FilePath source_install_dir = data_dir_
- .AppendASCII("l10n");
+ base::FilePath source_install_dir = data_dir().AppendASCII("l10n");
base::FilePath pref_path =
source_install_dir.Append(chrome::kPreferencesFilename);
InitializeInstalledExtensionService(pref_path, source_install_dir);
- service_->Init();
+ service()->Init();
ASSERT_EQ(3u, loaded_.size());
class ExtensionsReadyRecorder : public content::NotificationObserver {
public:
ExtensionsReadyRecorder() : ready_(false) {
- registrar_.Add(this, chrome::NOTIFICATION_EXTENSIONS_READY,
+ registrar_.Add(this,
+ extensions::NOTIFICATION_EXTENSIONS_READY_DEPRECATED,
content::NotificationService::AllSources());
}
const content::NotificationSource& source,
const content::NotificationDetails& details) OVERRIDE {
switch (type) {
- case chrome::NOTIFICATION_EXTENSIONS_READY:
+ case extensions::NOTIFICATION_EXTENSIONS_READY_DEPRECATED:
ready_ = true;
break;
default:
TEST_F(ExtensionServiceTest, StorageQuota) {
InitializeEmptyExtensionService();
- base::FilePath extensions_path = data_dir_
- .AppendASCII("storage_quota");
+ base::FilePath extensions_path = data_dir().AppendASCII("storage_quota");
base::FilePath limited_quota_ext =
extensions_path.AppendASCII("limited_quota")
base::FilePath unlimited_quota_ext2 =
extensions_path.AppendASCII("unlimited_quota")
.AppendASCII("2.0");
- extensions::UnpackedInstaller::Create(service_)->Load(limited_quota_ext);
- extensions::UnpackedInstaller::Create(service_)->Load(unlimited_quota_ext);
- extensions::UnpackedInstaller::Create(service_)->Load(unlimited_quota_ext2);
+ extensions::UnpackedInstaller::Create(service())->Load(limited_quota_ext);
+ extensions::UnpackedInstaller::Create(service())->Load(unlimited_quota_ext);
+ extensions::UnpackedInstaller::Create(service())->Load(unlimited_quota_ext2);
base::RunLoop().RunUntilIdle();
ASSERT_EQ(3u, loaded_.size());
- EXPECT_TRUE(profile_.get());
- EXPECT_FALSE(profile_->IsOffTheRecord());
- EXPECT_FALSE(profile_->GetExtensionSpecialStoragePolicy()->IsStorageUnlimited(
- loaded_[0]->url()));
- EXPECT_TRUE(profile_->GetExtensionSpecialStoragePolicy()->IsStorageUnlimited(
+ EXPECT_TRUE(profile());
+ EXPECT_FALSE(profile()->IsOffTheRecord());
+ EXPECT_FALSE(
+ profile()->GetExtensionSpecialStoragePolicy()->IsStorageUnlimited(
+ loaded_[0]->url()));
+ EXPECT_TRUE(profile()->GetExtensionSpecialStoragePolicy()->IsStorageUnlimited(
loaded_[1]->url()));
- EXPECT_TRUE(profile_->GetExtensionSpecialStoragePolicy()->IsStorageUnlimited(
+ EXPECT_TRUE(profile()->GetExtensionSpecialStoragePolicy()->IsStorageUnlimited(
loaded_[2]->url()));
}
InitializeEmptyExtensionService();
// Component extensions should work even when extensions are disabled.
- set_extensions_enabled(false);
+ service()->set_extensions_enabled(false);
- base::FilePath path = data_dir_
- .AppendASCII("good")
- .AppendASCII("Extensions")
- .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj")
- .AppendASCII("1.0.0.0");
+ base::FilePath path = data_dir()
+ .AppendASCII("good")
+ .AppendASCII("Extensions")
+ .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj")
+ .AppendASCII("1.0.0.0");
std::string manifest;
ASSERT_TRUE(base::ReadFileToString(
path.Append(extensions::kManifestFilename), &manifest));
- service_->component_loader()->Add(manifest, path);
- service_->Init();
+ service()->component_loader()->Add(manifest, path);
+ service()->Init();
// Note that we do not pump messages -- the extension should be loaded
// immediately.
EXPECT_EQ(0u, GetErrors().size());
ASSERT_EQ(1u, loaded_.size());
EXPECT_EQ(Manifest::COMPONENT, loaded_[0]->location());
- EXPECT_EQ(1u, registry_->enabled_extensions().size());
+ EXPECT_EQ(1u, registry()->enabled_extensions().size());
// Component extensions get a prefs entry on first install.
ValidatePrefKeyCount(1);
// Reload all extensions, and make sure it comes back.
- std::string extension_id = (*registry_->enabled_extensions().begin())->id();
+ std::string extension_id = (*registry()->enabled_extensions().begin())->id();
loaded_.clear();
- service_->ReloadExtensionsForTest();
- ASSERT_EQ(1u, registry_->enabled_extensions().size());
- EXPECT_EQ(extension_id, (*registry_->enabled_extensions().begin())->id());
+ service()->ReloadExtensionsForTest();
+ ASSERT_EQ(1u, registry()->enabled_extensions().size());
+ EXPECT_EQ(extension_id, (*registry()->enabled_extensions().begin())->id());
}
-namespace {
-
-class TestSyncProcessorStub : public syncer::SyncChangeProcessor {
- virtual syncer::SyncError ProcessSyncChanges(
- const tracked_objects::Location& from_here,
- const syncer::SyncChangeList& change_list) OVERRIDE {
- return syncer::SyncError();
- }
-
- virtual syncer::SyncDataList GetAllSyncData(
- syncer::ModelType type) const OVERRIDE {
- return syncer::SyncDataList();
- }
-};
-
-} // namespace
-
TEST_F(ExtensionServiceTest, DeferredSyncStartupPreInstalledComponent) {
InitializeEmptyExtensionService();
InitializeExtensionSyncService();
bool flare_was_called = false;
syncer::ModelType triggered_type(syncer::UNSPECIFIED);
base::WeakPtrFactory<ExtensionServiceTest> factory(this);
- extension_sync_service_->SetSyncStartFlare(
+ extension_sync_service()->SetSyncStartFlare(
base::Bind(&ExtensionServiceTest::MockSyncStartFlare,
factory.GetWeakPtr(),
&flare_was_called, // Safe due to WeakPtrFactory scope.
std::string manifest;
ASSERT_TRUE(base::ReadFileToString(
good0_path().Append(extensions::kManifestFilename), &manifest));
- service_->component_loader()->Add(manifest, good0_path());
- ASSERT_FALSE(service_->is_ready());
- service_->Init();
- ASSERT_TRUE(service_->is_ready());
+ service()->component_loader()->Add(manifest, good0_path());
+ ASSERT_FALSE(service()->is_ready());
+ service()->Init();
+ ASSERT_TRUE(service()->is_ready());
// Extensions added before service is_ready() don't trigger sync startup.
EXPECT_FALSE(flare_was_called);
bool flare_was_called = false;
syncer::ModelType triggered_type(syncer::UNSPECIFIED);
base::WeakPtrFactory<ExtensionServiceTest> factory(this);
- extension_sync_service_->SetSyncStartFlare(
+ extension_sync_service()->SetSyncStartFlare(
base::Bind(&ExtensionServiceTest::MockSyncStartFlare,
factory.GetWeakPtr(),
&flare_was_called, // Safe due to WeakPtrFactory scope.
&triggered_type)); // Safe due to WeakPtrFactory scope.
- ASSERT_FALSE(service_->is_ready());
- service_->Init();
+ ASSERT_FALSE(service()->is_ready());
+ service()->Init();
ASSERT_EQ(3u, loaded_.size());
- ASSERT_TRUE(service_->is_ready());
+ ASSERT_TRUE(service()->is_ready());
// Extensions added before service is_ready() don't trigger sync startup.
EXPECT_FALSE(flare_was_called);
TEST_F(ExtensionServiceTest, DeferredSyncStartupOnInstall) {
InitializeEmptyExtensionService();
InitializeExtensionSyncService();
- service_->Init();
- ASSERT_TRUE(service_->is_ready());
+ service()->Init();
+ ASSERT_TRUE(service()->is_ready());
bool flare_was_called = false;
syncer::ModelType triggered_type(syncer::UNSPECIFIED);
base::WeakPtrFactory<ExtensionServiceTest> factory(this);
- extension_sync_service_->SetSyncStartFlare(
+ extension_sync_service()->SetSyncStartFlare(
base::Bind(&ExtensionServiceTest::MockSyncStartFlare,
factory.GetWeakPtr(),
&flare_was_called, // Safe due to WeakPtrFactory scope.
&triggered_type)); // Safe due to WeakPtrFactory scope.
- base::FilePath path = data_dir_.AppendASCII("good.crx");
+ base::FilePath path = data_dir().AppendASCII("good.crx");
InstallCRX(path, INSTALL_NEW);
EXPECT_TRUE(flare_was_called);
triggered_type = syncer::UNSPECIFIED;
// Once sync starts, flare should no longer be invoked.
- extension_sync_service_->MergeDataAndStartSyncing(
- syncer::EXTENSIONS, syncer::SyncDataList(),
- scoped_ptr<syncer::SyncChangeProcessor>(new TestSyncProcessorStub),
+ extension_sync_service()->MergeDataAndStartSyncing(
+ syncer::EXTENSIONS,
+ syncer::SyncDataList(),
+ scoped_ptr<syncer::SyncChangeProcessor>(
+ new syncer::FakeSyncChangeProcessor),
scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
- path = data_dir_.AppendASCII("page_action.crx");
+ path = data_dir().AppendASCII("page_action.crx");
InstallCRX(path, INSTALL_NEW);
EXPECT_FALSE(flare_was_called);
ASSERT_EQ(syncer::UNSPECIFIED, triggered_type);
TEST_F(ExtensionServiceTest, DisableExtensionFromSync) {
// Start the extensions service with one external extension already installed.
- base::FilePath source_install_dir = data_dir_
- .AppendASCII("good")
- .AppendASCII("Extensions");
+ base::FilePath source_install_dir =
+ data_dir().AppendASCII("good").AppendASCII("Extensions");
base::FilePath pref_path =
source_install_dir.DirName().Append(chrome::kPreferencesFilename);
// The user has enabled sync.
ProfileSyncService* sync_service =
- ProfileSyncServiceFactory::GetForProfile(profile_.get());
+ ProfileSyncServiceFactory::GetForProfile(profile());
sync_service->SetSyncSetupCompleted();
- service_->Init();
- ASSERT_TRUE(service_->is_ready());
+ service()->Init();
+ ASSERT_TRUE(service()->is_ready());
ASSERT_EQ(3u, loaded_.size());
// We start enabled.
- const Extension* extension = service_->GetExtensionById(good0, true);
+ const Extension* extension = service()->GetExtensionById(good0, true);
ASSERT_TRUE(extension);
- ASSERT_TRUE(service_->IsExtensionEnabled(good0));
- extensions::ExtensionSyncData disable_good_crx(*extension, false, false);
+ ASSERT_TRUE(service()->IsExtensionEnabled(good0));
+ extensions::ExtensionSyncData disable_good_crx(
+ *extension, false, false, false);
// Then sync data arrives telling us to disable |good0|.
syncer::SyncDataList sync_data;
sync_data.push_back(disable_good_crx.GetSyncData());
- extension_sync_service_->MergeDataAndStartSyncing(
- syncer::EXTENSIONS, sync_data,
- scoped_ptr<syncer::SyncChangeProcessor>(new TestSyncProcessorStub),
+ extension_sync_service()->MergeDataAndStartSyncing(
+ syncer::EXTENSIONS,
+ sync_data,
+ scoped_ptr<syncer::SyncChangeProcessor>(
+ new syncer::FakeSyncChangeProcessor),
scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
- ASSERT_FALSE(service_->IsExtensionEnabled(good0));
+ ASSERT_FALSE(service()->IsExtensionEnabled(good0));
}
TEST_F(ExtensionServiceTest, DontDisableExtensionWithPendingEnableFromSync) {
// Start the extensions service with one external extension already installed.
- base::FilePath source_install_dir = data_dir_
- .AppendASCII("good")
- .AppendASCII("Extensions");
+ base::FilePath source_install_dir =
+ data_dir().AppendASCII("good").AppendASCII("Extensions");
base::FilePath pref_path =
source_install_dir.DirName().Append(chrome::kPreferencesFilename);
// The user has enabled sync.
ProfileSyncService* sync_service =
- ProfileSyncServiceFactory::GetForProfile(profile_.get());
+ ProfileSyncServiceFactory::GetForProfile(profile());
sync_service->SetSyncSetupCompleted();
- service_->Init();
- ASSERT_TRUE(service_->is_ready());
+ service()->Init();
+ ASSERT_TRUE(service()->is_ready());
ASSERT_EQ(3u, loaded_.size());
- const Extension* extension = service_->GetExtensionById(good0, true);
- ASSERT_TRUE(service_->IsExtensionEnabled(good0));
+ const Extension* extension = service()->GetExtensionById(good0, true);
+ ASSERT_TRUE(service()->IsExtensionEnabled(good0));
// Disable extension before first sync data arrives.
- service_->DisableExtension(good0, Extension::DISABLE_USER_ACTION);
- ASSERT_FALSE(service_->IsExtensionEnabled(good0));
+ service()->DisableExtension(good0, Extension::DISABLE_USER_ACTION);
+ ASSERT_FALSE(service()->IsExtensionEnabled(good0));
// Enable extension - this is now the most recent state.
- service_->EnableExtension(good0);
- ASSERT_TRUE(service_->IsExtensionEnabled(good0));
+ service()->EnableExtension(good0);
+ ASSERT_TRUE(service()->IsExtensionEnabled(good0));
// Now sync data comes in that says to disable good0. This should be
// ignored.
- extensions::ExtensionSyncData disable_good_crx(*extension, false, false);
+ extensions::ExtensionSyncData disable_good_crx(
+ *extension, false, false, false);
syncer::SyncDataList sync_data;
sync_data.push_back(disable_good_crx.GetSyncData());
- extension_sync_service_->MergeDataAndStartSyncing(
- syncer::EXTENSIONS, sync_data,
- scoped_ptr<syncer::SyncChangeProcessor>(new TestSyncProcessorStub),
+ extension_sync_service()->MergeDataAndStartSyncing(
+ syncer::EXTENSIONS,
+ sync_data,
+ scoped_ptr<syncer::SyncChangeProcessor>(
+ new syncer::FakeSyncChangeProcessor),
scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
// The extension was enabled locally before the sync data arrived, so it
// should still be enabled now.
- ASSERT_TRUE(service_->IsExtensionEnabled(good0));
+ ASSERT_TRUE(service()->IsExtensionEnabled(good0));
}
TEST_F(ExtensionServiceTest, GetSyncData) {
InitializeEmptyExtensionService();
InitializeExtensionSyncService();
- InstallCRX(data_dir_.AppendASCII("good.crx"), INSTALL_NEW);
- const Extension* extension = service_->GetInstalledExtension(good_crx);
+ InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
+ const Extension* extension = service()->GetInstalledExtension(good_crx);
ASSERT_TRUE(extension);
- extension_sync_service_->MergeDataAndStartSyncing(
- syncer::EXTENSIONS, syncer::SyncDataList(),
- scoped_ptr<syncer::SyncChangeProcessor>(new TestSyncProcessorStub),
+ extension_sync_service()->MergeDataAndStartSyncing(
+ syncer::EXTENSIONS,
+ syncer::SyncDataList(),
+ scoped_ptr<syncer::SyncChangeProcessor>(
+ new syncer::FakeSyncChangeProcessor),
scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
- syncer::SyncDataList list = extension_sync_service_->GetAllSyncData(
- syncer::EXTENSIONS);
+ syncer::SyncDataList list =
+ extension_sync_service()->GetAllSyncData(syncer::EXTENSIONS);
ASSERT_EQ(list.size(), 1U);
extensions::ExtensionSyncData data(list[0]);
EXPECT_EQ(extension->id(), data.id());
EXPECT_FALSE(data.uninstalled());
- EXPECT_EQ(service_->IsExtensionEnabled(good_crx), data.enabled());
- EXPECT_EQ(extensions::util::IsIncognitoEnabled(good_crx, profile_.get()),
+ EXPECT_EQ(service()->IsExtensionEnabled(good_crx), data.enabled());
+ EXPECT_EQ(extensions::util::IsIncognitoEnabled(good_crx, profile()),
data.incognito_enabled());
EXPECT_TRUE(data.version().Equals(*extension->version()));
EXPECT_EQ(extensions::ManifestURL::GetUpdateURL(extension),
TEST_F(ExtensionServiceTest, GetSyncDataTerminated) {
InitializeEmptyExtensionService();
InitializeExtensionSyncService();
- InstallCRX(data_dir_.AppendASCII("good.crx"), INSTALL_NEW);
+ InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
TerminateExtension(good_crx);
- const Extension* extension = service_->GetInstalledExtension(good_crx);
+ const Extension* extension = service()->GetInstalledExtension(good_crx);
ASSERT_TRUE(extension);
- TestSyncProcessorStub processor;
- extension_sync_service_->MergeDataAndStartSyncing(
- syncer::EXTENSIONS, syncer::SyncDataList(),
- scoped_ptr<syncer::SyncChangeProcessor>(new TestSyncProcessorStub),
+ syncer::FakeSyncChangeProcessor processor;
+ extension_sync_service()->MergeDataAndStartSyncing(
+ syncer::EXTENSIONS,
+ syncer::SyncDataList(),
+ scoped_ptr<syncer::SyncChangeProcessor>(
+ new syncer::FakeSyncChangeProcessor),
scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
- syncer::SyncDataList list = extension_sync_service_->GetAllSyncData(
- syncer::EXTENSIONS);
+ syncer::SyncDataList list =
+ extension_sync_service()->GetAllSyncData(syncer::EXTENSIONS);
ASSERT_EQ(list.size(), 1U);
extensions::ExtensionSyncData data(list[0]);
EXPECT_EQ(extension->id(), data.id());
EXPECT_FALSE(data.uninstalled());
- EXPECT_EQ(service_->IsExtensionEnabled(good_crx), data.enabled());
- EXPECT_EQ(extensions::util::IsIncognitoEnabled(good_crx, profile_.get()),
+ EXPECT_EQ(service()->IsExtensionEnabled(good_crx), data.enabled());
+ EXPECT_EQ(extensions::util::IsIncognitoEnabled(good_crx, profile()),
data.incognito_enabled());
EXPECT_TRUE(data.version().Equals(*extension->version()));
EXPECT_EQ(extensions::ManifestURL::GetUpdateURL(extension),
TEST_F(ExtensionServiceTest, GetSyncDataFilter) {
InitializeEmptyExtensionService();
InitializeExtensionSyncService();
- InstallCRX(data_dir_.AppendASCII("good.crx"), INSTALL_NEW);
- const Extension* extension = service_->GetInstalledExtension(good_crx);
+ InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
+ const Extension* extension = service()->GetInstalledExtension(good_crx);
ASSERT_TRUE(extension);
- TestSyncProcessorStub processor;
- extension_sync_service_->MergeDataAndStartSyncing(syncer::APPS,
+ syncer::FakeSyncChangeProcessor processor;
+ extension_sync_service()->MergeDataAndStartSyncing(
+ syncer::APPS,
syncer::SyncDataList(),
- scoped_ptr<syncer::SyncChangeProcessor>(new TestSyncProcessorStub),
+ scoped_ptr<syncer::SyncChangeProcessor>(
+ new syncer::FakeSyncChangeProcessor),
scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
- syncer::SyncDataList list = extension_sync_service_->GetAllSyncData(
- syncer::EXTENSIONS);
+ syncer::SyncDataList list =
+ extension_sync_service()->GetAllSyncData(syncer::EXTENSIONS);
ASSERT_EQ(list.size(), 0U);
}
InitializeEmptyExtensionService();
InitializeProcessManager();
InitializeExtensionSyncService();
- InstallCRX(data_dir_.AppendASCII("good.crx"), INSTALL_NEW);
- const Extension* extension = service_->GetInstalledExtension(good_crx);
+ InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
+ const Extension* extension = service()->GetInstalledExtension(good_crx);
ASSERT_TRUE(extension);
- TestSyncProcessorStub processor;
- extension_sync_service_->MergeDataAndStartSyncing(
- syncer::EXTENSIONS, syncer::SyncDataList(),
- scoped_ptr<syncer::SyncChangeProcessor>(new TestSyncProcessorStub),
+ syncer::FakeSyncChangeProcessor processor;
+ extension_sync_service()->MergeDataAndStartSyncing(
+ syncer::EXTENSIONS,
+ syncer::SyncDataList(),
+ scoped_ptr<syncer::SyncChangeProcessor>(
+ new syncer::FakeSyncChangeProcessor),
scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
{
- syncer::SyncDataList list = extension_sync_service_->GetAllSyncData(
- syncer::EXTENSIONS);
+ syncer::SyncDataList list =
+ extension_sync_service()->GetAllSyncData(syncer::EXTENSIONS);
ASSERT_EQ(list.size(), 1U);
extensions::ExtensionSyncData data(list[0]);
EXPECT_TRUE(data.enabled());
EXPECT_FALSE(data.incognito_enabled());
}
- service_->DisableExtension(good_crx, Extension::DISABLE_USER_ACTION);
+ service()->DisableExtension(good_crx, Extension::DISABLE_USER_ACTION);
{
- syncer::SyncDataList list = extension_sync_service_->GetAllSyncData(
- syncer::EXTENSIONS);
+ syncer::SyncDataList list =
+ extension_sync_service()->GetAllSyncData(syncer::EXTENSIONS);
ASSERT_EQ(list.size(), 1U);
extensions::ExtensionSyncData data(list[0]);
EXPECT_FALSE(data.enabled());
EXPECT_FALSE(data.incognito_enabled());
}
- extensions::util::SetIsIncognitoEnabled(good_crx, profile_.get(), true);
+ extensions::util::SetIsIncognitoEnabled(good_crx, profile(), true);
{
- syncer::SyncDataList list = extension_sync_service_->GetAllSyncData(
- syncer::EXTENSIONS);
+ syncer::SyncDataList list =
+ extension_sync_service()->GetAllSyncData(syncer::EXTENSIONS);
ASSERT_EQ(list.size(), 1U);
extensions::ExtensionSyncData data(list[0]);
EXPECT_FALSE(data.enabled());
EXPECT_TRUE(data.incognito_enabled());
}
- service_->EnableExtension(good_crx);
+ service()->EnableExtension(good_crx);
{
- syncer::SyncDataList list = extension_sync_service_->GetAllSyncData(
- syncer::EXTENSIONS);
+ syncer::SyncDataList list =
+ extension_sync_service()->GetAllSyncData(syncer::EXTENSIONS);
ASSERT_EQ(list.size(), 1U);
extensions::ExtensionSyncData data(list[0]);
EXPECT_TRUE(data.enabled());
TEST_F(ExtensionServiceTest, SyncForUninstalledExternalExtension) {
InitializeEmptyExtensionService();
InitializeExtensionSyncService();
- InstallCRXWithLocation(data_dir_.AppendASCII("good.crx"),
- Manifest::EXTERNAL_PREF, INSTALL_NEW);
- const Extension* extension = service_->GetInstalledExtension(good_crx);
+ InstallCRXWithLocation(
+ data_dir().AppendASCII("good.crx"), Manifest::EXTERNAL_PREF, INSTALL_NEW);
+ const Extension* extension = service()->GetInstalledExtension(good_crx);
ASSERT_TRUE(extension);
- TestSyncProcessorStub processor;
- extension_sync_service_->MergeDataAndStartSyncing(
- syncer::EXTENSIONS, syncer::SyncDataList(),
- scoped_ptr<syncer::SyncChangeProcessor>(new TestSyncProcessorStub),
+ syncer::FakeSyncChangeProcessor processor;
+ extension_sync_service()->MergeDataAndStartSyncing(
+ syncer::EXTENSIONS,
+ syncer::SyncDataList(),
+ scoped_ptr<syncer::SyncChangeProcessor>(
+ new syncer::FakeSyncChangeProcessor),
scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
UninstallExtension(good_crx, false);
- EXPECT_TRUE(service_->IsExternalExtensionUninstalled(good_crx));
+ EXPECT_TRUE(
+ ExtensionPrefs::Get(profile())->IsExternalExtensionUninstalled(good_crx));
sync_pb::EntitySpecifics specifics;
sync_pb::AppSpecifics* app_specifics = specifics.mutable_app();
syncer::SyncChangeList list(1);
list[0] = sync_change;
- extension_sync_service_->ProcessSyncChanges(FROM_HERE, list);
- EXPECT_TRUE(service_->IsExternalExtensionUninstalled(good_crx));
+ extension_sync_service()->ProcessSyncChanges(FROM_HERE, list);
+ EXPECT_TRUE(
+ ExtensionPrefs::Get(profile())->IsExternalExtensionUninstalled(good_crx));
}
TEST_F(ExtensionServiceTest, GetSyncAppDataUserSettings) {
InitializeEmptyExtensionService();
InitializeExtensionSyncService();
const Extension* app =
- PackAndInstallCRX(data_dir_.AppendASCII("app"), INSTALL_NEW);
+ PackAndInstallCRX(data_dir().AppendASCII("app"), INSTALL_NEW);
ASSERT_TRUE(app);
ASSERT_TRUE(app->is_app());
- TestSyncProcessorStub processor;
- extension_sync_service_->MergeDataAndStartSyncing(syncer::APPS,
+ syncer::FakeSyncChangeProcessor processor;
+ extension_sync_service()->MergeDataAndStartSyncing(
+ syncer::APPS,
syncer::SyncDataList(),
- scoped_ptr<syncer::SyncChangeProcessor>(new TestSyncProcessorStub),
+ scoped_ptr<syncer::SyncChangeProcessor>(
+ new syncer::FakeSyncChangeProcessor),
scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
syncer::StringOrdinal initial_ordinal =
syncer::StringOrdinal::CreateInitialOrdinal();
{
- syncer::SyncDataList list = extension_sync_service_->GetAllSyncData(
- syncer::APPS);
+ syncer::SyncDataList list =
+ extension_sync_service()->GetAllSyncData(syncer::APPS);
ASSERT_EQ(list.size(), 1U);
extensions::AppSyncData app_sync_data(list[0]);
EXPECT_TRUE(initial_ordinal.Equals(app_sync_data.page_ordinal()));
}
- AppSorting* sorting = service_->extension_prefs()->app_sorting();
+ AppSorting* sorting = ExtensionPrefs::Get(profile())->app_sorting();
sorting->SetAppLaunchOrdinal(app->id(), initial_ordinal.CreateAfter());
{
- syncer::SyncDataList list = extension_sync_service_->GetAllSyncData(
- syncer::APPS);
+ syncer::SyncDataList list =
+ extension_sync_service()->GetAllSyncData(syncer::APPS);
ASSERT_EQ(list.size(), 1U);
extensions::AppSyncData app_sync_data(list[0]);
sorting->SetPageOrdinal(app->id(), initial_ordinal.CreateAfter());
{
- syncer::SyncDataList list = extension_sync_service_->GetAllSyncData(
- syncer::APPS);
+ syncer::SyncDataList list =
+ extension_sync_service()->GetAllSyncData(syncer::APPS);
ASSERT_EQ(list.size(), 1U);
extensions::AppSyncData app_sync_data(list[0]);
}
}
+// TODO (rdevlin.cronin): The OnExtensionMoved() method has been removed from
+// ExtensionService, so this test probably needs a new home. Unfortunately, it
+// relies pretty heavily on things like InitializeExtension[Sync]Service() and
+// PackAndInstallCRX(). When we clean up a bit more, this should move out.
TEST_F(ExtensionServiceTest, GetSyncAppDataUserSettingsOnExtensionMoved) {
InitializeEmptyExtensionService();
InitializeExtensionSyncService();
const size_t kAppCount = 3;
const Extension* apps[kAppCount];
- apps[0] = PackAndInstallCRX(data_dir_.AppendASCII("app1"), INSTALL_NEW);
- apps[1] = PackAndInstallCRX(data_dir_.AppendASCII("app2"), INSTALL_NEW);
- apps[2] = PackAndInstallCRX(data_dir_.AppendASCII("app4"), INSTALL_NEW);
+ apps[0] = PackAndInstallCRX(data_dir().AppendASCII("app1"), INSTALL_NEW);
+ apps[1] = PackAndInstallCRX(data_dir().AppendASCII("app2"), INSTALL_NEW);
+ apps[2] = PackAndInstallCRX(data_dir().AppendASCII("app4"), INSTALL_NEW);
for (size_t i = 0; i < kAppCount; ++i) {
ASSERT_TRUE(apps[i]);
ASSERT_TRUE(apps[i]->is_app());
}
- TestSyncProcessorStub processor;
- extension_sync_service_->MergeDataAndStartSyncing(syncer::APPS,
+ syncer::FakeSyncChangeProcessor processor;
+ extension_sync_service()->MergeDataAndStartSyncing(
+ syncer::APPS,
syncer::SyncDataList(),
- scoped_ptr<syncer::SyncChangeProcessor>(new TestSyncProcessorStub),
+ scoped_ptr<syncer::SyncChangeProcessor>(
+ new syncer::FakeSyncChangeProcessor),
scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
- service_->OnExtensionMoved(apps[0]->id(), apps[1]->id(), apps[2]->id());
+ ExtensionPrefs::Get(service()->GetBrowserContext())
+ ->app_sorting()
+ ->OnExtensionMoved(apps[0]->id(), apps[1]->id(), apps[2]->id());
{
- syncer::SyncDataList list = extension_sync_service_->GetAllSyncData(
- syncer::APPS);
+ syncer::SyncDataList list =
+ extension_sync_service()->GetAllSyncData(syncer::APPS);
ASSERT_EQ(list.size(), 3U);
extensions::AppSyncData data[kAppCount];
TEST_F(ExtensionServiceTest, GetSyncDataList) {
InitializeEmptyExtensionService();
InitializeExtensionSyncService();
- InstallCRX(data_dir_.AppendASCII("good.crx"), INSTALL_NEW);
- InstallCRX(data_dir_.AppendASCII("page_action.crx"), INSTALL_NEW);
- InstallCRX(data_dir_.AppendASCII("theme.crx"), INSTALL_NEW);
- InstallCRX(data_dir_.AppendASCII("theme2.crx"), INSTALL_NEW);
-
- TestSyncProcessorStub processor;
- extension_sync_service_->MergeDataAndStartSyncing(
- syncer::APPS, syncer::SyncDataList(),
- scoped_ptr<syncer::SyncChangeProcessor>(new TestSyncProcessorStub),
+ InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
+ InstallCRX(data_dir().AppendASCII("page_action.crx"), INSTALL_NEW);
+ InstallCRX(data_dir().AppendASCII("theme.crx"), INSTALL_NEW);
+ InstallCRX(data_dir().AppendASCII("theme2.crx"), INSTALL_NEW);
+
+ syncer::FakeSyncChangeProcessor processor;
+ extension_sync_service()->MergeDataAndStartSyncing(
+ syncer::APPS,
+ syncer::SyncDataList(),
+ scoped_ptr<syncer::SyncChangeProcessor>(
+ new syncer::FakeSyncChangeProcessor),
scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
- extension_sync_service_->MergeDataAndStartSyncing(
- syncer::EXTENSIONS, syncer::SyncDataList(),
- scoped_ptr<syncer::SyncChangeProcessor>(new TestSyncProcessorStub),
+ extension_sync_service()->MergeDataAndStartSyncing(
+ syncer::EXTENSIONS,
+ syncer::SyncDataList(),
+ scoped_ptr<syncer::SyncChangeProcessor>(
+ new syncer::FakeSyncChangeProcessor),
scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
- service_->DisableExtension(page_action, Extension::DISABLE_USER_ACTION);
+ service()->DisableExtension(page_action, Extension::DISABLE_USER_ACTION);
TerminateExtension(theme2_crx);
- EXPECT_EQ(0u, extension_sync_service_->GetAllSyncData(syncer::APPS).size());
- EXPECT_EQ(2u, extension_sync_service_->
- GetAllSyncData(syncer::EXTENSIONS).size());
+ EXPECT_EQ(0u, extension_sync_service()->GetAllSyncData(syncer::APPS).size());
+ EXPECT_EQ(
+ 2u, extension_sync_service()->GetAllSyncData(syncer::EXTENSIONS).size());
}
TEST_F(ExtensionServiceTest, ProcessSyncDataUninstall) {
InitializeEmptyExtensionService();
InitializeExtensionSyncService();
- TestSyncProcessorStub processor;
- extension_sync_service_->MergeDataAndStartSyncing(
- syncer::EXTENSIONS, syncer::SyncDataList(),
- scoped_ptr<syncer::SyncChangeProcessor>(new TestSyncProcessorStub),
+ syncer::FakeSyncChangeProcessor processor;
+ extension_sync_service()->MergeDataAndStartSyncing(
+ syncer::EXTENSIONS,
+ syncer::SyncDataList(),
+ scoped_ptr<syncer::SyncChangeProcessor>(
+ new syncer::FakeSyncChangeProcessor),
scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
sync_pb::EntitySpecifics specifics;
list[0] = sync_change;
// Should do nothing.
- extension_sync_service_->ProcessSyncChanges(FROM_HERE, list);
- EXPECT_FALSE(service_->GetExtensionById(good_crx, true));
+ extension_sync_service()->ProcessSyncChanges(FROM_HERE, list);
+ EXPECT_FALSE(service()->GetExtensionById(good_crx, true));
// Install the extension.
- base::FilePath extension_path = data_dir_.AppendASCII("good.crx");
+ base::FilePath extension_path = data_dir().AppendASCII("good.crx");
InstallCRX(extension_path, INSTALL_NEW);
- EXPECT_TRUE(service_->GetExtensionById(good_crx, true));
+ EXPECT_TRUE(service()->GetExtensionById(good_crx, true));
// Should uninstall the extension.
- extension_sync_service_->ProcessSyncChanges(FROM_HERE, list);
- EXPECT_FALSE(service_->GetExtensionById(good_crx, true));
+ extension_sync_service()->ProcessSyncChanges(FROM_HERE, list);
+ EXPECT_FALSE(service()->GetExtensionById(good_crx, true));
// Should again do nothing.
- extension_sync_service_->ProcessSyncChanges(FROM_HERE, list);
- EXPECT_FALSE(service_->GetExtensionById(good_crx, true));
+ extension_sync_service()->ProcessSyncChanges(FROM_HERE, list);
+ EXPECT_FALSE(service()->GetExtensionById(good_crx, true));
}
TEST_F(ExtensionServiceTest, ProcessSyncDataWrongType) {
InitializeExtensionSyncService();
// Install the extension.
- base::FilePath extension_path = data_dir_.AppendASCII("good.crx");
+ base::FilePath extension_path = data_dir().AppendASCII("good.crx");
InstallCRX(extension_path, INSTALL_NEW);
- EXPECT_TRUE(service_->GetExtensionById(good_crx, true));
+ EXPECT_TRUE(service()->GetExtensionById(good_crx, true));
sync_pb::EntitySpecifics specifics;
sync_pb::AppSpecifics* app_specifics = specifics.mutable_app();
app_specifics->mutable_extension();
extension_specifics->set_id(good_crx);
extension_specifics->set_version(
- service_->GetInstalledExtension(good_crx)->version()->GetString());
+ service()->GetInstalledExtension(good_crx)->version()->GetString());
{
extension_specifics->set_enabled(true);
list[0] = sync_change;
// Should do nothing
- extension_sync_service_->ProcessSyncChanges(FROM_HERE, list);
- EXPECT_TRUE(service_->GetExtensionById(good_crx, true));
+ extension_sync_service()->ProcessSyncChanges(FROM_HERE, list);
+ EXPECT_TRUE(service()->GetExtensionById(good_crx, true));
}
{
list[0] = sync_change;
// Should again do nothing.
- extension_sync_service_->ProcessSyncChanges(FROM_HERE, list);
- EXPECT_TRUE(service_->GetExtensionById(good_crx, false));
+ extension_sync_service()->ProcessSyncChanges(FROM_HERE, list);
+ EXPECT_TRUE(service()->GetExtensionById(good_crx, false));
}
}
InitializeEmptyExtensionService();
InitializeProcessManager();
InitializeExtensionSyncService();
- TestSyncProcessorStub processor;
- extension_sync_service_->MergeDataAndStartSyncing(
- syncer::EXTENSIONS, syncer::SyncDataList(),
- scoped_ptr<syncer::SyncChangeProcessor>(new TestSyncProcessorStub),
+ syncer::FakeSyncChangeProcessor processor;
+ extension_sync_service()->MergeDataAndStartSyncing(
+ syncer::EXTENSIONS,
+ syncer::SyncDataList(),
+ scoped_ptr<syncer::SyncChangeProcessor>(
+ new syncer::FakeSyncChangeProcessor),
scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
- InstallCRX(data_dir_.AppendASCII("good.crx"), INSTALL_NEW);
- EXPECT_TRUE(service_->IsExtensionEnabled(good_crx));
- EXPECT_FALSE(extensions::util::IsIncognitoEnabled(good_crx, profile_.get()));
+ InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
+ EXPECT_TRUE(service()->IsExtensionEnabled(good_crx));
+ EXPECT_FALSE(extensions::util::IsIncognitoEnabled(good_crx, profile()));
sync_pb::EntitySpecifics specifics;
sync_pb::ExtensionSpecifics* ext_specifics = specifics.mutable_extension();
ext_specifics->set_id(good_crx);
ext_specifics->set_version(
- service_->GetInstalledExtension(good_crx)->version()->GetString());
+ service()->GetInstalledExtension(good_crx)->version()->GetString());
ext_specifics->set_enabled(false);
{
sync_data);
syncer::SyncChangeList list(1);
list[0] = sync_change;
- extension_sync_service_->ProcessSyncChanges(FROM_HERE, list);
- EXPECT_FALSE(service_->IsExtensionEnabled(good_crx));
- EXPECT_FALSE(
- extensions::util::IsIncognitoEnabled(good_crx, profile_.get()));
+ extension_sync_service()->ProcessSyncChanges(FROM_HERE, list);
+ EXPECT_FALSE(service()->IsExtensionEnabled(good_crx));
+ EXPECT_FALSE(extensions::util::IsIncognitoEnabled(good_crx, profile()));
}
{
sync_data);
syncer::SyncChangeList list(1);
list[0] = sync_change;
- extension_sync_service_->ProcessSyncChanges(FROM_HERE, list);
- EXPECT_TRUE(service_->IsExtensionEnabled(good_crx));
- EXPECT_TRUE(extensions::util::IsIncognitoEnabled(good_crx, profile_.get()));
+ extension_sync_service()->ProcessSyncChanges(FROM_HERE, list);
+ EXPECT_TRUE(service()->IsExtensionEnabled(good_crx));
+ EXPECT_TRUE(extensions::util::IsIncognitoEnabled(good_crx, profile()));
}
{
sync_data);
syncer::SyncChangeList list(1);
list[0] = sync_change;
- extension_sync_service_->ProcessSyncChanges(FROM_HERE, list);
- EXPECT_FALSE(service_->IsExtensionEnabled(good_crx));
- EXPECT_TRUE(extensions::util::IsIncognitoEnabled(good_crx, profile_.get()));
+ extension_sync_service()->ProcessSyncChanges(FROM_HERE, list);
+ EXPECT_FALSE(service()->IsExtensionEnabled(good_crx));
+ EXPECT_TRUE(extensions::util::IsIncognitoEnabled(good_crx, profile()));
}
- EXPECT_FALSE(service_->pending_extension_manager()->IsIdPending(good_crx));
+ EXPECT_FALSE(service()->pending_extension_manager()->IsIdPending(good_crx));
}
TEST_F(ExtensionServiceTest, ProcessSyncDataTerminatedExtension) {
InitializeExtensionServiceWithUpdater();
InitializeExtensionSyncService();
- TestSyncProcessorStub processor;
- extension_sync_service_->MergeDataAndStartSyncing(
- syncer::EXTENSIONS, syncer::SyncDataList(),
- scoped_ptr<syncer::SyncChangeProcessor>(new TestSyncProcessorStub),
+ syncer::FakeSyncChangeProcessor processor;
+ extension_sync_service()->MergeDataAndStartSyncing(
+ syncer::EXTENSIONS,
+ syncer::SyncDataList(),
+ scoped_ptr<syncer::SyncChangeProcessor>(
+ new syncer::FakeSyncChangeProcessor),
scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
- InstallCRX(data_dir_.AppendASCII("good.crx"), INSTALL_NEW);
+ InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
TerminateExtension(good_crx);
- EXPECT_TRUE(service_->IsExtensionEnabled(good_crx));
- EXPECT_FALSE(extensions::util::IsIncognitoEnabled(good_crx, profile_.get()));
+ EXPECT_TRUE(service()->IsExtensionEnabled(good_crx));
+ EXPECT_FALSE(extensions::util::IsIncognitoEnabled(good_crx, profile()));
sync_pb::EntitySpecifics specifics;
sync_pb::ExtensionSpecifics* ext_specifics = specifics.mutable_extension();
ext_specifics->set_id(good_crx);
ext_specifics->set_version(
- service_->GetInstalledExtension(good_crx)->version()->GetString());
+ service()->GetInstalledExtension(good_crx)->version()->GetString());
ext_specifics->set_enabled(false);
ext_specifics->set_incognito_enabled(true);
syncer::SyncData sync_data =
syncer::SyncChangeList list(1);
list[0] = sync_change;
- extension_sync_service_->ProcessSyncChanges(FROM_HERE, list);
- EXPECT_FALSE(service_->IsExtensionEnabled(good_crx));
- EXPECT_TRUE(extensions::util::IsIncognitoEnabled(good_crx, profile_.get()));
+ extension_sync_service()->ProcessSyncChanges(FROM_HERE, list);
+ EXPECT_FALSE(service()->IsExtensionEnabled(good_crx));
+ EXPECT_TRUE(extensions::util::IsIncognitoEnabled(good_crx, profile()));
- EXPECT_FALSE(service_->pending_extension_manager()->IsIdPending(good_crx));
+ EXPECT_FALSE(service()->pending_extension_manager()->IsIdPending(good_crx));
}
TEST_F(ExtensionServiceTest, ProcessSyncDataVersionCheck) {
InitializeExtensionServiceWithUpdater();
InitializeExtensionSyncService();
- TestSyncProcessorStub processor;
- extension_sync_service_->MergeDataAndStartSyncing(
- syncer::EXTENSIONS, syncer::SyncDataList(),
- scoped_ptr<syncer::SyncChangeProcessor>(new TestSyncProcessorStub),
+ syncer::FakeSyncChangeProcessor processor;
+ extension_sync_service()->MergeDataAndStartSyncing(
+ syncer::EXTENSIONS,
+ syncer::SyncDataList(),
+ scoped_ptr<syncer::SyncChangeProcessor>(
+ new syncer::FakeSyncChangeProcessor),
scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
- InstallCRX(data_dir_.AppendASCII("good.crx"), INSTALL_NEW);
- EXPECT_TRUE(service_->IsExtensionEnabled(good_crx));
- EXPECT_FALSE(extensions::util::IsIncognitoEnabled(good_crx, profile_.get()));
+ InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
+ EXPECT_TRUE(service()->IsExtensionEnabled(good_crx));
+ EXPECT_FALSE(extensions::util::IsIncognitoEnabled(good_crx, profile()));
sync_pb::EntitySpecifics specifics;
sync_pb::ExtensionSpecifics* ext_specifics = specifics.mutable_extension();
{
ext_specifics->set_version(
- service_->GetInstalledExtension(good_crx)->version()->GetString());
+ service()->GetInstalledExtension(good_crx)->version()->GetString());
syncer::SyncData sync_data =
syncer::SyncData::CreateLocalData(good_crx, "Name", specifics);
syncer::SyncChange sync_change(FROM_HERE,
list[0] = sync_change;
// Should do nothing if extension version == sync version.
- extension_sync_service_->ProcessSyncChanges(FROM_HERE, list);
- EXPECT_FALSE(service_->updater()->WillCheckSoon());
+ extension_sync_service()->ProcessSyncChanges(FROM_HERE, list);
+ EXPECT_FALSE(service()->updater()->WillCheckSoon());
}
// Should do nothing if extension version > sync version (but see
syncer::SyncChangeList list(1);
list[0] = sync_change;
- extension_sync_service_->ProcessSyncChanges(FROM_HERE, list);
- EXPECT_FALSE(service_->updater()->WillCheckSoon());
+ extension_sync_service()->ProcessSyncChanges(FROM_HERE, list);
+ EXPECT_FALSE(service()->updater()->WillCheckSoon());
}
// Should kick off an update if extension version < sync version.
syncer::SyncChangeList list(1);
list[0] = sync_change;
- extension_sync_service_->ProcessSyncChanges(FROM_HERE, list);
- EXPECT_TRUE(service_->updater()->WillCheckSoon());
+ extension_sync_service()->ProcessSyncChanges(FROM_HERE, list);
+ EXPECT_TRUE(service()->updater()->WillCheckSoon());
}
- EXPECT_FALSE(service_->pending_extension_manager()->IsIdPending(good_crx));
+ EXPECT_FALSE(service()->pending_extension_manager()->IsIdPending(good_crx));
}
TEST_F(ExtensionServiceTest, ProcessSyncDataNotInstalled) {
InitializeExtensionServiceWithUpdater();
InitializeExtensionSyncService();
- TestSyncProcessorStub processor;
- extension_sync_service_->MergeDataAndStartSyncing(
- syncer::EXTENSIONS, syncer::SyncDataList(),
- scoped_ptr<syncer::SyncChangeProcessor>(new TestSyncProcessorStub),
+ syncer::FakeSyncChangeProcessor processor;
+ extension_sync_service()->MergeDataAndStartSyncing(
+ syncer::EXTENSIONS,
+ syncer::SyncDataList(),
+ scoped_ptr<syncer::SyncChangeProcessor>(
+ new syncer::FakeSyncChangeProcessor),
scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
sync_pb::EntitySpecifics specifics;
syncer::SyncChangeList list(1);
list[0] = sync_change;
-
- EXPECT_TRUE(service_->IsExtensionEnabled(good_crx));
- EXPECT_FALSE(extensions::util::IsIncognitoEnabled(good_crx, profile_.get()));
- extension_sync_service_->ProcessSyncChanges(FROM_HERE, list);
- EXPECT_TRUE(service_->updater()->WillCheckSoon());
- EXPECT_FALSE(service_->IsExtensionEnabled(good_crx));
- EXPECT_TRUE(extensions::util::IsIncognitoEnabled(good_crx, profile_.get()));
+ EXPECT_TRUE(service()->IsExtensionEnabled(good_crx));
+ EXPECT_FALSE(extensions::util::IsIncognitoEnabled(good_crx, profile()));
+ extension_sync_service()->ProcessSyncChanges(FROM_HERE, list);
+ EXPECT_TRUE(service()->updater()->WillCheckSoon());
+ EXPECT_FALSE(service()->IsExtensionEnabled(good_crx));
+ EXPECT_TRUE(extensions::util::IsIncognitoEnabled(good_crx, profile()));
const extensions::PendingExtensionInfo* info;
- EXPECT_TRUE((info = service_->pending_extension_manager()->
- GetById(good_crx)));
+ EXPECT_TRUE(
+ (info = service()->pending_extension_manager()->GetById(good_crx)));
EXPECT_EQ(ext_specifics->update_url(), info->update_url().spec());
EXPECT_TRUE(info->is_from_sync());
EXPECT_TRUE(info->install_silently());
// TODO(akalin): Figure out a way to test |info.ShouldAllowInstall()|.
}
+TEST_F(ExtensionServiceTest, SupervisedUser_InstallOnlyAllowedByCustodian) {
+ ExtensionServiceInitParams params = CreateDefaultInitParams();
+ params.profile_is_supervised = true;
+ InitializeExtensionService(params);
+
+ SupervisedUserService* supervised_user_service =
+ SupervisedUserServiceFactory::GetForProfile(profile());
+ GetManagementPolicy()->RegisterProvider(supervised_user_service);
+
+ base::FilePath path1 = data_dir().AppendASCII("good.crx");
+ base::FilePath path2 = data_dir().AppendASCII("good2048.crx");
+ const Extension* extensions[] = {
+ InstallCRX(path1, INSTALL_FAILED),
+ InstallCRX(path2, INSTALL_NEW, Extension::WAS_INSTALLED_BY_CUSTODIAN)
+ };
+
+ // Only the extension with the "installed by custodian" flag should have been
+ // installed and enabled.
+ EXPECT_FALSE(extensions[0]);
+ ASSERT_TRUE(extensions[1]);
+ EXPECT_TRUE(registry()->enabled_extensions().Contains(extensions[1]->id()));
+}
+
+TEST_F(ExtensionServiceTest, SupervisedUser_UpdateWithoutPermissionIncrease) {
+ ExtensionServiceInitParams params = CreateDefaultInitParams();
+ params.profile_is_supervised = true;
+ InitializeExtensionService(params);
+
+ SupervisedUserService* supervised_user_service =
+ SupervisedUserServiceFactory::GetForProfile(profile());
+ GetManagementPolicy()->RegisterProvider(supervised_user_service);
+
+ base::FilePath base_path = data_dir().AppendASCII("autoupdate");
+ base::FilePath pem_path = base_path.AppendASCII("key.pem");
+
+ base::FilePath path = base_path.AppendASCII("v1");
+ const Extension* extension =
+ PackAndInstallCRX(path, pem_path, INSTALL_NEW,
+ Extension::WAS_INSTALLED_BY_CUSTODIAN);
+ // The extension must now be installed and enabled.
+ ASSERT_TRUE(extension);
+ ASSERT_TRUE(registry()->enabled_extensions().Contains(extension->id()));
+
+ // Save the id, as the extension object will be destroyed during updating.
+ std::string id = extension->id();
+
+ std::string old_version = extension->VersionString();
+
+ // Update to a new version.
+ path = base_path.AppendASCII("v2");
+ PackCRXAndUpdateExtension(id, path, pem_path, ENABLED);
+
+ // The extension should still be there and enabled.
+ extension = registry()->enabled_extensions().GetByID(id);
+ ASSERT_TRUE(extension);
+ // The version should have changed.
+ EXPECT_NE(extension->VersionString(), old_version);
+}
+
+TEST_F(ExtensionServiceTest, SupervisedUser_UpdateWithPermissionIncrease) {
+ ExtensionServiceInitParams params = CreateDefaultInitParams();
+ params.profile_is_supervised = true;
+ InitializeExtensionService(params);
+
+ SupervisedUserService* supervised_user_service =
+ SupervisedUserServiceFactory::GetForProfile(profile());
+ GetManagementPolicy()->RegisterProvider(supervised_user_service);
+
+ base::FilePath base_path = data_dir().AppendASCII("permissions_increase");
+ base::FilePath pem_path = base_path.AppendASCII("permissions.pem");
+
+ base::FilePath path = base_path.AppendASCII("v1");
+ const Extension* extension =
+ PackAndInstallCRX(path, pem_path, INSTALL_NEW,
+ Extension::WAS_INSTALLED_BY_CUSTODIAN);
+ // The extension must now be installed and enabled.
+ ASSERT_TRUE(extension);
+ ASSERT_TRUE(registry()->enabled_extensions().Contains(extension->id()));
+
+ // Save the id, as the extension object will be destroyed during updating.
+ std::string id = extension->id();
+
+ std::string old_version = extension->VersionString();
+
+ // Update to a new version with increased permissions.
+ path = base_path.AppendASCII("v2");
+ PackCRXAndUpdateExtension(id, path, pem_path, DISABLED);
+
+ // The extension should still be there, but disabled.
+ EXPECT_FALSE(registry()->enabled_extensions().Contains(id));
+ extension = registry()->disabled_extensions().GetByID(id);
+ ASSERT_TRUE(extension);
+ // The version should have changed.
+ EXPECT_NE(extension->VersionString(), old_version);
+}
+
+TEST_F(ExtensionServiceTest,
+ SupervisedUser_SyncUninstallByCustodianSkipsPolicy) {
+ InitializeEmptyExtensionService();
+ InitializeExtensionSyncService();
+ extension_sync_service()->MergeDataAndStartSyncing(
+ syncer::EXTENSIONS,
+ syncer::SyncDataList(),
+ scoped_ptr<syncer::SyncChangeProcessor>(
+ new syncer::FakeSyncChangeProcessor),
+ scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
+
+ // Install two extensions.
+ base::FilePath path1 = data_dir().AppendASCII("good.crx");
+ base::FilePath path2 = data_dir().AppendASCII("good2048.crx");
+ const Extension* extensions[] = {
+ InstallCRX(path1, INSTALL_NEW),
+ InstallCRX(path2, INSTALL_NEW, Extension::WAS_INSTALLED_BY_CUSTODIAN)
+ };
+
+ // Add a policy provider that will disallow any changes.
+ extensions::TestManagementPolicyProvider provider(
+ extensions::TestManagementPolicyProvider::PROHIBIT_MODIFY_STATUS);
+ GetManagementPolicy()->RegisterProvider(&provider);
+
+ // Create a sync deletion for each extension.
+ syncer::SyncChangeList change_list;
+ for (size_t i = 0; i < arraysize(extensions); i++) {
+ const std::string& id = extensions[i]->id();
+ sync_pb::EntitySpecifics specifics;
+ sync_pb::ExtensionSpecifics* ext_specifics = specifics.mutable_extension();
+ ext_specifics->set_id(id);
+ ext_specifics->set_version("1.0");
+ ext_specifics->set_installed_by_custodian(
+ extensions[i]->was_installed_by_custodian());
+ syncer::SyncData sync_data =
+ syncer::SyncData::CreateLocalData(id, "Name", specifics);
+ change_list.push_back(syncer::SyncChange(FROM_HERE,
+ syncer::SyncChange::ACTION_DELETE,
+ sync_data));
+ }
+
+ // Save the extension ids, as uninstalling destroys the Extension instance.
+ std::string extension_ids[] = {
+ extensions[0]->id(),
+ extensions[1]->id()
+ };
+
+ // Now apply the uninstallations.
+ extension_sync_service()->ProcessSyncChanges(FROM_HERE, change_list);
+
+ // Uninstalling the extension without installed_by_custodian should have been
+ // blocked by policy, so it should still be there.
+ EXPECT_TRUE(registry()->enabled_extensions().Contains(extension_ids[0]));
+
+ // But installed_by_custodian should result in bypassing the policy check.
+ EXPECT_FALSE(
+ registry()->GenerateInstalledExtensionsSet()->Contains(extension_ids[1]));
+}
+
TEST_F(ExtensionServiceTest, InstallPriorityExternalUpdateUrl) {
InitializeEmptyExtensionService();
- base::FilePath path = data_dir_.AppendASCII("good.crx");
+ base::FilePath path = data_dir().AppendASCII("good.crx");
InstallCRX(path, INSTALL_NEW);
ValidatePrefKeyCount(1u);
ValidateIntegerPref(good_crx, "state", Extension::ENABLED);
ValidateIntegerPref(good_crx, "location", Manifest::INTERNAL);
extensions::PendingExtensionManager* pending =
- service_->pending_extension_manager();
+ service()->pending_extension_manager();
EXPECT_FALSE(pending->IsIdPending(kGoodId));
// Skip install when the location is the same.
EXPECT_FALSE(
- service_->OnExternalExtensionUpdateUrlFound(
- kGoodId, GURL(kGoodUpdateURL), Manifest::INTERNAL,
- Extension::NO_FLAGS, false));
+ service()->OnExternalExtensionUpdateUrlFound(kGoodId,
+ std::string(),
+ GURL(kGoodUpdateURL),
+ Manifest::INTERNAL,
+ Extension::NO_FLAGS,
+ false));
EXPECT_FALSE(pending->IsIdPending(kGoodId));
// Install when the location has higher priority.
- EXPECT_TRUE(
- service_->OnExternalExtensionUpdateUrlFound(
- kGoodId, GURL(kGoodUpdateURL), Manifest::EXTERNAL_POLICY_DOWNLOAD,
- Extension::NO_FLAGS, false));
+ EXPECT_TRUE(service()->OnExternalExtensionUpdateUrlFound(
+ kGoodId,
+ std::string(),
+ GURL(kGoodUpdateURL),
+ Manifest::EXTERNAL_POLICY_DOWNLOAD,
+ Extension::NO_FLAGS,
+ false));
EXPECT_TRUE(pending->IsIdPending(kGoodId));
// Try the low priority again. Should be rejected.
- EXPECT_FALSE(
- service_->OnExternalExtensionUpdateUrlFound(
- kGoodId, GURL(kGoodUpdateURL), Manifest::EXTERNAL_PREF_DOWNLOAD,
- Extension::NO_FLAGS, false));
+ EXPECT_FALSE(service()->OnExternalExtensionUpdateUrlFound(
+ kGoodId,
+ std::string(),
+ GURL(kGoodUpdateURL),
+ Manifest::EXTERNAL_PREF_DOWNLOAD,
+ Extension::NO_FLAGS,
+ false));
// The existing record should still be present in the pending extension
// manager.
EXPECT_TRUE(pending->IsIdPending(kGoodId));
// Skip install when the location has the same priority as the installed
// location.
- EXPECT_FALSE(service_->OnExternalExtensionUpdateUrlFound(
- kGoodId, GURL(kGoodUpdateURL), Manifest::INTERNAL,
- Extension::NO_FLAGS, false));
+ EXPECT_FALSE(
+ service()->OnExternalExtensionUpdateUrlFound(kGoodId,
+ std::string(),
+ GURL(kGoodUpdateURL),
+ Manifest::INTERNAL,
+ Extension::NO_FLAGS,
+ false));
EXPECT_FALSE(pending->IsIdPending(kGoodId));
}
Manifest::INTERNAL));
extensions::PendingExtensionManager* pending =
- service_->pending_extension_manager();
+ service()->pending_extension_manager();
EXPECT_FALSE(pending->IsIdPending(kGoodId));
{
// Simulate an external source adding the extension as INTERNAL.
content::WindowedNotificationObserver observer(
- chrome::NOTIFICATION_CRX_INSTALLER_DONE,
+ extensions::NOTIFICATION_CRX_INSTALLER_DONE,
content::NotificationService::AllSources());
- EXPECT_TRUE(
- service_->OnExternalExtensionFileFound(
- kGoodId, &older_version, kInvalidPathToCrx,
- Manifest::INTERNAL, kCreationFlags, kDontMarkAcknowledged));
+ EXPECT_TRUE(service()->OnExternalExtensionFileFound(kGoodId,
+ &older_version,
+ kInvalidPathToCrx,
+ Manifest::INTERNAL,
+ kCreationFlags,
+ kDontMarkAcknowledged));
EXPECT_TRUE(pending->IsIdPending(kGoodId));
observer.Wait();
VerifyCrxInstall(kInvalidPathToCrx, INSTALL_FAILED);
{
// Simulate an external source adding the extension as EXTERNAL_PREF.
content::WindowedNotificationObserver observer(
- chrome::NOTIFICATION_CRX_INSTALLER_DONE,
+ extensions::NOTIFICATION_CRX_INSTALLER_DONE,
content::NotificationService::AllSources());
- EXPECT_TRUE(
- service_->OnExternalExtensionFileFound(
- kGoodId, &older_version, kInvalidPathToCrx,
- Manifest::EXTERNAL_PREF, kCreationFlags, kDontMarkAcknowledged));
+ EXPECT_TRUE(service()->OnExternalExtensionFileFound(kGoodId,
+ &older_version,
+ kInvalidPathToCrx,
+ Manifest::EXTERNAL_PREF,
+ kCreationFlags,
+ kDontMarkAcknowledged));
EXPECT_TRUE(pending->IsIdPending(kGoodId));
observer.Wait();
VerifyCrxInstall(kInvalidPathToCrx, INSTALL_FAILED);
// Simulate an external source adding as EXTERNAL_PREF again.
// This is rejected because the version and the location are the same as
// the previous installation, which is still pending.
- EXPECT_FALSE(
- service_->OnExternalExtensionFileFound(
- kGoodId, &older_version, kInvalidPathToCrx,
- Manifest::EXTERNAL_PREF, kCreationFlags, kDontMarkAcknowledged));
+ EXPECT_FALSE(service()->OnExternalExtensionFileFound(kGoodId,
+ &older_version,
+ kInvalidPathToCrx,
+ Manifest::EXTERNAL_PREF,
+ kCreationFlags,
+ kDontMarkAcknowledged));
EXPECT_TRUE(pending->IsIdPending(kGoodId));
// Try INTERNAL again. Should fail.
- EXPECT_FALSE(
- service_->OnExternalExtensionFileFound(
- kGoodId, &older_version, kInvalidPathToCrx,
- Manifest::INTERNAL, kCreationFlags, kDontMarkAcknowledged));
+ EXPECT_FALSE(service()->OnExternalExtensionFileFound(kGoodId,
+ &older_version,
+ kInvalidPathToCrx,
+ Manifest::INTERNAL,
+ kCreationFlags,
+ kDontMarkAcknowledged));
EXPECT_TRUE(pending->IsIdPending(kGoodId));
{
// Now the registry adds the extension.
content::WindowedNotificationObserver observer(
- chrome::NOTIFICATION_CRX_INSTALLER_DONE,
+ extensions::NOTIFICATION_CRX_INSTALLER_DONE,
content::NotificationService::AllSources());
EXPECT_TRUE(
- service_->OnExternalExtensionFileFound(kGoodId,
- &older_version,
- kInvalidPathToCrx,
- Manifest::EXTERNAL_REGISTRY,
- kCreationFlags,
- kDontMarkAcknowledged));
+ service()->OnExternalExtensionFileFound(kGoodId,
+ &older_version,
+ kInvalidPathToCrx,
+ Manifest::EXTERNAL_REGISTRY,
+ kCreationFlags,
+ kDontMarkAcknowledged));
EXPECT_TRUE(pending->IsIdPending(kGoodId));
observer.Wait();
VerifyCrxInstall(kInvalidPathToCrx, INSTALL_FAILED);
}
// Registry outranks both external pref and internal, so both fail.
- EXPECT_FALSE(
- service_->OnExternalExtensionFileFound(
- kGoodId, &older_version, kInvalidPathToCrx,
- Manifest::EXTERNAL_PREF, kCreationFlags, kDontMarkAcknowledged));
+ EXPECT_FALSE(service()->OnExternalExtensionFileFound(kGoodId,
+ &older_version,
+ kInvalidPathToCrx,
+ Manifest::EXTERNAL_PREF,
+ kCreationFlags,
+ kDontMarkAcknowledged));
EXPECT_TRUE(pending->IsIdPending(kGoodId));
- EXPECT_FALSE(
- service_->OnExternalExtensionFileFound(
- kGoodId, &older_version, kInvalidPathToCrx,
- Manifest::INTERNAL, kCreationFlags, kDontMarkAcknowledged));
+ EXPECT_FALSE(service()->OnExternalExtensionFileFound(kGoodId,
+ &older_version,
+ kInvalidPathToCrx,
+ Manifest::INTERNAL,
+ kCreationFlags,
+ kDontMarkAcknowledged));
EXPECT_TRUE(pending->IsIdPending(kGoodId));
pending->Remove(kGoodId);
// Install the extension.
- base::FilePath path = data_dir_.AppendASCII("good.crx");
+ base::FilePath path = data_dir().AppendASCII("good.crx");
const Extension* ext = InstallCRX(path, INSTALL_NEW);
ValidatePrefKeyCount(1u);
ValidateIntegerPref(good_crx, "state", Extension::ENABLED);
// older, or the same, and succeed if the version is newer.
// Older than the installed version...
- EXPECT_FALSE(
- service_->OnExternalExtensionFileFound(
- kGoodId, &older_version, kInvalidPathToCrx,
- Manifest::INTERNAL, kCreationFlags, kDontMarkAcknowledged));
+ EXPECT_FALSE(service()->OnExternalExtensionFileFound(kGoodId,
+ &older_version,
+ kInvalidPathToCrx,
+ Manifest::INTERNAL,
+ kCreationFlags,
+ kDontMarkAcknowledged));
EXPECT_FALSE(pending->IsIdPending(kGoodId));
// Same version as the installed version...
- EXPECT_FALSE(
- service_->OnExternalExtensionFileFound(
- kGoodId, ext->version(), kInvalidPathToCrx,
- Manifest::INTERNAL, kCreationFlags, kDontMarkAcknowledged));
+ EXPECT_FALSE(service()->OnExternalExtensionFileFound(kGoodId,
+ ext->version(),
+ kInvalidPathToCrx,
+ Manifest::INTERNAL,
+ kCreationFlags,
+ kDontMarkAcknowledged));
EXPECT_FALSE(pending->IsIdPending(kGoodId));
// Newer than the installed version...
- EXPECT_TRUE(
- service_->OnExternalExtensionFileFound(
- kGoodId, &newer_version, kInvalidPathToCrx,
- Manifest::INTERNAL, kCreationFlags, kDontMarkAcknowledged));
+ EXPECT_TRUE(service()->OnExternalExtensionFileFound(kGoodId,
+ &newer_version,
+ kInvalidPathToCrx,
+ Manifest::INTERNAL,
+ kCreationFlags,
+ kDontMarkAcknowledged));
EXPECT_TRUE(pending->IsIdPending(kGoodId));
// An external install for a higher priority install source should succeed
// if the version is greater. |older_version| is not...
- EXPECT_FALSE(
- service_->OnExternalExtensionFileFound(
- kGoodId, &older_version, kInvalidPathToCrx,
- Manifest::EXTERNAL_PREF, kCreationFlags, kDontMarkAcknowledged));
+ EXPECT_FALSE(service()->OnExternalExtensionFileFound(kGoodId,
+ &older_version,
+ kInvalidPathToCrx,
+ Manifest::EXTERNAL_PREF,
+ kCreationFlags,
+ kDontMarkAcknowledged));
EXPECT_TRUE(pending->IsIdPending(kGoodId));
// |newer_version| is newer.
- EXPECT_TRUE(
- service_->OnExternalExtensionFileFound(
- kGoodId, &newer_version, kInvalidPathToCrx,
- Manifest::EXTERNAL_PREF, kCreationFlags, kDontMarkAcknowledged));
+ EXPECT_TRUE(service()->OnExternalExtensionFileFound(kGoodId,
+ &newer_version,
+ kInvalidPathToCrx,
+ Manifest::EXTERNAL_PREF,
+ kCreationFlags,
+ kDontMarkAcknowledged));
EXPECT_TRUE(pending->IsIdPending(kGoodId));
// An external install for an even higher priority install source should
// succeed if the version is greater.
EXPECT_TRUE(
- service_->OnExternalExtensionFileFound(
- kGoodId, &newer_version, kInvalidPathToCrx,
- Manifest::EXTERNAL_REGISTRY, kCreationFlags, kDontMarkAcknowledged));
+ service()->OnExternalExtensionFileFound(kGoodId,
+ &newer_version,
+ kInvalidPathToCrx,
+ Manifest::EXTERNAL_REGISTRY,
+ kCreationFlags,
+ kDontMarkAcknowledged));
EXPECT_TRUE(pending->IsIdPending(kGoodId));
// Because EXTERNAL_PREF is a lower priority source than EXTERNAL_REGISTRY,
// adding from external pref will now fail.
- EXPECT_FALSE(
- service_->OnExternalExtensionFileFound(
- kGoodId, &newer_version, kInvalidPathToCrx,
- Manifest::EXTERNAL_PREF, kCreationFlags, kDontMarkAcknowledged));
+ EXPECT_FALSE(service()->OnExternalExtensionFileFound(kGoodId,
+ &newer_version,
+ kInvalidPathToCrx,
+ Manifest::EXTERNAL_PREF,
+ kCreationFlags,
+ kDontMarkAcknowledged));
EXPECT_TRUE(pending->IsIdPending(kGoodId));
}
InitializeEmptyExtensionService();
extensions::PendingExtensionManager* pending =
- service_->pending_extension_manager();
+ service()->pending_extension_manager();
EXPECT_FALSE(pending->IsIdPending(kGoodId));
// An external provider starts installing from a local crx.
- EXPECT_TRUE(
- service_->OnExternalExtensionFileFound(
- kGoodId, &kVersion123, kInvalidPathToCrx,
- Manifest::EXTERNAL_PREF, kCreationFlags, kDontMarkAcknowledged));
+ EXPECT_TRUE(service()->OnExternalExtensionFileFound(kGoodId,
+ &kVersion123,
+ kInvalidPathToCrx,
+ Manifest::EXTERNAL_PREF,
+ kCreationFlags,
+ kDontMarkAcknowledged));
const extensions::PendingExtensionInfo* info;
EXPECT_TRUE((info = pending->GetById(kGoodId)));
EXPECT_TRUE(info->version().IsValid());
EXPECT_TRUE(info->version().Equals(kVersion123));
// Adding a newer version overrides the currently pending version.
- EXPECT_TRUE(
- service_->OnExternalExtensionFileFound(
- kGoodId, &kVersion124, kInvalidPathToCrx,
- Manifest::EXTERNAL_PREF, kCreationFlags, kDontMarkAcknowledged));
+ EXPECT_TRUE(service()->OnExternalExtensionFileFound(kGoodId,
+ &kVersion124,
+ kInvalidPathToCrx,
+ Manifest::EXTERNAL_PREF,
+ kCreationFlags,
+ kDontMarkAcknowledged));
EXPECT_TRUE((info = pending->GetById(kGoodId)));
EXPECT_TRUE(info->version().IsValid());
EXPECT_TRUE(info->version().Equals(kVersion124));
// Adding an older version fails.
- EXPECT_FALSE(
- service_->OnExternalExtensionFileFound(
- kGoodId, &kVersion123, kInvalidPathToCrx,
- Manifest::EXTERNAL_PREF, kCreationFlags, kDontMarkAcknowledged));
+ EXPECT_FALSE(service()->OnExternalExtensionFileFound(kGoodId,
+ &kVersion123,
+ kInvalidPathToCrx,
+ Manifest::EXTERNAL_PREF,
+ kCreationFlags,
+ kDontMarkAcknowledged));
EXPECT_TRUE((info = pending->GetById(kGoodId)));
EXPECT_TRUE(info->version().IsValid());
EXPECT_TRUE(info->version().Equals(kVersion124));
// Adding an older version fails even when coming from a higher-priority
// location.
EXPECT_FALSE(
- service_->OnExternalExtensionFileFound(
- kGoodId, &kVersion123, kInvalidPathToCrx,
- Manifest::EXTERNAL_REGISTRY, kCreationFlags, kDontMarkAcknowledged));
+ service()->OnExternalExtensionFileFound(kGoodId,
+ &kVersion123,
+ kInvalidPathToCrx,
+ Manifest::EXTERNAL_REGISTRY,
+ kCreationFlags,
+ kDontMarkAcknowledged));
EXPECT_TRUE((info = pending->GetById(kGoodId)));
EXPECT_TRUE(info->version().IsValid());
EXPECT_TRUE(info->version().Equals(kVersion124));
// Adding the latest version from the webstore overrides a specific version.
GURL kUpdateUrl("http://example.com/update");
- EXPECT_TRUE(
- service_->OnExternalExtensionUpdateUrlFound(
- kGoodId, kUpdateUrl, Manifest::EXTERNAL_POLICY_DOWNLOAD,
- Extension::NO_FLAGS, false));
+ EXPECT_TRUE(service()->OnExternalExtensionUpdateUrlFound(
+ kGoodId,
+ std::string(),
+ kUpdateUrl,
+ Manifest::EXTERNAL_POLICY_DOWNLOAD,
+ Extension::NO_FLAGS,
+ false));
EXPECT_TRUE((info = pending->GetById(kGoodId)));
EXPECT_FALSE(info->version().IsValid());
}
TEST_F(ExtensionServiceTest, InstallWhitelistedExtension) {
std::string test_id = "hdkklepkcpckhnpgjnmbdfhehckloojk";
CommandLine::ForCurrentProcess()->AppendSwitchASCII(
- switches::kWhitelistedExtensionID, test_id);
+ extensions::switches::kWhitelistedExtensionID, test_id);
InitializeEmptyExtensionService();
- base::FilePath path = data_dir_
- .AppendASCII("permissions");
+ base::FilePath path = data_dir().AppendASCII("permissions");
base::FilePath pem_path = path
.AppendASCII("whitelist.pem");
path = path
const Extension* extension = PackAndInstallCRX(path, pem_path, INSTALL_NEW);
EXPECT_EQ(0u, GetErrors().size());
- ASSERT_EQ(1u, registry_->enabled_extensions().size());
+ ASSERT_EQ(1u, registry()->enabled_extensions().size());
EXPECT_EQ(test_id, extension->id());
}
// All tests use a single extension. Put the id and path in member vars
// that all methods can read.
crx_id_ = kGoodId;
- crx_path_ = data_dir_.AppendASCII("good.crx");
+ crx_path_ = data_dir().AppendASCII("good.crx");
}
// Fake an external source adding a URL to fetch an extension from.
bool AddPendingExternalPrefUrl() {
- return service_->pending_extension_manager()->AddFromExternalUpdateUrl(
- crx_id_, GURL(), Manifest::EXTERNAL_PREF_DOWNLOAD,
- Extension::NO_FLAGS, false);
+ return service()->pending_extension_manager()->AddFromExternalUpdateUrl(
+ crx_id_,
+ std::string(),
+ GURL(),
+ Manifest::EXTERNAL_PREF_DOWNLOAD,
+ Extension::NO_FLAGS,
+ false);
}
// Fake an external file from external_extensions.json.
bool AddPendingExternalPrefFileInstall() {
Version version("1.0.0.0");
- return service_->OnExternalExtensionFileFound(
- crx_id_, &version, crx_path_, Manifest::EXTERNAL_PREF,
- Extension::NO_FLAGS, false);
+ return service()->OnExternalExtensionFileFound(crx_id_,
+ &version,
+ crx_path_,
+ Manifest::EXTERNAL_PREF,
+ Extension::NO_FLAGS,
+ false);
}
// Fake a request from sync to install an extension.
bool AddPendingSyncInstall() {
- return service_->pending_extension_manager()->AddFromSync(
- crx_id_, GURL(kGoodUpdateURL), &IsExtension, kGoodInstallSilently);
+ return service()->pending_extension_manager()->AddFromSync(
+ crx_id_,
+ GURL(kGoodUpdateURL),
+ &IsExtension,
+ kGoodInstallSilently,
+ kGoodRemoteInstall,
+ kGoodInstalledByCustodian);
}
// Fake a policy install.
bool AddPendingPolicyInstall() {
// Get path to the CRX with id |kGoodId|.
- return service_->OnExternalExtensionUpdateUrlFound(
- crx_id_, GURL(), Manifest::EXTERNAL_POLICY_DOWNLOAD,
- Extension::NO_FLAGS, false);
+ return service()->OnExternalExtensionUpdateUrlFound(
+ crx_id_,
+ std::string(),
+ GURL(),
+ Manifest::EXTERNAL_POLICY_DOWNLOAD,
+ Extension::NO_FLAGS,
+ false);
}
// Get the install source of a pending extension.
Manifest::Location GetPendingLocation() {
const extensions::PendingExtensionInfo* info;
- EXPECT_TRUE((info = service_->pending_extension_manager()->
- GetById(crx_id_)));
+ EXPECT_TRUE(
+ (info = service()->pending_extension_manager()->GetById(crx_id_)));
return info->install_source();
}
// Is an extension pending from a sync request?
bool GetPendingIsFromSync() {
const extensions::PendingExtensionInfo* info;
- EXPECT_TRUE((info = service_->pending_extension_manager()->
- GetById(crx_id_)));
+ EXPECT_TRUE(
+ (info = service()->pending_extension_manager()->GetById(crx_id_)));
return info->is_from_sync();
}
// Is the CRX id these tests use pending?
bool IsCrxPending() {
- return service_->pending_extension_manager()->IsIdPending(crx_id_);
+ return service()->pending_extension_manager()->IsIdPending(crx_id_);
}
// Is an extension installed?
bool IsCrxInstalled() {
- return (service_->GetExtensionById(crx_id_, true) != NULL);
+ return (service()->GetExtensionById(crx_id_, true) != NULL);
}
protected:
// Install pending extension from sync.
content::WindowedNotificationObserver observer(
- chrome::NOTIFICATION_CRX_INSTALLER_DONE,
+ extensions::NOTIFICATION_CRX_INSTALLER_DONE,
content::NotificationService::AllSources());
EXPECT_TRUE(AddPendingSyncInstall());
ASSERT_EQ(Manifest::INTERNAL, GetPendingLocation());
// Before the CRX installer runs, Sync requests that the same extension
// be installed. Should fail, because an external source is pending.
content::WindowedNotificationObserver observer(
- chrome::NOTIFICATION_CRX_INSTALLER_DONE,
+ extensions::NOTIFICATION_CRX_INSTALLER_DONE,
content::NotificationService::AllSources());
ASSERT_FALSE(AddPendingSyncInstall());
InitializeEmptyExtensionService();
MockExtensionProvider* provider =
- new MockExtensionProvider(service_, Manifest::EXTERNAL_PREF);
+ new MockExtensionProvider(service(), Manifest::EXTERNAL_PREF);
AddMockExternalProvider(provider);
- service_->UpdateExternalExtensionAlert();
+ service()->external_install_manager()->UpdateExternalExtensionAlert();
// Should return false, meaning there aren't any extensions that the user
// needs to know about.
- EXPECT_FALSE(extensions::HasExternalInstallError(service_));
+ EXPECT_FALSE(
+ service()->external_install_manager()->HasExternalInstallError());
// This is a normal extension, installed normally.
// This should NOT trigger an alert.
- set_extensions_enabled(true);
- base::FilePath path = data_dir_.AppendASCII("good.crx");
+ service()->set_extensions_enabled(true);
+ base::FilePath path = data_dir().AppendASCII("good.crx");
InstallCRX(path, INSTALL_NEW);
- service_->CheckForExternalUpdates();
+ service()->CheckForExternalUpdates();
base::RunLoop().RunUntilIdle();
- EXPECT_FALSE(extensions::HasExternalInstallError(service_));
+ EXPECT_FALSE(
+ service()->external_install_manager()->HasExternalInstallError());
// A hosted app, installed externally.
// This should NOT trigger an alert.
- provider->UpdateOrAddExtension(hosted_app, "1.0.0.0",
- data_dir_.AppendASCII("hosted_app.crx"));
+ provider->UpdateOrAddExtension(
+ hosted_app, "1.0.0.0", data_dir().AppendASCII("hosted_app.crx"));
content::WindowedNotificationObserver observer(
- chrome::NOTIFICATION_CRX_INSTALLER_DONE,
+ extensions::NOTIFICATION_CRX_INSTALLER_DONE,
content::NotificationService::AllSources());
- service_->CheckForExternalUpdates();
+ service()->CheckForExternalUpdates();
observer.Wait();
- EXPECT_FALSE(extensions::HasExternalInstallError(service_));
+ EXPECT_FALSE(
+ service()->external_install_manager()->HasExternalInstallError());
// Another normal extension, but installed externally.
// This SHOULD trigger an alert.
- provider->UpdateOrAddExtension(page_action, "1.0.0.0",
- data_dir_.AppendASCII("page_action.crx"));
+ provider->UpdateOrAddExtension(
+ page_action, "1.0.0.0", data_dir().AppendASCII("page_action.crx"));
content::WindowedNotificationObserver observer2(
- chrome::NOTIFICATION_CRX_INSTALLER_DONE,
+ extensions::NOTIFICATION_CRX_INSTALLER_DONE,
content::NotificationService::AllSources());
- service_->CheckForExternalUpdates();
+ service()->CheckForExternalUpdates();
observer2.Wait();
- EXPECT_TRUE(extensions::HasExternalInstallError(service_));
+ EXPECT_TRUE(service()->external_install_manager()->HasExternalInstallError());
}
// Test that external extensions are initially disabled, and that enabling
InitializeEmptyExtensionService();
MockExtensionProvider* provider =
- new MockExtensionProvider(service_, Manifest::EXTERNAL_PREF);
+ new MockExtensionProvider(service(), Manifest::EXTERNAL_PREF);
AddMockExternalProvider(provider);
- provider->UpdateOrAddExtension(page_action, "1.0.0.0",
- data_dir_.AppendASCII("page_action.crx"));
+ provider->UpdateOrAddExtension(
+ page_action, "1.0.0.0", data_dir().AppendASCII("page_action.crx"));
content::WindowedNotificationObserver observer(
- chrome::NOTIFICATION_CRX_INSTALLER_DONE,
+ extensions::NOTIFICATION_CRX_INSTALLER_DONE,
content::NotificationService::AllSources());
- service_->CheckForExternalUpdates();
+ service()->CheckForExternalUpdates();
observer.Wait();
- EXPECT_TRUE(extensions::HasExternalInstallError(service_));
- EXPECT_FALSE(service_->IsExtensionEnabled(page_action));
+ EXPECT_TRUE(service()->external_install_manager()->HasExternalInstallError());
+ EXPECT_FALSE(service()->IsExtensionEnabled(page_action));
const Extension* extension =
- registry_->disabled_extensions().GetByID(page_action);
+ registry()->disabled_extensions().GetByID(page_action);
EXPECT_TRUE(extension);
EXPECT_EQ(page_action, extension->id());
- service_->EnableExtension(page_action);
- EXPECT_FALSE(extensions::HasExternalInstallError(service_));
- EXPECT_TRUE(service_->IsExtensionEnabled(page_action));
+ service()->EnableExtension(page_action);
+ EXPECT_FALSE(
+ service()->external_install_manager()->HasExternalInstallError());
+ EXPECT_TRUE(service()->IsExtensionEnabled(page_action));
}
// Test that installing multiple external extensions works.
InitializeEmptyExtensionService();
MockExtensionProvider* provider =
- new MockExtensionProvider(service_, Manifest::EXTERNAL_PREF);
+ new MockExtensionProvider(service(), Manifest::EXTERNAL_PREF);
AddMockExternalProvider(provider);
- provider->UpdateOrAddExtension(page_action, "1.0.0.0",
- data_dir_.AppendASCII("page_action.crx"));
- provider->UpdateOrAddExtension(good_crx, "1.0.0.0",
- data_dir_.AppendASCII("good.crx"));
- provider->UpdateOrAddExtension(theme_crx, "2.0",
- data_dir_.AppendASCII("theme.crx"));
+ provider->UpdateOrAddExtension(
+ page_action, "1.0.0.0", data_dir().AppendASCII("page_action.crx"));
+ provider->UpdateOrAddExtension(
+ good_crx, "1.0.0.0", data_dir().AppendASCII("good.crx"));
+ provider->UpdateOrAddExtension(
+ theme_crx, "2.0", data_dir().AppendASCII("theme.crx"));
int count = 3;
content::WindowedNotificationObserver observer(
- chrome::NOTIFICATION_CRX_INSTALLER_DONE,
+ extensions::NOTIFICATION_CRX_INSTALLER_DONE,
base::Bind(&WaitForCountNotificationsCallback, &count));
- service_->CheckForExternalUpdates();
+ service()->CheckForExternalUpdates();
observer.Wait();
- EXPECT_TRUE(extensions::HasExternalInstallError(service_));
- EXPECT_FALSE(service_->IsExtensionEnabled(page_action));
- EXPECT_FALSE(service_->IsExtensionEnabled(good_crx));
- EXPECT_FALSE(service_->IsExtensionEnabled(theme_crx));
-
- service_->EnableExtension(page_action);
- EXPECT_TRUE(extensions::HasExternalInstallError(service_));
- EXPECT_FALSE(extensions::HasExternalInstallBubble(service_));
- service_->EnableExtension(theme_crx);
- EXPECT_TRUE(extensions::HasExternalInstallError(service_));
- EXPECT_FALSE(extensions::HasExternalInstallBubble(service_));
- service_->EnableExtension(good_crx);
- EXPECT_FALSE(extensions::HasExternalInstallError(service_));
- EXPECT_FALSE(extensions::HasExternalInstallBubble(service_));
+ EXPECT_TRUE(service()->external_install_manager()->HasExternalInstallError());
+ EXPECT_FALSE(service()->IsExtensionEnabled(page_action));
+ EXPECT_FALSE(service()->IsExtensionEnabled(good_crx));
+ EXPECT_FALSE(service()->IsExtensionEnabled(theme_crx));
+
+ service()->EnableExtension(page_action);
+ EXPECT_TRUE(service()->external_install_manager()->HasExternalInstallError());
+ EXPECT_FALSE(service()
+ ->external_install_manager()
+ ->HasExternalInstallBubbleForTesting());
+
+ service()->EnableExtension(theme_crx);
+ EXPECT_TRUE(service()->external_install_manager()->HasExternalInstallError());
+ EXPECT_FALSE(service()
+ ->external_install_manager()
+ ->HasExternalInstallBubbleForTesting());
+
+ service()->EnableExtension(good_crx);
+ EXPECT_FALSE(
+ service()->external_install_manager()->HasExternalInstallError());
+ EXPECT_FALSE(service()
+ ->external_install_manager()
+ ->HasExternalInstallBubbleForTesting());
}
// Test that there is a bubble for external extensions that update
params.is_first_run = false;
InitializeExtensionService(params);
- base::FilePath crx_path = temp_dir_.path().AppendASCII("webstore.crx");
- PackCRX(data_dir_.AppendASCII("update_from_webstore"),
- data_dir_.AppendASCII("update_from_webstore.pem"),
+ base::FilePath crx_path = temp_dir().path().AppendASCII("webstore.crx");
+ PackCRX(data_dir().AppendASCII("update_from_webstore"),
+ data_dir().AppendASCII("update_from_webstore.pem"),
crx_path);
MockExtensionProvider* provider =
- new MockExtensionProvider(service_, Manifest::EXTERNAL_PREF);
+ new MockExtensionProvider(service(), Manifest::EXTERNAL_PREF);
AddMockExternalProvider(provider);
provider->UpdateOrAddExtension(updates_from_webstore, "1", crx_path);
content::WindowedNotificationObserver observer(
- chrome::NOTIFICATION_CRX_INSTALLER_DONE,
+ extensions::NOTIFICATION_CRX_INSTALLER_DONE,
content::NotificationService::AllSources());
- service_->CheckForExternalUpdates();
+ service()->CheckForExternalUpdates();
observer.Wait();
- EXPECT_TRUE(extensions::HasExternalInstallError(service_));
- EXPECT_TRUE(extensions::HasExternalInstallBubble(service_));
- EXPECT_FALSE(service_->IsExtensionEnabled(updates_from_webstore));
+ EXPECT_TRUE(service()->external_install_manager()->HasExternalInstallError());
+ EXPECT_TRUE(service()
+ ->external_install_manager()
+ ->HasExternalInstallBubbleForTesting());
+ EXPECT_FALSE(service()->IsExtensionEnabled(updates_from_webstore));
}
// Test that there is no bubble for external extensions if the profile is new.
InitializeEmptyExtensionService();
- base::FilePath crx_path = temp_dir_.path().AppendASCII("webstore.crx");
- PackCRX(data_dir_.AppendASCII("update_from_webstore"),
- data_dir_.AppendASCII("update_from_webstore.pem"),
+ base::FilePath crx_path = temp_dir().path().AppendASCII("webstore.crx");
+ PackCRX(data_dir().AppendASCII("update_from_webstore"),
+ data_dir().AppendASCII("update_from_webstore.pem"),
+ crx_path);
+
+ MockExtensionProvider* provider =
+ new MockExtensionProvider(service(), Manifest::EXTERNAL_PREF);
+ AddMockExternalProvider(provider);
+ provider->UpdateOrAddExtension(updates_from_webstore, "1", crx_path);
+
+ content::WindowedNotificationObserver observer(
+ extensions::NOTIFICATION_CRX_INSTALLER_DONE,
+ content::NotificationService::AllSources());
+ service()->CheckForExternalUpdates();
+ observer.Wait();
+ EXPECT_TRUE(service()->external_install_manager()->HasExternalInstallError());
+ EXPECT_FALSE(service()
+ ->external_install_manager()
+ ->HasExternalInstallBubbleForTesting());
+ EXPECT_FALSE(service()->IsExtensionEnabled(updates_from_webstore));
+}
+
+// Test that clicking to remove the extension on an external install warning
+// uninstalls the extension.
+TEST_F(ExtensionServiceTest, ExternalInstallClickToRemove) {
+ FeatureSwitch::ScopedOverride prompt(
+ FeatureSwitch::prompt_for_external_extensions(), true);
+
+ ExtensionServiceInitParams params = CreateDefaultInitParams();
+ params.is_first_run = false;
+ InitializeExtensionService(params);
+
+ base::FilePath crx_path = temp_dir().path().AppendASCII("webstore.crx");
+ PackCRX(data_dir().AppendASCII("update_from_webstore"),
+ data_dir().AppendASCII("update_from_webstore.pem"),
+ crx_path);
+
+ MockExtensionProvider* provider =
+ new MockExtensionProvider(service_, Manifest::EXTERNAL_PREF);
+ AddMockExternalProvider(provider);
+ provider->UpdateOrAddExtension(updates_from_webstore, "1", crx_path);
+
+ content::WindowedNotificationObserver observer(
+ extensions::NOTIFICATION_CRX_INSTALLER_DONE,
+ content::NotificationService::AllSources());
+ service_->CheckForExternalUpdates();
+ observer.Wait();
+ EXPECT_TRUE(service_->external_install_manager()->HasExternalInstallError());
+
+ // We check both enabled and disabled, since these are "eventually exclusive"
+ // sets.
+ EXPECT_TRUE(registry()->disabled_extensions().GetByID(updates_from_webstore));
+ EXPECT_FALSE(registry()->enabled_extensions().GetByID(updates_from_webstore));
+
+ // Click the negative response.
+ service_->external_install_manager()->error_for_testing()->InstallUIAbort(
+ true);
+ // The Extension should be uninstalled.
+ EXPECT_FALSE(registry()->GetExtensionById(updates_from_webstore,
+ ExtensionRegistry::EVERYTHING));
+ // The error should be removed.
+ EXPECT_FALSE(service_->external_install_manager()->HasExternalInstallError());
+}
+
+// Test that clicking to keep the extension on an external install warning
+// re-enables the extension.
+TEST_F(ExtensionServiceTest, ExternalInstallClickToKeep) {
+ FeatureSwitch::ScopedOverride prompt(
+ FeatureSwitch::prompt_for_external_extensions(), true);
+
+ ExtensionServiceInitParams params = CreateDefaultInitParams();
+ params.is_first_run = false;
+ InitializeExtensionService(params);
+
+ base::FilePath crx_path = temp_dir().path().AppendASCII("webstore.crx");
+ PackCRX(data_dir().AppendASCII("update_from_webstore"),
+ data_dir().AppendASCII("update_from_webstore.pem"),
crx_path);
MockExtensionProvider* provider =
provider->UpdateOrAddExtension(updates_from_webstore, "1", crx_path);
content::WindowedNotificationObserver observer(
- chrome::NOTIFICATION_CRX_INSTALLER_DONE,
+ extensions::NOTIFICATION_CRX_INSTALLER_DONE,
content::NotificationService::AllSources());
service_->CheckForExternalUpdates();
observer.Wait();
- EXPECT_TRUE(extensions::HasExternalInstallError(service_));
- EXPECT_FALSE(extensions::HasExternalInstallBubble(service_));
- EXPECT_FALSE(service_->IsExtensionEnabled(updates_from_webstore));
+ EXPECT_TRUE(service_->external_install_manager()->HasExternalInstallError());
+
+ // We check both enabled and disabled, since these are "eventually exclusive"
+ // sets.
+ EXPECT_TRUE(registry()->disabled_extensions().GetByID(updates_from_webstore));
+ EXPECT_FALSE(registry()->enabled_extensions().GetByID(updates_from_webstore));
+
+ // Accept the extension.
+ service_->external_install_manager()->error_for_testing()->InstallUIProceed();
+
+ // It should be enabled again.
+ EXPECT_TRUE(registry()->enabled_extensions().GetByID(updates_from_webstore));
+ EXPECT_FALSE(
+ registry()->disabled_extensions().GetByID(updates_from_webstore));
+
+ // The error should be removed.
+ EXPECT_FALSE(service_->external_install_manager()->HasExternalInstallError());
}
TEST_F(ExtensionServiceTest, InstallBlacklistedExtension) {
// Installation should be allowed but the extension should never have been
// loaded and it should be blacklisted in prefs.
- service_->OnExtensionInstalled(
+ service()->OnExtensionInstalled(
extension.get(),
syncer::StringOrdinal(),
- false /* has requirement errors */,
- extensions::BLACKLISTED_MALWARE,
- false /* wait for idle */);
+ (extensions::kInstallFlagIsBlacklistedForMalware |
+ extensions::kInstallFlagInstallImmediately));
base::RunLoop().RunUntilIdle();
// Extension was installed but not loaded.
EXPECT_TRUE(notifications.CheckNotifications(
- chrome::NOTIFICATION_EXTENSION_INSTALLED));
- EXPECT_TRUE(service_->GetInstalledExtension(id));
+ extensions::NOTIFICATION_EXTENSION_WILL_BE_INSTALLED_DEPRECATED));
+ EXPECT_TRUE(service()->GetInstalledExtension(id));
- EXPECT_FALSE(registry_->enabled_extensions().Contains(id));
- EXPECT_TRUE(registry_->blacklisted_extensions().Contains(id));
+ EXPECT_FALSE(registry()->enabled_extensions().Contains(id));
+ EXPECT_TRUE(registry()->blacklisted_extensions().Contains(id));
- EXPECT_TRUE(service_->extension_prefs()->IsExtensionBlacklisted(id));
+ EXPECT_TRUE(ExtensionPrefs::Get(profile())->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
- // disabled.
- service_->Init();
-
- extensions::ExtensionIdSet expected_extensions;
- expected_extensions.insert(good0);
- expected_extensions.insert(good1);
- expected_extensions.insert(good2);
-
- extensions::ExtensionIdSet expected_disabled_extensions;
-
- EXPECT_EQ(expected_extensions, registry_->enabled_extensions().GetIDs());
- EXPECT_EQ(expected_disabled_extensions,
- registry_->disabled_extensions().GetIDs());
+ ExtensionPrefs::Get(profile())->IsBlacklistedExtensionAcknowledged(id));
}
-TEST_F(ExtensionServiceTest, ReconcileKnownDisabledWithSideEnable) {
- // A profile with 3 extensions installed: good0, good1, and good2.
- InitializeGoodInstalledExtensionService();
-
- ExtensionPrefs* extension_prefs = service_->extension_prefs();
-
- // Disable good1.
- extension_prefs->SetExtensionState(good1, Extension::DISABLED);
-
- // Mark both good1 and good2 as "known_disabled" (effectively making good2
- // look as if it had been side-enabled).
- extensions::ExtensionIdSet known_disabled;
- known_disabled.insert(good1);
- known_disabled.insert(good2);
- extension_prefs->SetKnownDisabled(known_disabled);
-
- // Initialize the service (which should disable good2 since it's known to be
- // disabled).
- service_->Init();
-
- extensions::ExtensionIdSet expected_extensions;
- expected_extensions.insert(good0);
-
- extensions::ExtensionIdSet expected_disabled_extensions;
- expected_disabled_extensions.insert(good1);
- expected_disabled_extensions.insert(good2);
-
- EXPECT_EQ(expected_extensions, registry_->enabled_extensions().GetIDs());
- EXPECT_EQ(expected_disabled_extensions,
- registry_->disabled_extensions().GetIDs());
-
- // Make sure that re-enabling an extension sticks across calls to
- // ReconcileKnownDisabled().
- service_->EnableExtension(good2);
- service_->ReconcileKnownDisabled();
- expected_extensions.insert(good2);
- expected_disabled_extensions.erase(good2);
+// Tests a profile being destroyed correctly disables extensions.
+TEST_F(ExtensionServiceTest, DestroyingProfileClearsExtensions) {
+ InitializeEmptyExtensionService();
- EXPECT_EQ(expected_extensions, registry_->enabled_extensions().GetIDs());
- EXPECT_EQ(expected_disabled_extensions,
- registry_->disabled_extensions().GetIDs());
+ InstallCRX(data_dir().AppendASCII("good.crx"), INSTALL_NEW);
+ EXPECT_NE(UnloadedExtensionInfo::REASON_PROFILE_SHUTDOWN, unloaded_reason_);
+ 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());
+
+ service()->Observe(chrome::NOTIFICATION_PROFILE_DESTRUCTION_STARTED,
+ content::Source<Profile>(profile()),
+ content::NotificationService::NoDetails());
+ EXPECT_EQ(UnloadedExtensionInfo::REASON_PROFILE_SHUTDOWN, unloaded_reason_);
+ EXPECT_EQ(0u, 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());
}
projects / platform / framework / web / crosswalk.git / blobdiff