Rename ExtensionsService to ExtensionService.

chrome/browser/extensions/extension_service_unittest.cc

 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "chrome/browser/extensions/extensions_service_unittest.h"
+#include "chrome/browser/extensions/extension_service_unittest.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/scoped_ptr.h"
 #include "base/stl_util-inl.h"
 #include "base/string16.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/task.h"
 #include "base/utf_string_conversions.h"
 #include "base/version.h"
 #include "chrome/browser/appcache/chrome_appcache_service.h"
 #include "chrome/browser/browser_thread.h"
 #include "chrome/browser/extensions/crx_installer.h"
 #include "chrome/browser/extensions/extension_creator.h"
 #include "chrome/browser/extensions/extension_error_reporter.h"
-#include "chrome/browser/extensions/extensions_service.h"
+#include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/external_extension_provider.h"
 #include "chrome/browser/extensions/external_pref_extension_provider.h"
 #include "chrome/browser/extensions/pack_extension_job.cc"
 #include "chrome/browser/file_system/browser_file_system_helper.h"
 #include "chrome/browser/in_process_webkit/dom_storage_context.h"
 #include "chrome/browser/in_process_webkit/webkit_context.h"
 #include "chrome/browser/prefs/browser_prefs.h"
 #include "chrome/browser/prefs/pref_service_mock_builder.h"
 #include "chrome/browser/prefs/scoped_pref_update.h"
 #include "chrome/common/chrome_paths.h"
@@ skipping 251 matching lines @@
   scoped_ptr<DictionaryValue> prefs_;
 
   DISALLOW_COPY_AND_ASSIGN(MockProviderVisitor);
 };
 
 class ExtensionTestingProfile : public TestingProfile {
  public:
   ExtensionTestingProfile() : service_(NULL) {
   }
 
-  void set_extensions_service(ExtensionsService* service) {
+  void set_extensions_service(ExtensionService* service) {
     service_ = service;
   }
-  virtual ExtensionsService* GetExtensionsService() { return service_; }
+  virtual ExtensionService* GetExtensionService() { return service_; }
 
   virtual ChromeAppCacheService* GetAppCacheService() {
     if (!appcache_service_) {
       appcache_service_ = new ChromeAppCacheService;
       BrowserThread::PostTask(
           BrowserThread::IO, FROM_HERE,
           NewRunnableMethod(appcache_service_.get(),
                             &ChromeAppCacheService::InitializeOnIOThread,
                             GetPath(), IsOffTheRecord(),
                             make_scoped_refptr(GetHostContentSettingsMap())));
     }
     return appcache_service_;
   }
 
   virtual fileapi::SandboxedFileSystemContext* GetFileSystemContext() {
     if (!file_system_context_)
       file_system_context_ = CreateFileSystemContext(
           GetPath(), IsOffTheRecord());
     return file_system_context_;
   }
 
  private:
-  ExtensionsService* service_;
+  ExtensionService* service_;
   scoped_refptr<ChromeAppCacheService> appcache_service_;
   scoped_refptr<fileapi::SandboxedFileSystemContext> file_system_context_;
 };
 
 // Our message loop may be used in tests which require it to be an IO loop.
-ExtensionsServiceTestBase::ExtensionsServiceTestBase()
+ExtensionServiceTestBase::ExtensionServiceTestBase()
     : total_successes_(0),
       loop_(MessageLoop::TYPE_IO),
       ui_thread_(BrowserThread::UI, &loop_),
       db_thread_(BrowserThread::DB, &loop_),
       webkit_thread_(BrowserThread::WEBKIT, &loop_),
       file_thread_(BrowserThread::FILE, &loop_),
       io_thread_(BrowserThread::IO, &loop_) {
 }
 
-ExtensionsServiceTestBase::~ExtensionsServiceTestBase() {
-  // Drop our reference to ExtensionsService and TestingProfile, so that they
+ExtensionServiceTestBase::~ExtensionServiceTestBase() {
+  // Drop our reference to ExtensionService and TestingProfile, so that they
   // can be destroyed while BrowserThreads and MessageLoop are still around
   // (they are used in the destruction process).
   service_ = NULL;
   profile_.reset(NULL);
   MessageLoop::current()->RunAllPending();
 }
 
-void ExtensionsServiceTestBase::InitializeExtensionsService(
+void ExtensionServiceTestBase::InitializeExtensionService(
     const FilePath& pref_file, const FilePath& extensions_install_dir) {
   ExtensionTestingProfile* profile = new ExtensionTestingProfile();
   // Create a PrefService that only contains user defined preference values.
   PrefService* prefs =
       PrefServiceMockBuilder().WithUserFilePrefs(pref_file).Create();
   Profile::RegisterUserPrefs(prefs);
   browser::RegisterUserPrefs(prefs);
   profile->SetPrefService(prefs);
 
   profile_.reset(profile);
 
-  service_ = profile->CreateExtensionsService(
+  service_ = profile->CreateExtensionService(
       CommandLine::ForCurrentProcess(),
       extensions_install_dir);
   service_->set_extensions_enabled(true);
   service_->set_show_extensions_prompts(false);
   profile->set_extensions_service(service_.get());
 
   // 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();
 
   total_successes_ = 0;
 }
 
-void ExtensionsServiceTestBase::InitializeInstalledExtensionsService(
+void ExtensionServiceTestBase::InitializeInstalledExtensionService(
     const FilePath& prefs_file, const FilePath& source_install_dir) {
   ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
   FilePath path_ = temp_dir_.path();
   path_ = path_.Append(FILE_PATH_LITERAL("TestingExtensionsPath"));
   file_util::Delete(path_, true);
   file_util::CreateDirectory(path_);
   FilePath temp_prefs = path_.Append(FILE_PATH_LITERAL("Preferences"));
   file_util::CopyFile(prefs_file, temp_prefs);
 
   extensions_install_dir_ = path_.Append(FILE_PATH_LITERAL("Extensions"));
   file_util::Delete(extensions_install_dir_, true);
   file_util::CopyDirectory(source_install_dir, extensions_install_dir_, true);
 
-  InitializeExtensionsService(temp_prefs, extensions_install_dir_);
+  InitializeExtensionService(temp_prefs, extensions_install_dir_);
 }
 
-void ExtensionsServiceTestBase::InitializeEmptyExtensionsService() {
+void ExtensionServiceTestBase::InitializeEmptyExtensionService() {
   ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
   FilePath path_ = temp_dir_.path();
   path_ = path_.Append(FILE_PATH_LITERAL("TestingExtensionsPath"));
   file_util::Delete(path_, true);
   file_util::CreateDirectory(path_);
   FilePath prefs_filename = path_
       .Append(FILE_PATH_LITERAL("TestPreferences"));
   extensions_install_dir_ = path_.Append(FILE_PATH_LITERAL("Extensions"));
   file_util::Delete(extensions_install_dir_, true);
   file_util::CreateDirectory(extensions_install_dir_);
 
-  InitializeExtensionsService(prefs_filename, extensions_install_dir_);
+  InitializeExtensionService(prefs_filename, extensions_install_dir_);
 }
 
 // static
-void ExtensionsServiceTestBase::SetUpTestCase() {
+void ExtensionServiceTestBase::SetUpTestCase() {
   ExtensionErrorReporter::Init(false);  // no noisy errors
 }
 
-void ExtensionsServiceTestBase::SetUp() {
+void ExtensionServiceTestBase::SetUp() {
   ExtensionErrorReporter::GetInstance()->ClearErrors();
 }
 
-class ExtensionsServiceTest
-  : public ExtensionsServiceTestBase, public NotificationObserver {
+class ExtensionServiceTest
+  : public ExtensionServiceTestBase, public NotificationObserver {
  public:
-  ExtensionsServiceTest() : installed_(NULL) {
+  ExtensionServiceTest() : installed_(NULL) {
     registrar_.Add(this, NotificationType::EXTENSION_LOADED,
                    NotificationService::AllSources());
     registrar_.Add(this, NotificationType::EXTENSION_UNLOADED,
                    NotificationService::AllSources());
     registrar_.Add(this, NotificationType::EXTENSION_INSTALLED,
                    NotificationService::AllSources());
     registrar_.Add(this, NotificationType::THEME_INSTALLED,
                    NotificationService::AllSources());
   }
 
@@ skipping 373 matching lines @@
   EXPECT_EQ(expected_private_key_path_.value(), private_key_path.value());
   ASSERT_TRUE(file_util::PathExists(private_key_path));
 }
 
 // The tests are designed so that we never expect to see a packing error.
 void PackExtensionTestClient::OnPackFailure(const std::string& error_message) {
   FAIL() << "Packing should not fail.";
 }
 
 // Test loading good extensions from the profile directory.
-TEST_F(ExtensionsServiceTest, LoadAllExtensionsFromDirectorySuccess) {
+TEST_F(ExtensionServiceTest, LoadAllExtensionsFromDirectorySuccess) {
   // Initialize the test dir with a good Preferences/extensions.
   FilePath source_install_dir;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &source_install_dir));
   source_install_dir = source_install_dir
       .AppendASCII("extensions")
       .AppendASCII("good")
       .AppendASCII("Extensions");
   FilePath pref_path = source_install_dir
       .DirName()
       .AppendASCII("Preferences");
-  InitializeInstalledExtensionsService(pref_path, source_install_dir);
+  InitializeInstalledExtensionService(pref_path, source_install_dir);
 
   service_->Init();
 
   // On Chrome OS, we disallow extensions with plugins.  "good1" has plugins,
   // so we need to edit it out here.
   uint32 expected_num_extensions = 3u;
 #if defined(OS_CHROMEOS)
   --expected_num_extensions;
 #endif
   ASSERT_EQ(expected_num_extensions, loaded_.size());
@@ skipping 72 matching lines @@
 
   int index = expected_num_extensions - 1;
   EXPECT_EQ(std::string(good2), loaded_[index]->id());
   EXPECT_EQ(std::string("My extension 3"), loaded_[index]->name());
   EXPECT_EQ(std::string(""), loaded_[index]->description());
   EXPECT_EQ(0u, loaded_[index]->content_scripts().size());
   EXPECT_EQ(Extension::INTERNAL, loaded_[index]->location());
 };
 
 // Test loading bad extensions from the profile directory.
-TEST_F(ExtensionsServiceTest, LoadAllExtensionsFromDirectoryFail) {
+TEST_F(ExtensionServiceTest, LoadAllExtensionsFromDirectoryFail) {
   // Initialize the test dir with a bad Preferences/extensions.
   FilePath source_install_dir;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &source_install_dir));
   source_install_dir = source_install_dir
       .AppendASCII("extensions")
       .AppendASCII("bad")
       .AppendASCII("Extensions");
   FilePath pref_path = source_install_dir
       .DirName()
       .AppendASCII("Preferences");
 
-  InitializeInstalledExtensionsService(pref_path, source_install_dir);
+  InitializeInstalledExtensionService(pref_path, source_install_dir);
 
   service_->Init();
   loop_.RunAllPending();
 
   ASSERT_EQ(4u, GetErrors().size());
   ASSERT_EQ(0u, loaded_.size());
 
   EXPECT_TRUE(MatchPattern(GetErrors()[0],
       std::string("Could not load extension from '*'. ") +
       extension_manifest_errors::kManifestUnreadable)) << GetErrors()[0];
 
   EXPECT_TRUE(MatchPattern(GetErrors()[1],
       std::string("Could not load extension from '*'. ") +
       extension_manifest_errors::kManifestUnreadable)) << GetErrors()[1];
 
   EXPECT_TRUE(MatchPattern(GetErrors()[2],
       std::string("Could not load extension from '*'. ") +
       extension_manifest_errors::kMissingFile)) << GetErrors()[2];
 
   EXPECT_TRUE(MatchPattern(GetErrors()[3],
       std::string("Could not load extension from '*'. ") +
       extension_manifest_errors::kManifestUnreadable)) << GetErrors()[3];
 };
 
 // Test that partially deleted extensions are cleaned up during startup
 // Test loading bad extensions from the profile directory.
-TEST_F(ExtensionsServiceTest, CleanupOnStartup) {
+TEST_F(ExtensionServiceTest, CleanupOnStartup) {
   FilePath source_install_dir;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &source_install_dir));
   source_install_dir = source_install_dir
       .AppendASCII("extensions")
       .AppendASCII("good")
       .AppendASCII("Extensions");
   FilePath pref_path = source_install_dir
       .DirName()
       .AppendASCII("Preferences");
 
-  InitializeInstalledExtensionsService(pref_path, source_install_dir);
+  InitializeInstalledExtensionService(pref_path, source_install_dir);
 
   // Simulate that one of them got partially deleted by clearing its pref.
   DictionaryValue* dict =
       profile_->GetPrefs()->GetMutableDictionary("extensions.settings");
   ASSERT_TRUE(dict != NULL);
   dict->Remove("behllobkkfkfnphdnhnkndlbkcpglgmj", NULL);
 
   service_->Init();
   loop_.RunAllPending();
 
   file_util::FileEnumerator dirs(extensions_install_dir_, false,
                                  file_util::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.
   FilePath extension_dir = extensions_install_dir_
       .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj");
   ASSERT_FALSE(file_util::PathExists(extension_dir));
 }
 
 // Test installing extensions. This test tries to install few extensions using
 // crx files. If you need to change those crx files, feel free to repackage
 // them, throw away the key used and change the id's above.
-TEST_F(ExtensionsServiceTest, InstallExtension) {
-  InitializeEmptyExtensionsService();
+TEST_F(ExtensionServiceTest, InstallExtension) {
+  InitializeEmptyExtensionService();
 
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
 
   // Extensions not enabled.
   set_extensions_enabled(false);
   FilePath path = extensions_path.AppendASCII("good.crx");
   InstallExtension(path, false);
   set_extensions_enabled(true);
@@ skipping 38 matching lines @@
   // We did not used to handle this correctly for installation.
   path = extensions_path.AppendASCII("bad_underscore.crx");
   InstallExtension(path, false);
   ValidatePrefKeyCount(pref_count);
 
   // TODO(erikkay): add more tests for many of the failure cases.
   // TODO(erikkay): add tests for upgrade cases.
 }
 
 // Test the handling of killed extensions.
-TEST_F(ExtensionsServiceTest, KilledExtensions) {
-  InitializeEmptyExtensionsService();
+TEST_F(ExtensionServiceTest, KilledExtensions) {
+  InitializeEmptyExtensionService();
 
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
   FilePath path = extensions_path.AppendASCII("good.crx");
   set_extensions_enabled(true);
 
   // Install an external extension.
   service_->OnExternalExtensionFileFound(good_crx, "1.0.0.0",
                                          path, Extension::EXTERNAL_PREF);
@@ skipping 24 matching lines @@
   service_->AddPendingExtensionFromExternalUpdateUrl(
       good_crx,
       GURL("http:://fake.update/url"),
       Extension::EXTERNAL_PREF_DOWNLOAD);
   const PendingExtensionMap& pending_extensions =
       service_->pending_extensions();
   ASSERT_TRUE(pending_extensions.find(good_crx) == pending_extensions.end());
 }
 
 // Install a user script (they get converted automatically to an extension)
-TEST_F(ExtensionsServiceTest, InstallUserScript) {
+TEST_F(ExtensionServiceTest, InstallUserScript) {
   // The details of script conversion are tested elsewhere, this just tests
-  // integration with ExtensionsService.
-  InitializeEmptyExtensionsService();
+  // integration with ExtensionService.
+  InitializeEmptyExtensionService();
 
   FilePath path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &path));
   path = path.AppendASCII("extensions")
              .AppendASCII("user_script_basic.user.js");
 
   ASSERT_TRUE(file_util::PathExists(path));
   scoped_refptr<CrxInstaller> installer(
       new CrxInstaller(service_, NULL));  // silent install
   installer->InstallUserScript(
       path,
       GURL("http://www.aaronboodman.com/scripts/user_script_basic.user.js"));
 
   loop_.RunAllPending();
   std::vector<std::string> errors = GetErrors();
   EXPECT_TRUE(installed_) << "Nothing was installed.";
   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();
 
   installed_ = NULL;
   loaded_.clear();
   ExtensionErrorReporter::GetInstance()->ClearErrors();
 }
 
 // This tests that the granted permissions preferences are correctly set when
 // installing an extension.
-TEST_F(ExtensionsServiceTest, GrantedPermissions) {
-  InitializeEmptyExtensionsService();
+TEST_F(ExtensionServiceTest, GrantedPermissions) {
+  InitializeEmptyExtensionService();
   FilePath path;
   FilePath pem_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &path));
   path = path.AppendASCII("extensions")
       .AppendASCII("permissions");
 
   pem_path = path.AppendASCII("unknown.pem");
   path = path.AppendASCII("unknown");
 
   ASSERT_TRUE(file_util::PathExists(pem_path));
@@ skipping 37 matching lines @@
 
   EXPECT_EQ(expected_api_perms, known_api_perms);
   EXPECT_FALSE(full_access);
   AssertEqualExtents(&expected_host_perms, &known_host_perms);
 }
 
 #if !defined(OS_CHROMEOS)
 // 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.
-TEST_F(ExtensionsServiceTest, GrantedFullAccessPermissions) {
-  InitializeEmptyExtensionsService();
+TEST_F(ExtensionServiceTest, GrantedFullAccessPermissions) {
+  InitializeEmptyExtensionService();
 
   FilePath path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &path));
   path = path.AppendASCII("extensions")
       .AppendASCII("good")
       .AppendASCII("Extensions")
       .AppendASCII(good1)
       .AppendASCII("2");
 
   ASSERT_TRUE(file_util::PathExists(path));
@@ skipping 14 matching lines @@
 
   EXPECT_TRUE(full_access);
   EXPECT_TRUE(api_permissions.empty());
   EXPECT_TRUE(host_permissions.is_empty());
 }
 #endif
 
 // Tests that the extension is disabled when permissions are missing from
 // the extension's granted permissions preferences. (This simulates updating
 // the browser to a version which recognizes more permissions).
-TEST_F(ExtensionsServiceTest, GrantedAPIAndHostPermissions) {
-  InitializeEmptyExtensionsService();
+TEST_F(ExtensionServiceTest, GrantedAPIAndHostPermissions) {
+  InitializeEmptyExtensionService();
 
   FilePath path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &path));
   path = path.AppendASCII("extensions")
       .AppendASCII("permissions")
       .AppendASCII("unknown");
 
   ASSERT_TRUE(file_util::PathExists(path));
 
   PackAndInstallExtension(path, true);
@@ skipping 108 matching lines @@
                                            &current_full_access,
                                            &current_api_permissions,
                                            &current_host_permissions));
 
   ASSERT_FALSE(current_full_access);
   ASSERT_EQ(expected_api_permissions, current_api_permissions);
   AssertEqualExtents(&expected_host_permissions, &current_host_permissions);
 }
 
 // Test Packaging and installing an extension.
-TEST_F(ExtensionsServiceTest, PackExtension) {
-  InitializeEmptyExtensionsService();
+TEST_F(ExtensionServiceTest, PackExtension) {
+  InitializeEmptyExtensionService();
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
   FilePath input_directory = extensions_path
       .AppendASCII("good")
       .AppendASCII("Extensions")
       .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj")
       .AppendASCII("1.0.0.0");
 
   ScopedTempDir temp_dir;
@@ skipping 26 matching lines @@
   std::string invalid_manifest_content = "I am not a manifest.";
   ASSERT_TRUE(file_util::WriteFile(
       temp_dir2.path().Append(Extension::kManifestFilename),
       invalid_manifest_content.c_str(), invalid_manifest_content.size()));
   creator.reset(new ExtensionCreator());
   ASSERT_FALSE(creator->Run(temp_dir2.path(), crx_path, privkey_path,
                             FilePath()));
 }
 
 // Test Packaging and installing an extension whose name contains punctuation.
-TEST_F(ExtensionsServiceTest, PackPunctuatedExtension) {
-  InitializeEmptyExtensionsService();
+TEST_F(ExtensionServiceTest, PackPunctuatedExtension) {
+  InitializeEmptyExtensionService();
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
   FilePath input_directory = extensions_path
       .AppendASCII("good")
       .AppendASCII("Extensions")
       .AppendASCII(good0)
       .AppendASCII("1.0.0.0");
 
   ScopedTempDir temp_dir;
@@ skipping 57 matching lines @@
     InstallExtension(expected_crx_path, true);
   }
 }
 
 // Test Packaging and installing an extension using an openssl generated key.
 // The openssl is generated with the following:
 // > openssl genrsa -out privkey.pem 1024
 // > openssl pkcs8 -topk8 -nocrypt -in privkey.pem -out privkey_asn1.pem
 // The privkey.pem is a PrivateKey, and the pcks8 -topk8 creates a
 // PrivateKeyInfo ASN.1 structure, we our RSAPrivateKey expects.
-TEST_F(ExtensionsServiceTest, PackExtensionOpenSSLKey) {
-  InitializeEmptyExtensionsService();
+TEST_F(ExtensionServiceTest, PackExtensionOpenSSLKey) {
+  InitializeEmptyExtensionService();
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
   FilePath input_directory = extensions_path
       .AppendASCII("good")
       .AppendASCII("Extensions")
       .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj")
       .AppendASCII("1.0.0.0");
   FilePath privkey_path(extensions_path.AppendASCII(
       "openssl_privkey_asn1.pem"));
   ASSERT_TRUE(file_util::PathExists(privkey_path));
 
   ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   FilePath output_directory = temp_dir.path();
 
   FilePath crx_path(output_directory.AppendASCII("ex1.crx"));
 
   scoped_ptr<ExtensionCreator> creator(new ExtensionCreator());
   ASSERT_TRUE(creator->Run(input_directory, crx_path, privkey_path,
       FilePath()));
 
   InstallExtension(crx_path, true);
 }
 
-TEST_F(ExtensionsServiceTest, InstallTheme) {
-  InitializeEmptyExtensionsService();
+TEST_F(ExtensionServiceTest, InstallTheme) {
+  InitializeEmptyExtensionService();
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
 
   // A theme.
   FilePath path = extensions_path.AppendASCII("theme.crx");
   InstallExtension(path, true);
   int pref_count = 0;
   ValidatePrefKeyCount(++pref_count);
   ValidateIntegerPref(theme_crx, "state", Extension::ENABLED);
@@ skipping 14 matching lines @@
   path = extensions_path.AppendASCII("theme_with_extension.crx");
   InstallExtension(path, false);
   ValidatePrefKeyCount(pref_count);
 
   // A theme with image resources missing (misspelt path).
   path = extensions_path.AppendASCII("theme_missing_image.crx");
   InstallExtension(path, false);
   ValidatePrefKeyCount(pref_count);
 }
 
-TEST_F(ExtensionsServiceTest, LoadLocalizedTheme) {
+TEST_F(ExtensionServiceTest, LoadLocalizedTheme) {
   // Load.
-  InitializeEmptyExtensionsService();
+  InitializeEmptyExtensionService();
   FilePath extension_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extension_path));
   extension_path = extension_path
       .AppendASCII("extensions")
       .AppendASCII("theme_i18n");
 
   service_->LoadExtension(extension_path);
   loop_.RunAllPending();
   EXPECT_EQ(0u, GetErrors().size());
   ASSERT_EQ(1u, loaded_.size());
   EXPECT_EQ(1u, service_->extensions()->size());
   EXPECT_EQ("name", service_->extensions()->at(0)->name());
   EXPECT_EQ("description", service_->extensions()->at(0)->description());
 }
 
-TEST_F(ExtensionsServiceTest, InstallLocalizedTheme) {
-  InitializeEmptyExtensionsService();
+TEST_F(ExtensionServiceTest, InstallLocalizedTheme) {
+  InitializeEmptyExtensionService();
   FilePath theme_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &theme_path));
   theme_path = theme_path
       .AppendASCII("extensions")
       .AppendASCII("theme_i18n");
 
   PackAndInstallExtension(theme_path, true);
 
   EXPECT_EQ(0u, GetErrors().size());
   EXPECT_EQ(1u, service_->extensions()->size());
   EXPECT_EQ("name", service_->extensions()->at(0)->name());
   EXPECT_EQ("description", service_->extensions()->at(0)->description());
 }
 
-TEST_F(ExtensionsServiceTest, InstallApps) {
-  InitializeEmptyExtensionsService();
+TEST_F(ExtensionServiceTest, InstallApps) {
+  InitializeEmptyExtensionService();
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
 
   // An empty app.
   PackAndInstallExtension(extensions_path.AppendASCII("app1"), true);
   int pref_count = 0;
   ValidatePrefKeyCount(++pref_count);
   ASSERT_EQ(1u, service_->extensions()->size());
   std::string id = service_->extensions()->at(0)->id();
   ValidateIntegerPref(id, "state", Extension::ENABLED);
   ValidateIntegerPref(id, "location", Extension::INTERNAL);
 
   // Another app with non-overlapping extent. Should succeed.
   PackAndInstallExtension(extensions_path.AppendASCII("app2"), true);
   ValidatePrefKeyCount(++pref_count);
 
   // A third app whose extent overlaps the first. Should fail.
   PackAndInstallExtension(extensions_path.AppendASCII("app3"), false);
   ValidatePrefKeyCount(pref_count);
 }
 
-TEST_F(ExtensionsServiceTest, InstallAppsWithUnlimtedStorage) {
-  InitializeEmptyExtensionsService();
+TEST_F(ExtensionServiceTest, InstallAppsWithUnlimtedStorage) {
+  InitializeEmptyExtensionService();
   EXPECT_TRUE(service_->extensions()->empty());
   EXPECT_TRUE(service_->unlimited_storage_map_.empty());
 
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
   int pref_count = 0;
   ChromeAppCacheService* appcache_service = profile_->GetAppCacheService();
 
   // Install app1 with unlimited storage.
@@ skipping 38 matching lines @@
 
   // Uninstall the other, unlimited storage should be revoked.
   service_->UninstallExtension(id2, false);
   loop_.RunAllPending();
   EXPECT_EQ(0u, service_->extensions()->size());
   EXPECT_EQ(-1L,
             appcache_service->storage()->GetOriginQuotaInMemory(origin2));
   EXPECT_TRUE(service_->unlimited_storage_map_.empty());
 }
 
-TEST_F(ExtensionsServiceTest, InstallAppsAndCheckStorageProtection) {
-  InitializeEmptyExtensionsService();
+TEST_F(ExtensionServiceTest, InstallAppsAndCheckStorageProtection) {
+  InitializeEmptyExtensionService();
   EXPECT_TRUE(service_->extensions()->empty());
   EXPECT_TRUE(service_->protected_storage_map_.empty());
 
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
   int pref_count = 0;
 
   PackAndInstallExtension(extensions_path.AppendASCII("app1"), true);
   ValidatePrefKeyCount(++pref_count);
@@ skipping 22 matching lines @@
   EXPECT_FALSE(service_->protected_storage_map_.empty());
 
   service_->UninstallExtension(id2, false);
   loop_.RunAllPending();
 
   EXPECT_TRUE(service_->extensions()->empty());
   EXPECT_TRUE(service_->protected_storage_map_.empty());
 }
 
 // Test that when an extension version is reinstalled, nothing happens.
-TEST_F(ExtensionsServiceTest, Reinstall) {
-  InitializeEmptyExtensionsService();
+TEST_F(ExtensionServiceTest, Reinstall) {
+  InitializeEmptyExtensionService();
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
 
   // A simple extension that should install without error.
   FilePath path = extensions_path.AppendASCII("good.crx");
   service_->InstallExtension(path);
   loop_.RunAllPending();
 
   ASSERT_TRUE(installed_);
@@ skipping 13 matching lines @@
 
   ASSERT_TRUE(installed_);
   ASSERT_EQ(1u, loaded_.size());
   ASSERT_EQ(0u, GetErrors().size());
   ValidatePrefKeyCount(1);
   ValidateIntegerPref(good_crx, "state", Extension::ENABLED);
   ValidateIntegerPref(good_crx, "location", Extension::INTERNAL);
 }
 
 // Test upgrading a signed extension.
-TEST_F(ExtensionsServiceTest, UpgradeSignedGood) {
-  InitializeEmptyExtensionsService();
+TEST_F(ExtensionServiceTest, UpgradeSignedGood) {
+  InitializeEmptyExtensionService();
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
 
   FilePath path = extensions_path.AppendASCII("good.crx");
   service_->InstallExtension(path);
   loop_.RunAllPending();
 
   ASSERT_TRUE(installed_);
   ASSERT_EQ(1u, loaded_.size());
   ASSERT_EQ("1.0.0.0", loaded_[0]->version()->GetString());
   ASSERT_EQ(0u, GetErrors().size());
 
   // Upgrade to version 2.0
   path = extensions_path.AppendASCII("good2.crx");
   service_->InstallExtension(path);
   loop_.RunAllPending();
 
   ASSERT_TRUE(installed_);
   ASSERT_EQ(1u, loaded_.size());
   ASSERT_EQ("1.0.0.1", loaded_[0]->version()->GetString());
   ASSERT_EQ(0u, GetErrors().size());
 }
 
 // Test upgrading a signed extension with a bad signature.
-TEST_F(ExtensionsServiceTest, UpgradeSignedBad) {
-  InitializeEmptyExtensionsService();
+TEST_F(ExtensionServiceTest, UpgradeSignedBad) {
+  InitializeEmptyExtensionService();
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
 
   FilePath path = extensions_path.AppendASCII("good.crx");
   service_->InstallExtension(path);
   loop_.RunAllPending();
 
   ASSERT_TRUE(installed_);
   ASSERT_EQ(1u, loaded_.size());
   ASSERT_EQ(0u, GetErrors().size());
   installed_ = NULL;
 
   // Try upgrading with a bad signature. This should fail during the unpack,
   // because the key will not match the signature.
   path = extensions_path.AppendASCII("good2_bad_signature.crx");
   service_->InstallExtension(path);
   loop_.RunAllPending();
 
   ASSERT_FALSE(installed_);
   ASSERT_EQ(1u, loaded_.size());
   ASSERT_EQ(1u, GetErrors().size());
 }
 
 // Test a normal update via the UpdateExtension API
-TEST_F(ExtensionsServiceTest, UpdateExtension) {
-  InitializeEmptyExtensionsService();
+TEST_F(ExtensionServiceTest, UpdateExtension) {
+  InitializeEmptyExtensionService();
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
 
   FilePath path = extensions_path.AppendASCII("good.crx");
 
   InstallExtension(path, true);
   const Extension* good = service_->extensions()->at(0);
   ASSERT_EQ("1.0.0.0", good->VersionString());
   ASSERT_EQ(good_crx, good->id());
 
   path = extensions_path.AppendASCII("good2.crx");
   UpdateExtension(good_crx, path, ENABLED);
   ASSERT_EQ("1.0.0.1", loaded_[0]->version()->GetString());
 }
 
 // Test updating a not-already-installed extension - this should fail
-TEST_F(ExtensionsServiceTest, UpdateNotInstalledExtension) {
-  InitializeEmptyExtensionsService();
+TEST_F(ExtensionServiceTest, UpdateNotInstalledExtension) {
+  InitializeEmptyExtensionService();
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
 
   FilePath path = extensions_path.AppendASCII("good.crx");
   UpdateExtension(good_crx, path, UPDATED);
   loop_.RunAllPending();
 
   ASSERT_EQ(0u, service_->extensions()->size());
   ASSERT_FALSE(installed_);
   ASSERT_EQ(0u, loaded_.size());
 }
 
 // Makes sure you can't downgrade an extension via UpdateExtension
-TEST_F(ExtensionsServiceTest, UpdateWillNotDowngrade) {
-  InitializeEmptyExtensionsService();
+TEST_F(ExtensionServiceTest, UpdateWillNotDowngrade) {
+  InitializeEmptyExtensionService();
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
 
   FilePath path = extensions_path.AppendASCII("good2.crx");
 
   InstallExtension(path, true);
   const Extension* good = service_->extensions()->at(0);
   ASSERT_EQ("1.0.0.1", good->VersionString());
   ASSERT_EQ(good_crx, good->id());
 
   // Change path from good2.crx -> good.crx
   path = extensions_path.AppendASCII("good.crx");
   UpdateExtension(good_crx, path, FAILED);
   ASSERT_EQ("1.0.0.1", service_->extensions()->at(0)->VersionString());
 }
 
 // Make sure calling update with an identical version does nothing
-TEST_F(ExtensionsServiceTest, UpdateToSameVersionIsNoop) {
-  InitializeEmptyExtensionsService();
+TEST_F(ExtensionServiceTest, UpdateToSameVersionIsNoop) {
+  InitializeEmptyExtensionService();
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
 
   FilePath path = extensions_path.AppendASCII("good.crx");
 
   InstallExtension(path, true);
   const Extension* good = service_->extensions()->at(0);
   ASSERT_EQ(good_crx, good->id());
   UpdateExtension(good_crx, path, FAILED_SILENTLY);
 }
 
 // Tests that updating an extension does not clobber old state.
-TEST_F(ExtensionsServiceTest, UpdateExtensionPreservesState) {
-  InitializeEmptyExtensionsService();
+TEST_F(ExtensionServiceTest, UpdateExtensionPreservesState) {
+  InitializeEmptyExtensionService();
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
 
   FilePath path = extensions_path.AppendASCII("good.crx");
 
   InstallExtension(path, true);
   const Extension* good = service_->extensions()->at(0);
   ASSERT_EQ("1.0.0.0", good->VersionString());
   ASSERT_EQ(good_crx, good->id());
 
   // Disable it and allow it to run in incognito. These settings should carry
   // over to the updated version.
   service_->DisableExtension(good->id());
   service_->SetIsIncognitoEnabled(good, true);
 
   path = extensions_path.AppendASCII("good2.crx");
   UpdateExtension(good_crx, path, INSTALLED);
   ASSERT_EQ(1u, service_->disabled_extensions()->size());
   const Extension* good2 = service_->disabled_extensions()->at(0);
   ASSERT_EQ("1.0.0.1", good2->version()->GetString());
   EXPECT_TRUE(service_->IsIncognitoEnabled(good2));
 }
 
 // Tests that updating preserves extension location.
-TEST_F(ExtensionsServiceTest, UpdateExtensionPreservesLocation) {
-  InitializeEmptyExtensionsService();
+TEST_F(ExtensionServiceTest, UpdateExtensionPreservesLocation) {
+  InitializeEmptyExtensionService();
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
 
   FilePath path = extensions_path.AppendASCII("good.crx");
 
   InstallExtension(path, true);
   const Extension* good = service_->extensions()->at(0);
 
   ASSERT_EQ("1.0.0.0", good->VersionString());
   ASSERT_EQ(good_crx, good->id());
 
   // Simulate non-internal location.
   const_cast<Extension*>(good)->location_ = Extension::EXTERNAL_PREF;
 
   path = extensions_path.AppendASCII("good2.crx");
   UpdateExtension(good_crx, path, ENABLED);
   const Extension* good2 = service_->extensions()->at(0);
   ASSERT_EQ("1.0.0.1", good2->version()->GetString());
   EXPECT_EQ(good2->location(), Extension::EXTERNAL_PREF);
 }
 
 // Makes sure that LOAD extension types can downgrade.
-TEST_F(ExtensionsServiceTest, LoadExtensionsCanDowngrade) {
-  InitializeEmptyExtensionsService();
+TEST_F(ExtensionServiceTest, LoadExtensionsCanDowngrade) {
+  InitializeEmptyExtensionService();
 
   ScopedTempDir temp;
   ASSERT_TRUE(temp.CreateUniqueTempDir());
 
   // We'll write the extension manifest dynamically to a temporary path
   // to make it easier to change the version number.
   FilePath extension_path = temp.path();
   FilePath manifest_path = extension_path.Append(Extension::kManifestFilename);
   ASSERT_FALSE(file_util::PathExists(manifest_path));
 
@@ skipping 23 matching lines @@
   loop_.RunAllPending();
 
   EXPECT_EQ(0u, GetErrors().size());
   ASSERT_EQ(1u, loaded_.size());
   EXPECT_EQ(Extension::LOAD, loaded_[0]->location());
   EXPECT_EQ(1u, service_->extensions()->size());
   EXPECT_EQ("1.0", loaded_[0]->VersionString());
 }
 
 // Test adding a pending extension.
-TEST_F(ExtensionsServiceTest, AddPendingExtension) {
-  InitializeEmptyExtensionsService();
+TEST_F(ExtensionServiceTest, AddPendingExtension) {
+  InitializeEmptyExtensionService();
 
   const std::string kFakeId("fake-id");
   const GURL kFakeUpdateURL("http:://fake.update/url");
   const PendingExtensionInfo::ExpectedCrxType kFakeExpectedCrxType =
       PendingExtensionInfo::EXTENSION;
   const bool kFakeInstallSilently(true);
   const Extension::State kFakeInitialState(Extension::ENABLED);
   const bool kFakeInitialIncognitoEnabled(false);
 
   service_->AddPendingExtensionFromSync(
@@ skipping 14 matching lines @@
     PendingExtensionInfo::THEME;
 const PendingExtensionInfo::ExpectedCrxType kCrxTypeExtension =
     PendingExtensionInfo::EXTENSION;
 const bool kGoodIsFromSync = true;
 const bool kGoodInstallSilently = true;
 const Extension::State kGoodInitialState = Extension::DISABLED;
 const bool kGoodInitialIncognitoEnabled = true;
 }  // namespace
 
 // Test updating a pending extension.
-TEST_F(ExtensionsServiceTest, UpdatePendingExtension) {
-  InitializeEmptyExtensionsService();
+TEST_F(ExtensionServiceTest, UpdatePendingExtension) {
+  InitializeEmptyExtensionService();
   service_->AddPendingExtensionFromSync(
       kGoodId, GURL(kGoodUpdateURL), kCrxTypeExtension,
       kGoodInstallSilently, kGoodInitialState,
       kGoodInitialIncognitoEnabled);
   EXPECT_TRUE(ContainsKey(service_->pending_extensions(), kGoodId));
 
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
   FilePath path = extensions_path.AppendASCII("good.crx");
   UpdateExtension(kGoodId, path, INSTALLED);
 
   EXPECT_FALSE(ContainsKey(service_->pending_extensions(), kGoodId));
 
   const Extension* extension = service_->GetExtensionById(kGoodId, true);
   ASSERT_TRUE(extension);
 
   bool enabled = service_->GetExtensionById(kGoodId, false);
   EXPECT_EQ(kGoodInitialState == Extension::ENABLED, enabled);
   EXPECT_EQ(kGoodInitialState,
             service_->extension_prefs()->GetExtensionState(extension->id()));
   EXPECT_EQ(kGoodInitialIncognitoEnabled,
             service_->IsIncognitoEnabled(extension));
 }
 
 // Test updating a pending theme.
-TEST_F(ExtensionsServiceTest, UpdatePendingTheme) {
-  InitializeEmptyExtensionsService();
+TEST_F(ExtensionServiceTest, UpdatePendingTheme) {
+  InitializeEmptyExtensionService();
   service_->AddPendingExtensionFromSync(
       theme_crx, GURL(), PendingExtensionInfo::THEME,
       false, Extension::ENABLED, false);
   EXPECT_TRUE(ContainsKey(service_->pending_extensions(), theme_crx));
 
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
   FilePath path = extensions_path.AppendASCII("theme.crx");
   UpdateExtension(theme_crx, path, ENABLED);
 
   EXPECT_FALSE(ContainsKey(service_->pending_extensions(), theme_crx));
 
   const Extension* extension = service_->GetExtensionById(theme_crx, true);
   ASSERT_TRUE(extension);
 
   EXPECT_EQ(Extension::ENABLED,
             service_->extension_prefs()->GetExtensionState(extension->id()));
   EXPECT_FALSE(service_->IsIncognitoEnabled(extension));
 }
 
 // Test updating a pending CRX as if the source is an external extension
 // with an update URL.  In this case we don't know if the CRX is a theme
 // or not.
-TEST_F(ExtensionsServiceTest, UpdatePendingExternalCrx) {
-  InitializeEmptyExtensionsService();
+TEST_F(ExtensionServiceTest, UpdatePendingExternalCrx) {
+  InitializeEmptyExtensionService();
   service_->AddPendingExtensionFromExternalUpdateUrl(
       theme_crx, GURL(), Extension::EXTERNAL_PREF_DOWNLOAD);
 
   EXPECT_TRUE(ContainsKey(service_->pending_extensions(), theme_crx));
 
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
   FilePath path = extensions_path.AppendASCII("theme.crx");
   UpdateExtension(theme_crx, path, ENABLED);
 
   EXPECT_FALSE(ContainsKey(service_->pending_extensions(), theme_crx));
 
   const Extension* extension = service_->GetExtensionById(theme_crx, true);
   ASSERT_TRUE(extension);
 
   EXPECT_EQ(Extension::ENABLED,
             service_->extension_prefs()->GetExtensionState(extension->id()));
   EXPECT_FALSE(service_->IsIncognitoEnabled(extension));
 }
 
 // Test updating a pending CRX as if the source is an external extension
 // with an update URL.  The external update should overwrite a sync update,
 // but a sync update should not overwrite a non-sync update.
-TEST_F(ExtensionsServiceTest, UpdatePendingExternalCrxWinsOverSync) {
-  InitializeEmptyExtensionsService();
+TEST_F(ExtensionServiceTest, UpdatePendingExternalCrxWinsOverSync) {
+  InitializeEmptyExtensionService();
 
   // Add a crx to be installed from the update mechanism.
   service_->AddPendingExtensionFromSync(
       kGoodId, GURL(kGoodUpdateURL), kCrxTypeExtension,
       kGoodInstallSilently, kGoodInitialState,
       kGoodInitialIncognitoEnabled);
 
   // Check that there is a pending crx, with is_from_sync set to true.
   PendingExtensionMap::const_iterator it;
   it = service_->pending_extensions().find(kGoodId);
@@ skipping 16 matching lines @@
       kGoodInitialIncognitoEnabled);
 
   // Check that the external, non-sync update was not overridden.
   it = service_->pending_extensions().find(kGoodId);
   ASSERT_TRUE(it != service_->pending_extensions().end());
   EXPECT_FALSE(it->second.is_from_sync);
 }
 
 // Updating a theme should fail if the updater is explicitly told that
 // the CRX is not a theme.
-TEST_F(ExtensionsServiceTest, UpdatePendingCrxThemeMismatch) {
-  InitializeEmptyExtensionsService();
+TEST_F(ExtensionServiceTest, UpdatePendingCrxThemeMismatch) {
+  InitializeEmptyExtensionService();
   service_->AddPendingExtensionFromSync(
       theme_crx, GURL(),
       PendingExtensionInfo::EXTENSION,
       true, Extension::ENABLED, false);
 
   EXPECT_TRUE(ContainsKey(service_->pending_extensions(), theme_crx));
 
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
   FilePath path = extensions_path.AppendASCII("theme.crx");
   UpdateExtension(theme_crx, path, FAILED_SILENTLY);
 
   EXPECT_FALSE(ContainsKey(service_->pending_extensions(), theme_crx));
 
   const Extension* extension = service_->GetExtensionById(theme_crx, true);
   ASSERT_FALSE(extension);
 }
 
 // TODO(akalin): Test updating a pending extension non-silently once
 // we can mock out ExtensionInstallUI and inject our version into
 // UpdateExtension().
 
 // Test updating a pending extension with wrong is_theme.
-TEST_F(ExtensionsServiceTest, UpdatePendingExtensionWrongIsTheme) {
-  InitializeEmptyExtensionsService();
+TEST_F(ExtensionServiceTest, UpdatePendingExtensionWrongIsTheme) {
+  InitializeEmptyExtensionService();
   // Add pending extension with a flipped is_theme.
   service_->AddPendingExtensionFromSync(
       kGoodId, GURL(kGoodUpdateURL),
       kCrxTypeTheme, kGoodInstallSilently, kGoodInitialState,
       kGoodInitialIncognitoEnabled);
   EXPECT_TRUE(ContainsKey(service_->pending_extensions(), kGoodId));
 
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
   FilePath path = extensions_path.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(ContainsKey(service_->pending_extensions(), kGoodId));
 }
 
 // TODO(akalin): Figure out how to test that installs of pending
 // unsyncable extensions are blocked.
 
 // Test updating a pending extension for one that is not pending.
-TEST_F(ExtensionsServiceTest, UpdatePendingExtensionNotPending) {
-  InitializeEmptyExtensionsService();
+TEST_F(ExtensionServiceTest, UpdatePendingExtensionNotPending) {
+  InitializeEmptyExtensionService();
 
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
   FilePath path = extensions_path.AppendASCII("good.crx");
   UpdateExtension(kGoodId, path, UPDATED);
 
   EXPECT_FALSE(ContainsKey(service_->pending_extensions(), kGoodId));
 }
 
 // Test updating a pending extension for one that is already
 // installed.
-TEST_F(ExtensionsServiceTest, UpdatePendingExtensionAlreadyInstalled) {
-  InitializeEmptyExtensionsService();
+TEST_F(ExtensionServiceTest, UpdatePendingExtensionAlreadyInstalled) {
+  InitializeEmptyExtensionService();
 
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
   FilePath path = extensions_path.AppendASCII("good.crx");
   InstallExtension(path, true);
   ASSERT_EQ(1u, service_->extensions()->size());
   const Extension* good = service_->extensions()->at(0);
 
   EXPECT_FALSE(good->is_theme());
 
   // Use AddPendingExtensionInternal() as AddPendingExtension() would
   // balk.
   service_->AddPendingExtensionInternal(
       good->id(), good->update_url(),
       PendingExtensionInfo::EXTENSION,
       kGoodIsFromSync, kGoodInstallSilently, kGoodInitialState,
       kGoodInitialIncognitoEnabled, Extension::INTERNAL);
   UpdateExtension(good->id(), path, INSTALLED);
 
   EXPECT_FALSE(ContainsKey(service_->pending_extensions(), kGoodId));
 }
 
 // Test pref settings for blacklist and unblacklist extensions.
-TEST_F(ExtensionsServiceTest, SetUnsetBlacklistInPrefs) {
-  InitializeEmptyExtensionsService();
+TEST_F(ExtensionServiceTest, SetUnsetBlacklistInPrefs) {
+  InitializeEmptyExtensionService();
   std::vector<std::string> blacklist;
   blacklist.push_back(good0);
   blacklist.push_back("invalid_id");  // an invalid id
   blacklist.push_back(good1);
   service_->UpdateExtensionBlacklist(blacklist);
   // Make sure pref is updated
   loop_.RunAllPending();
 
   // blacklist is set for good0,1,2
   ValidateBooleanPref(good0, "blacklist", true);
   ValidateBooleanPref(good1, "blacklist", true);
   // invalid_id should not be inserted to pref.
   EXPECT_FALSE(IsPrefExist("invalid_id", "blacklist"));
 
   // remove good1, add good2
   blacklist.pop_back();
   blacklist.push_back(good2);
 
   service_->UpdateExtensionBlacklist(blacklist);
   // only good0 and good1 should be set
   ValidateBooleanPref(good0, "blacklist", true);
   EXPECT_FALSE(IsPrefExist(good1, "blacklist"));
   ValidateBooleanPref(good2, "blacklist", true);
   EXPECT_FALSE(IsPrefExist("invalid_id", "blacklist"));
 }
 
 // Unload installed extension from blacklist.
-TEST_F(ExtensionsServiceTest, UnloadBlacklistedExtension) {
-  InitializeEmptyExtensionsService();
+TEST_F(ExtensionServiceTest, UnloadBlacklistedExtension) {
+  InitializeEmptyExtensionService();
   FilePath extensions_path;
   EXPECT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
 
   FilePath path = extensions_path.AppendASCII("good.crx");
 
   InstallExtension(path, true);
   const Extension* good = service_->extensions()->at(0);
   EXPECT_EQ(good_crx, good->id());
   UpdateExtension(good_crx, path, FAILED_SILENTLY);
@@ skipping 11 matching lines @@
   // Remove good_crx from blacklist
   blacklist.pop_back();
   service_->UpdateExtensionBlacklist(blacklist);
   // Make sure pref is updated
   loop_.RunAllPending();
   // blacklist value should not be set for good_crx
   EXPECT_FALSE(IsPrefExist(good_crx, "blacklist"));
 }
 
 // Unload installed extension from blacklist.
-TEST_F(ExtensionsServiceTest, BlacklistedExtensionWillNotInstall) {
-  InitializeEmptyExtensionsService();
+TEST_F(ExtensionServiceTest, BlacklistedExtensionWillNotInstall) {
+  InitializeEmptyExtensionService();
   std::vector<std::string> blacklist;
   blacklist.push_back(good_crx);
   service_->UpdateExtensionBlacklist(blacklist);
   // Make sure pref is updated
   loop_.RunAllPending();
 
   // Now, the good_crx is blacklisted.
   ValidateBooleanPref(good_crx, "blacklist", true);
 
   // We can not install good_crx.
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
   FilePath path = extensions_path.AppendASCII("good.crx");
   service_->InstallExtension(path);
   loop_.RunAllPending();
   EXPECT_EQ(0u, service_->extensions()->size());
   ValidateBooleanPref(good_crx, "blacklist", true);
 }
 
 // Test loading extensions from the profile directory, except
 // blacklisted ones.
-TEST_F(ExtensionsServiceTest, WillNotLoadBlacklistedExtensionsFromDirectory) {
+TEST_F(ExtensionServiceTest, WillNotLoadBlacklistedExtensionsFromDirectory) {
   // Initialize the test dir with a good Preferences/extensions.
   FilePath source_install_dir;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &source_install_dir));
   source_install_dir = source_install_dir
       .AppendASCII("extensions")
       .AppendASCII("good")
       .AppendASCII("Extensions");
   FilePath pref_path = source_install_dir
       .DirName()
       .AppendASCII("Preferences");
-  InitializeInstalledExtensionsService(pref_path, source_install_dir);
+  InitializeInstalledExtensionService(pref_path, source_install_dir);
 
   // Blacklist good1.
   std::vector<std::string> blacklist;
   blacklist.push_back(good1);
   service_->UpdateExtensionBlacklist(blacklist);
   // Make sure pref is updated
   loop_.RunAllPending();
 
   ValidateBooleanPref(good1, "blacklist", true);
 
   // Load extensions.
   service_->Init();
   loop_.RunAllPending();
 
   std::vector<std::string> errors = GetErrors();
   for (std::vector<std::string>::iterator err = errors.begin();
     err != errors.end(); ++err) {
     LOG(ERROR) << *err;
   }
   ASSERT_EQ(2u, loaded_.size());
 
   EXPECT_NE(std::string(good1), loaded_[0]->id());
   EXPECT_NE(std::string(good1), loaded_[1]->id());
 }
 
 #if defined(OS_CHROMEOS)
 // Test loading extensions from the profile directory, except
 // ones with a plugin.
-TEST_F(ExtensionsServiceTest, WillNotLoadPluginExtensionsFromDirectory) {
+TEST_F(ExtensionServiceTest, WillNotLoadPluginExtensionsFromDirectory) {
   // Initialize the test dir with a good Preferences/extensions.
   FilePath source_install_dir;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &source_install_dir));
   source_install_dir = source_install_dir
       .AppendASCII("extensions")
       .AppendASCII("good")
       .AppendASCII("Extensions");
   FilePath pref_path = source_install_dir
       .DirName()
       .AppendASCII("Preferences");
-  InitializeInstalledExtensionsService(pref_path, source_install_dir);
+  InitializeInstalledExtensionService(pref_path, source_install_dir);
 
   // good1 contains a plugin.
   // Load extensions.
   service_->Init();
   loop_.RunAllPending();
 
   std::vector<std::string> errors = GetErrors();
   for (std::vector<std::string>::iterator err = errors.begin();
     err != errors.end(); ++err) {
     LOG(ERROR) << *err;
   }
   ASSERT_EQ(2u, loaded_.size());
 
   EXPECT_NE(std::string(good1), loaded_[0]->id());
   EXPECT_NE(std::string(good1), loaded_[1]->id());
 }
 #endif
 
 // Will not install extension blacklisted by policy.
-TEST_F(ExtensionsServiceTest, BlacklistedByPolicyWillNotInstall) {
-  InitializeEmptyExtensionsService();
+TEST_F(ExtensionServiceTest, BlacklistedByPolicyWillNotInstall) {
+  InitializeEmptyExtensionService();
 
   ListValue* whitelist =
       profile_->GetPrefs()->GetMutableList(prefs::kExtensionInstallAllowList);
   ListValue* blacklist =
       profile_->GetPrefs()->GetMutableList(prefs::kExtensionInstallDenyList);
   ASSERT_TRUE(whitelist != NULL && blacklist != NULL);
 
   // Blacklist everything.
   blacklist->Append(Value::CreateStringValue("*"));
 
   // Blacklist prevents us from installing good_crx.
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
   FilePath path = extensions_path.AppendASCII("good.crx");
   service_->InstallExtension(path);
   loop_.RunAllPending();
   EXPECT_EQ(0u, service_->extensions()->size());
 
   // Now whitelist this particular extension.
   whitelist->Append(Value::CreateStringValue(good_crx));
 
   // Ensure we can now install good_crx.
   service_->InstallExtension(path);
   loop_.RunAllPending();
   EXPECT_EQ(1u, service_->extensions()->size());
 }
 
 // Extension blacklisted by policy get unloaded after installing.
-TEST_F(ExtensionsServiceTest, BlacklistedByPolicyRemovedIfRunning) {
-  InitializeEmptyExtensionsService();
+TEST_F(ExtensionServiceTest, BlacklistedByPolicyRemovedIfRunning) {
+  InitializeEmptyExtensionService();
 
   // Install good_crx.
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
   FilePath path = extensions_path.AppendASCII("good.crx");
   service_->InstallExtension(path);
   loop_.RunAllPending();
   EXPECT_EQ(1u, service_->extensions()->size());
 
   { // Scope for pref update notification.
     PrefService* prefs = profile_->GetPrefs();
     ScopedPrefUpdate pref_update(prefs, prefs::kExtensionInstallDenyList);
     ListValue* blacklist =
         prefs->GetMutableList(prefs::kExtensionInstallDenyList);
     ASSERT_TRUE(blacklist != NULL);
 
     // Blacklist this extension.
     blacklist->Append(Value::CreateStringValue(good_crx));
     prefs->ScheduleSavePersistentPrefs();
   }
 
   // Extension should not be running now.
   loop_.RunAllPending();
   EXPECT_EQ(0u, service_->extensions()->size());
 }
 
 // Tests disabling extensions
-TEST_F(ExtensionsServiceTest, DisableExtension) {
-  InitializeEmptyExtensionsService();
+TEST_F(ExtensionServiceTest, DisableExtension) {
+  InitializeEmptyExtensionService();
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
 
   // A simple extension that should install without error.
   FilePath path = extensions_path.AppendASCII("good.crx");
   InstallExtension(path, true);
 
   const char* extension_id = good_crx;
   EXPECT_FALSE(service_->extensions()->empty());
   EXPECT_TRUE(service_->GetExtensionById(extension_id, true) != NULL);
   EXPECT_TRUE(service_->GetExtensionById(extension_id, false) != NULL);
   EXPECT_TRUE(service_->disabled_extensions()->empty());
 
   // Disable it.
   service_->DisableExtension(extension_id);
 
   EXPECT_TRUE(service_->extensions()->empty());
   EXPECT_TRUE(service_->GetExtensionById(extension_id, true) != NULL);
   EXPECT_FALSE(service_->GetExtensionById(extension_id, false) != NULL);
   EXPECT_FALSE(service_->disabled_extensions()->empty());
 }
 
 // Tests disabling all extensions (simulating --disable-extensions flag).
-TEST_F(ExtensionsServiceTest, DisableAllExtensions) {
-  InitializeEmptyExtensionsService();
+TEST_F(ExtensionServiceTest, DisableAllExtensions) {
+  InitializeEmptyExtensionService();
 
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
 
   FilePath path = extensions_path.AppendASCII("good.crx");
   InstallExtension(path, true);
 
   EXPECT_EQ(1u, service_->extensions()->size());
   EXPECT_EQ(0u, service_->disabled_extensions()->size());
@@ skipping 16 matching lines @@
 
   // And then re-enable the extensions.
   service_->set_extensions_enabled(true);
   service_->ReloadExtensions();
 
   EXPECT_EQ(1u, service_->extensions()->size());
   EXPECT_EQ(0u, service_->disabled_extensions()->size());
 }
 
 // Tests reloading extensions
-TEST_F(ExtensionsServiceTest, ReloadExtensions) {
-  InitializeEmptyExtensionsService();
+TEST_F(ExtensionServiceTest, ReloadExtensions) {
+  InitializeEmptyExtensionService();
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
 
   // Simple extension that should install without error.
   FilePath path = extensions_path.AppendASCII("good.crx");
   InstallExtension(path, true);
   const char* extension_id = good_crx;
   service_->DisableExtension(extension_id);
 
@@ skipping 16 matching lines @@
   // UnloadAllExtensions() doesn't send out notifications.
   loaded_.clear();
   service_->ReloadExtensions();
 
   // Extension counts shouldn't change.
   EXPECT_EQ(1u, service_->extensions()->size());
   EXPECT_EQ(0u, service_->disabled_extensions()->size());
 }
 
 // Tests uninstalling normal extensions
-TEST_F(ExtensionsServiceTest, UninstallExtension) {
-  InitializeEmptyExtensionsService();
+TEST_F(ExtensionServiceTest, UninstallExtension) {
+  InitializeEmptyExtensionService();
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
 
   // A simple extension that should install without error.
   FilePath path = extensions_path.AppendASCII("good.crx");
   InstallExtension(path, true);
 
   // The directory should be there now.
   const char* extension_id = good_crx;
@@ skipping 16 matching lines @@
 
   // The extension should not be in the service anymore.
   ASSERT_FALSE(service_->GetExtensionById(extension_id, false));
   loop_.RunAllPending();
 
   // The directory should be gone.
   EXPECT_FALSE(file_util::PathExists(extension_path));
 }
 
 // Tests the uninstaller helper.
-TEST_F(ExtensionsServiceTest, UninstallExtensionHelper) {
-  InitializeEmptyExtensionsService();
+TEST_F(ExtensionServiceTest, UninstallExtensionHelper) {
+  InitializeEmptyExtensionService();
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
 
   // A simple extension that should install without error.
   FilePath path = extensions_path.AppendASCII("good.crx");
   InstallExtension(path, true);
 
   // The directory should be there now.
   const char* extension_id = good_crx;
   FilePath extension_path = extensions_install_dir_.AppendASCII(extension_id);
   EXPECT_TRUE(file_util::PathExists(extension_path));
 
-  bool result = ExtensionsService::UninstallExtensionHelper(service_,
+  bool result = ExtensionService::UninstallExtensionHelper(service_,
                                                             extension_id);
   total_successes_ = 0;
 
   EXPECT_TRUE(result);
 
   // We should get an unload notification.
   ASSERT_TRUE(unloaded_id_.length());
   EXPECT_EQ(extension_id, unloaded_id_);
 
   ValidatePrefKeyCount(0);
 
   // The extension should not be in the service anymore.
   ASSERT_FALSE(service_->GetExtensionById(extension_id, false));
   loop_.RunAllPending();
 
   // The directory should be gone.
   EXPECT_FALSE(file_util::PathExists(extension_path));
 
   // Attempt to uninstall again. This should fail as we just removed the
   // extension.
-  result = ExtensionsService::UninstallExtensionHelper(service_, extension_id);
+  result = ExtensionService::UninstallExtensionHelper(service_, extension_id);
   EXPECT_FALSE(result);
 }
 
 // Verifies extension state is removed upon uninstall
-TEST_F(ExtensionsServiceTest, ClearExtensionData) {
-  InitializeEmptyExtensionsService();
+TEST_F(ExtensionServiceTest, ClearExtensionData) {
+  InitializeEmptyExtensionService();
 
   // Load a test extension.
   FilePath path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &path));
   path = path.AppendASCII("extensions");
   path = path.AppendASCII("good.crx");
   InstallExtension(path, true);
   const Extension* extension = service_->GetExtensionById(good_crx, false);
   ASSERT_TRUE(extension);
   GURL ext_url(extension->url());
@@ skipping 55 matching lines @@
   EXPECT_EQ(0U, origins.size());
 
   // Check that the LSO file has been removed.
   EXPECT_FALSE(file_util::PathExists(lso_path));
 
   // Check if the indexed db has disappeared too.
   EXPECT_FALSE(file_util::PathExists(idb_path));
 }
 
 // Tests loading single extensions (like --load-extension)
-TEST_F(ExtensionsServiceTest, LoadExtension) {
-  InitializeEmptyExtensionsService();
+TEST_F(ExtensionServiceTest, LoadExtension) {
+  InitializeEmptyExtensionService();
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
 
   FilePath ext1 = extensions_path
       .AppendASCII("good")
       .AppendASCII("Extensions")
       .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj")
       .AppendASCII("1.0.0.0");
   service_->LoadExtension(ext1);
@@ skipping 21 matching lines @@
   EXPECT_FALSE(unloaded_id_.length());
   service_->UninstallExtension(id, false);
   loop_.RunAllPending();
   EXPECT_EQ(id, unloaded_id_);
   ASSERT_EQ(0u, loaded_.size());
   EXPECT_EQ(0u, service_->extensions()->size());
 }
 
 // Tests that we generate IDs when they are not specified in the manifest for
 // --load-extension.
-TEST_F(ExtensionsServiceTest, GenerateID) {
-  InitializeEmptyExtensionsService();
+TEST_F(ExtensionServiceTest, GenerateID) {
+  InitializeEmptyExtensionService();
 
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
 
   FilePath no_id_ext = extensions_path.AppendASCII("no_id");
   service_->LoadExtension(no_id_ext);
   loop_.RunAllPending();
   EXPECT_EQ(0u, GetErrors().size());
   ASSERT_EQ(1u, loaded_.size());
   ASSERT_TRUE(Extension::IdIsValid(loaded_[0]->id()));
   EXPECT_EQ(loaded_[0]->location(), Extension::LOAD);
 
   ValidatePrefKeyCount(1);
 
   std::string previous_id = loaded_[0]->id();
 
   // If we reload the same path, we should get the same extension ID.
   service_->LoadExtension(no_id_ext);
   loop_.RunAllPending();
   ASSERT_EQ(1u, loaded_.size());
   ASSERT_EQ(previous_id, loaded_[0]->id());
 }
 
-void ExtensionsServiceTest::TestExternalProvider(
+void ExtensionServiceTest::TestExternalProvider(
     MockExtensionProvider* provider, Extension::Location location) {
   // Verify that starting with no providers loads no extensions.
   service_->Init();
   loop_.RunAllPending();
   ASSERT_EQ(0u, loaded_.size());
 
   provider->set_visit_count(0);
 
   // Register a test extension externally using the mock registry provider.
   FilePath source_path;
@@ skipping 109 matching lines @@
   service_->LoadAllExtensions();
   loop_.RunAllPending();
   ASSERT_EQ(0u, loaded_.size());
   ValidatePrefKeyCount(1);
 
   EXPECT_EQ(5, provider->visit_count());
 }
 
 // Tests the external installation feature
 #if defined(OS_WIN)
-TEST_F(ExtensionsServiceTest, ExternalInstallRegistry) {
+TEST_F(ExtensionServiceTest, ExternalInstallRegistry) {
   // This should all work, even when normal extension installation is disabled.
-  InitializeEmptyExtensionsService();
+  InitializeEmptyExtensionService();
   set_extensions_enabled(false);
 
   // Now add providers. Extension system takes ownership of the objects.
   MockExtensionProvider* reg_provider =
       new MockExtensionProvider(Extension::EXTERNAL_REGISTRY);
   AddMockExternalProvider(reg_provider);
   TestExternalProvider(reg_provider, Extension::EXTERNAL_REGISTRY);
 }
 #endif
 
-TEST_F(ExtensionsServiceTest, ExternalInstallPref) {
-  InitializeEmptyExtensionsService();
+TEST_F(ExtensionServiceTest, ExternalInstallPref) {
+  InitializeEmptyExtensionService();
 
   // Now add providers. Extension system takes ownership of the objects.
   MockExtensionProvider* pref_provider =
       new MockExtensionProvider(Extension::EXTERNAL_PREF);
 
   AddMockExternalProvider(pref_provider);
   TestExternalProvider(pref_provider, Extension::EXTERNAL_PREF);
 }
 
-TEST_F(ExtensionsServiceTest, ExternalInstallPrefUpdateUrl) {
+TEST_F(ExtensionServiceTest, ExternalInstallPrefUpdateUrl) {
   // This should all work, even when normal extension installation is disabled.
-  InitializeEmptyExtensionsService();
+  InitializeEmptyExtensionService();
   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.
   // Extend the mock to work with update URLs.  This test checks the
   // behavior that is common to all external extension visitors.  The
   // browser test ExtensionManagementTest.ExternalUrlUpdate tests that
   // what the visitor does results in an extension being downloaded and
   // installed.
   MockExtensionProvider* pref_provider =
       new MockExtensionProvider(Extension::EXTERNAL_PREF_DOWNLOAD);
   AddMockExternalProvider(pref_provider);
   TestExternalProvider(pref_provider, Extension::EXTERNAL_PREF_DOWNLOAD);
 }
 
 // Tests that external extensions get uninstalled when the external extension
 // providers can't account for them.
-TEST_F(ExtensionsServiceTest, ExternalUninstall) {
+TEST_F(ExtensionServiceTest, ExternalUninstall) {
   // Start the extensions service with one external extension already installed.
   FilePath source_install_dir;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &source_install_dir));
   source_install_dir = source_install_dir
       .AppendASCII("extensions")
       .AppendASCII("good")
       .AppendASCII("Extensions");
   FilePath pref_path = source_install_dir
       .DirName()
       .AppendASCII("PreferencesExternal");
 
   // This initializes the extensions service with no ExternalExtensionProviders.
-  InitializeInstalledExtensionsService(pref_path, source_install_dir);
+  InitializeInstalledExtensionService(pref_path, source_install_dir);
   set_extensions_enabled(false);
 
   service_->Init();
   loop_.RunAllPending();
 
   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_->ReloadExtensions();
   loop_.RunAllPending();
 
   ASSERT_EQ(0u, GetErrors().size());
   ASSERT_EQ(0u, loaded_.size());
 }
 
-TEST_F(ExtensionsServiceTest, ExternalPrefProvider) {
-  InitializeEmptyExtensionsService();
+TEST_F(ExtensionServiceTest, ExternalPrefProvider) {
+  InitializeEmptyExtensionService();
   std::string json_data =
       "{"
       "  \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\": {"
       "    \"external_crx\": \"RandomExtension.crx\","
       "    \"external_version\": \"1.0\""
       "  },"
       "  \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\": {"
       "    \"external_crx\": \"RandomExtension2.crx\","
       "    \"external_version\": \"2.0\""
       "  },"
@@ skipping 43 matching lines @@
       "  },"
       "  \"hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh\": {"
       "    \"external_crx\": \"RandomValidExtension.crx\","
       "    \"external_version\": \"1.0\""
       "  }"
       "}";
   EXPECT_EQ(1, visitor.Visit(json_data));
 }
 
 // Test loading good extensions from the profile directory.
-TEST_F(ExtensionsServiceTest, LoadAndRelocalizeExtensions) {
+TEST_F(ExtensionServiceTest, LoadAndRelocalizeExtensions) {
   // Initialize the test dir with a good Preferences/extensions.
   FilePath source_install_dir;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &source_install_dir));
   source_install_dir = source_install_dir
       .AppendASCII("extensions")
       .AppendASCII("l10n");
   FilePath pref_path = source_install_dir.AppendASCII("Preferences");
-  InitializeInstalledExtensionsService(pref_path, source_install_dir);
+  InitializeInstalledExtensionService(pref_path, source_install_dir);
 
   service_->Init();
   loop_.RunAllPending();
 
   ASSERT_EQ(3u, loaded_.size());
 
   // This was equal to "sr" on load.
   ValidateStringPref(loaded_[0]->id(), keys::kCurrentLocale, "en");
 
   // These are untouched by re-localization.
@@ skipping 29 matching lines @@
       default:
         NOTREACHED();
     }
   }
 
   NotificationRegistrar registrar_;
   bool ready_;
 };
 
 // Test that we get enabled/disabled correctly for all the pref/command-line
-// combinations. We don't want to derive from the ExtensionsServiceTest class
-// for this test, so we use ExtensionsServiceTestSimple.
+// combinations. We don't want to derive from the ExtensionServiceTest class
+// for this test, so we use ExtensionServiceTestSimple.
 //
 // Also tests that we always fire EXTENSIONS_READY, no matter whether we are
 // enabled or not.
-TEST(ExtensionsServiceTestSimple, Enabledness) {
+TEST(ExtensionServiceTestSimple, Enabledness) {
   ExtensionsReadyRecorder recorder;
   scoped_ptr<TestingProfile> profile(new TestingProfile());
   MessageLoop loop;
   BrowserThread ui_thread(BrowserThread::UI, &loop);
   BrowserThread file_thread(BrowserThread::FILE, &loop);
   scoped_ptr<CommandLine> command_line;
-  scoped_refptr<ExtensionsService> service;
+  scoped_refptr<ExtensionService> service;
   FilePath install_dir = profile->GetPath()
-      .AppendASCII(ExtensionsService::kInstallDirectoryName);
+      .AppendASCII(ExtensionService::kInstallDirectoryName);
 
   // By default, we are enabled.
   command_line.reset(new CommandLine(CommandLine::NO_PROGRAM));
-  service = profile->CreateExtensionsService(command_line.get(),
+  service = profile->CreateExtensionService(command_line.get(),
                                              install_dir);
   EXPECT_TRUE(service->extensions_enabled());
   service->Init();
   loop.RunAllPending();
   EXPECT_TRUE(recorder.ready());
 
   // If either the command line or pref is set, we are disabled.
   recorder.set_ready(false);
   profile.reset(new TestingProfile());
   command_line->AppendSwitch(switches::kDisableExtensions);
-  service = profile->CreateExtensionsService(command_line.get(),
+  service = profile->CreateExtensionService(command_line.get(),
                                              install_dir);
   EXPECT_FALSE(service->extensions_enabled());
   service->Init();
   loop.RunAllPending();
   EXPECT_TRUE(recorder.ready());
 
   recorder.set_ready(false);
   profile.reset(new TestingProfile());
   profile->GetPrefs()->SetBoolean(prefs::kDisableExtensions, true);
-  service = profile->CreateExtensionsService(command_line.get(),
+  service = profile->CreateExtensionService(command_line.get(),
                                              install_dir);
   EXPECT_FALSE(service->extensions_enabled());
   service->Init();
   loop.RunAllPending();
   EXPECT_TRUE(recorder.ready());
 
   recorder.set_ready(false);
   profile.reset(new TestingProfile());
   profile->GetPrefs()->SetBoolean(prefs::kDisableExtensions, true);
   command_line.reset(new CommandLine(CommandLine::NO_PROGRAM));
-  service = profile->CreateExtensionsService(command_line.get(),
+  service = profile->CreateExtensionService(command_line.get(),
                                              install_dir);
   EXPECT_FALSE(service->extensions_enabled());
   service->Init();
   loop.RunAllPending();
   EXPECT_TRUE(recorder.ready());
 
   // Explicitly delete all the resources used in this test.
   profile.reset();
   service = NULL;
 }
 
 // Test loading extensions that require limited and unlimited storage quotas.
-TEST_F(ExtensionsServiceTest, StorageQuota) {
-  InitializeEmptyExtensionsService();
+TEST_F(ExtensionServiceTest, StorageQuota) {
+  InitializeEmptyExtensionService();
 
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions")
       .AppendASCII("storage_quota");
 
   FilePath limited_quota_ext = extensions_path.AppendASCII("limited_quota")
       .AppendASCII("1.0");
 
   // The old permission name for unlimited quota was "unlimited_storage", but
@@ skipping 37 matching lines @@
                              1, &database_size, &unlimited_quota);
   db_tracker->DatabaseClosed(unlimited_quota_identifier, db_name);
   EXPECT_EQ(kint64max, unlimited_quota);
   db_tracker->DatabaseOpened(unlimited_quota_identifier2, db_name, description,
                              1, &database_size, &unlimited_quota);
   db_tracker->DatabaseClosed(unlimited_quota_identifier2, db_name);
 
   EXPECT_EQ(kint64max, unlimited_quota);
 }
 
-// Tests ExtensionsService::register_component_extension().
-TEST_F(ExtensionsServiceTest, ComponentExtensions) {
-  InitializeEmptyExtensionsService();
+// Tests ExtensionService::register_component_extension().
+TEST_F(ExtensionServiceTest, ComponentExtensions) {
+  InitializeEmptyExtensionService();
 
   // Component extensions should work even when extensions are disabled.
   set_extensions_enabled(false);
 
   FilePath path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &path));
   path = path.AppendASCII("extensions")
       .AppendASCII("good")
       .AppendASCII("Extensions")
       .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj")
       .AppendASCII("1.0.0.0");
 
   std::string manifest;
   ASSERT_TRUE(file_util::ReadFileToString(
       path.Append(Extension::kManifestFilename), &manifest));
 
   service_->register_component_extension(
-      ExtensionsService::ComponentExtensionInfo(manifest, path));
+      ExtensionService::ComponentExtensionInfo(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(Extension::COMPONENT, loaded_[0]->location());
   EXPECT_EQ(1u, service_->extensions()->size());
 
   // Component extensions shouldn't get recourded in the prefs.
   ValidatePrefKeyCount(0);
 
   // Reload all extensions, and make sure it comes back.
   std::string extension_id = service_->extensions()->at(0)->id();
   loaded_.clear();
   service_->ReloadExtensions();
   ASSERT_EQ(1u, service_->extensions()->size());
   EXPECT_EQ(extension_id, service_->extensions()->at(0)->id());
 }