Cleanup: Constify some ProfileKeyedBaseFactory methods and all overrides. Remove ProfileKeyedBaseFa…

chrome/browser/extensions/extension_service_unittest.cc

 // Copyright (c) 2012 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/extension_service_unittest.h"
 
 #include <algorithm>
 #include <set>
 #include <vector>
 
@@ skipping 227 matching lines @@
   // VisitRegisteredExtension(), which must be a const method to inherit
   // from the class being mocked.
   mutable int visit_count_;
 
   DISALLOW_COPY_AND_ASSIGN(MockExtensionProvider);
 };
 
 class MockProviderVisitor
     : public extensions::ExternalProviderInterface::VisitorInterface {
  public:
-
   // The provider will return |fake_base_path| from
   // GetBaseCrxFilePath().  User can test the behavior with
   // and without an empty path using this parameter.
   explicit MockProviderVisitor(FilePath fake_base_path)
       : ids_found_(0),
         fake_base_path_(fake_base_path),
         expected_creation_flags_(Extension::NO_FLAGS) {
   }
 
   MockProviderVisitor(FilePath fake_base_path, int expected_creation_flags)
@@ skipping 144 matching lines @@
   // 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;
   MessageLoop::current()->RunAllPending();
   profile_.reset(NULL);
   MessageLoop::current()->RunAllPending();
 }
 
 void ExtensionServiceTestBase::InitializeExtensionService(
-    const FilePath& pref_file, const FilePath& extensions_install_dir,
+    const FilePath& profile_path,
+    const FilePath& pref_file,
+    const FilePath& extensions_install_dir,
     bool autoupdate_enabled) {
-  TestingProfile* profile = new TestingProfile();
+  TestingProfile::Builder profile_builder;
   // Create a PrefService that only contains user defined preference values.
-  PrefService* prefs =
-      PrefServiceMockBuilder().WithUserFilePrefs(pref_file).Create();
-  Profile::RegisterUserPrefs(prefs);
-  chrome::RegisterUserPrefs(prefs);
-  profile->SetPrefService(prefs);
+  scoped_ptr<PrefService> prefs(
+      PrefServiceMockBuilder().WithUserFilePrefs(pref_file).Create());
+  Profile::RegisterUserPrefs(prefs.get());
+  chrome::RegisterUserPrefs(prefs.get());
+  profile_builder.SetPrefService(prefs.Pass());
+  profile_builder.SetPath(profile_path);
+  profile_ = profile_builder.Build();
 
 #if defined(ENABLE_THEMES)
-  ThemeServiceFactory::GetInstance()->ForceRegisterPrefsForTest(prefs);
+  ThemeServiceFactory::GetInstance()->RegisterUserPrefsOnProfile(

[Lei Zhang, 2012/09/05 19:16:26]

It also occurred to me, we probably don't need these
RegisterUserPrefsOnProfile() calls, since they are auto-registered when the test
profile gets created.

[Elliot Glaysher, 2012/09/05 19:35:39]

Are you sure? I think this is a different prefservice than the profile one.

+      profile_.get());
 #endif
-  PluginPrefsFactory::GetInstance()->ForceRegisterPrefsForTest(prefs);
-
-  profile_.reset(profile);
+  PluginPrefsFactory::GetInstance()->RegisterUserPrefsOnProfile(profile_.get());
 
   service_ = static_cast<extensions::TestExtensionSystem*>(
-      ExtensionSystem::Get(profile))->CreateExtensionService(
+      ExtensionSystem::Get(profile_.get()))->CreateExtensionService(
           CommandLine::ForCurrentProcess(),
           extensions_install_dir,
           autoupdate_enabled);
   service_->set_extensions_enabled(true);
   service_->set_show_extensions_prompts(false);
 
   management_policy_ = static_cast<extensions::TestExtensionSystem*>(
-      ExtensionSystem::Get(profile))->CreateManagementPolicy();
+      ExtensionSystem::Get(profile_.get()))->CreateManagementPolicy();
 
   // 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();
 
   expected_extensions_count_ = 0;
 }
 
 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"));
+  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"));
+  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);
 
-  InitializeExtensionService(temp_prefs, extensions_install_dir_, false);
+  InitializeExtensionService(path, temp_prefs, extensions_install_dir_, false);
 }
 
 void ExtensionServiceTestBase::InitializeEmptyExtensionService() {
   InitializeExtensionServiceHelper(false);
 }
 
 void ExtensionServiceTestBase::InitializeExtensionProcessManager() {
   static_cast<extensions::TestExtensionSystem*>(
       ExtensionSystem::Get(profile_.get()))->
       CreateExtensionProcessManager();
 }
 
 void ExtensionServiceTestBase::InitializeExtensionServiceWithUpdater() {
   InitializeExtensionServiceHelper(true);
   service_->updater()->Start();
 }
 
 void ExtensionServiceTestBase::InitializeExtensionServiceHelper(
     bool autoupdate_enabled) {
   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"));
+  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_);
 
-  InitializeExtensionService(prefs_filename, extensions_install_dir_,
+  InitializeExtensionService(path, prefs_filename, extensions_install_dir_,
                              autoupdate_enabled);
 }
 
 void ExtensionServiceTestBase::InitializeRequestContext() {
   ASSERT_TRUE(profile_.get());
   TestingProfile* profile =
       static_cast<TestingProfile*>(profile_.get());
   profile->CreateRequestContext();
 }
 
@@ skipping 523 matching lines @@
   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,
                                             ExtensionCreator::ErrorType type) {
   if (type == ExtensionCreator::kCRXExists)
      FAIL() << "Packing should not fail.";
   else
      FAIL() << "Existing CRX should have been overwritten.";
-
 }
 
 // Test loading good extensions from the profile directory.
 TEST_F(ExtensionServiceTest, LoadAllExtensionsFromDirectorySuccess) {
   PluginService::GetInstance()->Init();
 
   // Initialize the test dir with a good Preferences/extensions.
   FilePath source_install_dir = data_dir_
       .AppendASCII("good")
       .AppendASCII("Extensions");
@@ skipping 3567 matching lines @@
   service_->MergeDataAndStartSyncing(syncer::APPS, syncer::SyncDataList(),
       scoped_ptr<syncer::SyncChangeProcessor>(new TestSyncProcessorStub),
       scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
 
   service_->OnExtensionMoved(apps[0]->id(), apps[1]->id(), apps[2]->id());
   {
     syncer::SyncDataList list = service_->GetAllSyncData(syncer::APPS);
     ASSERT_EQ(list.size(), 3U);
 
     extensions::AppSyncData data[kAppCount];
-    for (size_t i = 0; i < kAppCount; ++i)
-    {
+    for (size_t i = 0; i < kAppCount; ++i) {
       data[i] = extensions::AppSyncData(list[i]);
     }
 
     // The sync data is not always in the same order our apps were installed in,
     // so we do that sorting here so we can make sure the values are changed as
     // expected.
     StringOrdinal app_launch_ordinals[kAppCount];
     for (size_t i = 0; i < kAppCount; ++i) {
       for (size_t j = 0; j < kAppCount; ++j) {
         if (apps[i]->id() == data[j].id())
@@ skipping 785 matching lines @@
   // This should NOT trigger an alert.
   provider->UpdateOrAddExtension(hosted_app, "1.0.0.0",
                                  data_dir_.AppendASCII("hosted_app.crx"));
 
   service_->CheckForExternalUpdates();
   loop_.RunAllPending();
 
   ASSERT_TRUE(service_->PopulateExtensionErrorUI(extension_error_ui.get()));
   ASSERT_EQ(1u, extension_error_ui->get_external_extension_ids()->size());
 }