Move ExtensionServiceTestBase into it's own header/cc file

chrome/browser/extensions/extension_service_unittest.cc

 // Copyright (c) 2013 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>
 
 #include "base/at_exit.h"
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_string_value_serializer.h"
 #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 "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/version.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/app_sync_data.h"
 #include "chrome/browser/extensions/blacklist.h"
 #include "chrome/browser/extensions/chrome_app_sorting.h"
 #include "chrome/browser/extensions/component_loader.h"
 #include "chrome/browser/extensions/crx_installer.h"
 #include "chrome/browser/extensions/default_apps.h"
 #include "chrome/browser/extensions/extension_creator.h"
 #include "chrome/browser/extensions/extension_error_reporter.h"
 #include "chrome/browser/extensions/extension_error_ui.h"
-#include "chrome/browser/extensions/extension_garbage_collector_factory.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_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/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/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/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/test/base/scoped_browser_locale.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/pref_registry/pref_registry_syncable.h"
@@ skipping 11 matching lines @@
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/external_provider_interface.h"
 #include "extensions/browser/management_policy.h"
 #include "extensions/browser/pref_names.h"
 #include "extensions/browser/test_management_policy.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 "grit/browser_resources.h"
 #include "net/cookies/canonical_cookie.h"
@@ skipping 11 matching lines @@
 #include "sync/protocol/extension_specifics.pb.h"
 #include "sync/protocol/sync.pb.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 #include "url/gurl.h"
 #include "webkit/browser/database/database_tracker.h"
 #include "webkit/browser/quota/quota_manager.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/users/user_manager.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/chromeos/settings/device_settings_service.h"
 #endif
 
 // The blacklist tests rely on safe browsing.
 #if defined(FULL_SAFE_BROWSING) || defined(MOBILE_SAFE_BROWSING)
 #define ENABLE_BLACKLIST_TESTS
 #endif
 
@@ skipping 311 matching lines @@
   int ids_found_;
   base::FilePath fake_base_path_;
   int expected_creation_flags_;
   scoped_ptr<extensions::ExternalProviderImpl> provider_;
   scoped_ptr<base::DictionaryValue> prefs_;
   scoped_ptr<TestingProfile> profile_;
 
   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());
-  extensions::ExtensionGarbageCollectorFactory::GetInstance()
-      ->SetTestingFactoryAndUse(
-          profile_.get(),
-          &extensions::ExtensionGarbageCollectorFactory::BuildInstanceFor);
-}
-
-// 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(), ExtensionPrefs::Get(profile_.get()), 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()
       : unloaded_reason_(UnloadedExtensionInfo::REASON_UNDEFINED),
         installed_(NULL),
         was_update_(false),
         override_external_install_prompt_(
             FeatureSwitch::prompt_for_external_extensions(),
-            false) {
+            false),
+        expected_extensions_count_(0) {
     registrar_.Add(this,
                    chrome::NOTIFICATION_EXTENSION_LOADED_DEPRECATED,
                    content::NotificationService::AllSources());
     registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED,
                    content::NotificationService::AllSources());
     registrar_.Add(this,
                    chrome::NOTIFICATION_EXTENSION_INSTALLED_DEPRECATED,
                    content::NotificationService::AllSources());
   }
 
@@ skipping 36 matching lines @@
         break;
       }
 
       default:
         DCHECK(false);
     }
   }
 
   void AddMockExternalProvider(
       extensions::ExternalProviderInterface* provider) {
-    service_->AddProviderForTesting(provider);
+    service()->AddProviderForTesting(provider);
   }
 
   void MockSyncStartFlare(bool* was_called,
                           syncer::ModelType* model_type_passed_in,
                           syncer::ModelType model_type) {
     *was_called = true;
     *model_type_passed_in = model_type;
   }
 
  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,
                             Manifest::Location location);
 
   void PackCRX(const base::FilePath& dir_path,
                const base::FilePath& pem_path,
                const base::FilePath& crx_path) {
     // Use the existing pem key, if provided.
     base::FilePath pem_output_path;
@@ skipping 81 matching lines @@
     InstallCRXInternal(path, Extension::FROM_WEBSTORE);
     return VerifyCrxInstall(path, install_state);
   }
 
   const Extension* InstallCRXWithLocation(const base::FilePath& crx_path,
                                           Manifest::Location install_location,
                                           InstallState install_state) {
     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,
         content::NotificationService::AllSources());
     installer->InstallCrx(crx_path);
     observer.Wait();
 
     return VerifyCrxInstall(crx_path, install_state);
   }
@@ skipping 27 matching lines @@
           << path.value();
       // If INSTALL_UPDATED, old_name_ should match the given string.
       if (install_state == INSTALL_UPDATED && !expected_old_name.empty())
         EXPECT_EQ(expected_old_name, old_name_);
       EXPECT_EQ(0u, errors.size()) << path.value();
 
       if (install_state == INSTALL_WITHOUT_LOAD) {
         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();
       }
 
       for (std::vector<base::string16>::iterator err = errors.begin();
         err != errors.end(); ++err) {
         LOG(ERROR) << *err;
       }
     } else {
       EXPECT_FALSE(installed_) << path.value();
       EXPECT_EQ(0u, loaded_.size()) << path.value();
@@ skipping 43 matching lines @@
            *installer;
   }
 
   void UpdateExtension(const std::string& id,
                        const base::FilePath& in_path,
                        UpdateState expected_state) {
     ASSERT_TRUE(base::PathExists(in_path));
 
     // 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,
         base::Bind(&IsCrxInstallerDone, &installer));
-    service_->UpdateExtension(id, path, true, &installer);
+    service()->UpdateExtension(id, path, true, &installer);
 
     if (installer)
       observer.Wait();
     else
       base::RunLoop().RunUntilIdle();
 
     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();
 
     if (expected_state <= FAILED) {
       EXPECT_EQ(previous_enabled_extension_count,
                 enabled_extension_count);
       EXPECT_EQ(previous_installed_extension_count,
                 installed_extension_count);
     } else {
       int expected_installed_extension_count =
           (expected_state >= INSTALLED) ? 1 : 0;
       int expected_enabled_extension_count =
           (expected_state >= ENABLED) ? 1 : 0;
       EXPECT_EQ(expected_installed_extension_count,
                 installed_extension_count);
       EXPECT_EQ(expected_enabled_extension_count,
                 enabled_extension_count);
     }
 
     // Update() should the temporary input file.
     EXPECT_FALSE(base::PathExists(path));
   }
 
   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;
     }
     return dict->size();
   }
 
   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);
     ValidateIntegerPref(id, "state", Extension::ENABLED);
 
     // Uninstall it.
     if (use_helper) {
-      EXPECT_TRUE(ExtensionService::UninstallExtensionHelper(service_, id));
+      EXPECT_TRUE(ExtensionService::UninstallExtensionHelper(service(), id));
     } else {
-      EXPECT_TRUE(service_->UninstallExtension(id, false, NULL));
+      EXPECT_TRUE(service()->UninstallExtension(id, false, NULL));
     }
     --expected_extensions_count_;
 
     // We should get an unload notification.
     EXPECT_FALSE(unloaded_id_.empty());
     EXPECT_EQ(id, unloaded_id_);
 
     // Verify uninstalled state.
     size_t new_pref_key_count = GetPrefKeyCount();
     if (new_pref_key_count == pref_key_count) {
       ValidateIntegerPref(id, "location",
                           Extension::EXTERNAL_EXTENSION_UNINSTALLED);
     } else {
       EXPECT_EQ(new_pref_key_count, pref_key_count - 1);
     }
 
     // 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.
     EXPECT_FALSE(base::PathExists(extension_path));
   }
 
   void ValidatePrefKeyCount(size_t count) {
     EXPECT_EQ(count, GetPrefKeyCount());
   }
 
   testing::AssertionResult ValidateBooleanPref(
       const std::string& extension_id,
       const std::string& pref_path,
       bool expected_val) {
     std::string msg = "while checking: ";
     msg += extension_id;
     msg += " ";
     msg += pref_path;
     msg += " == ";
     msg += expected_val ? "true" : "false";
 
-    PrefService* prefs = profile_->GetPrefs();
+    PrefService* prefs = profile()->GetPrefs();
     const base::DictionaryValue* dict =
         prefs->GetDictionary("extensions.settings");
     if (!dict) {
       return testing::AssertionFailure()
           << "extension.settings does not exist " << msg;
     }
 
     const base::DictionaryValue* pref = NULL;
     if (!dict->GetDictionary(extension_id, &pref)) {
       return testing::AssertionFailure()
           << "extension pref does not exist " << msg;
     }
 
     bool val;
     if (!pref->GetBoolean(pref_path, &val)) {
       return testing::AssertionFailure()
           << pref_path << " pref not found " << msg;
     }
 
     return expected_val == val
         ? testing::AssertionSuccess()
         : testing::AssertionFailure() << "base::Value is incorrect " << msg;
   }
 
   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)) {
       return false;
     }
     if (pref == NULL) {
       return false;
     }
     bool val;
     if (!pref->GetBoolean(pref_path, &val)) {
       return false;
     }
     return true;
   }
 
   void ValidateIntegerPref(const std::string& extension_id,
                            const std::string& pref_path,
                            int expected_val) {
     std::string msg = " while checking: ";
     msg += extension_id;
     msg += " ";
     msg += pref_path;
     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;
     const base::DictionaryValue* pref = NULL;
     ASSERT_TRUE(dict->GetDictionary(extension_id, &pref)) << msg;
     EXPECT_TRUE(pref != NULL) << msg;
     int val;
     ASSERT_TRUE(pref->GetInteger(pref_path, &val)) << msg;
     EXPECT_EQ(expected_val, val) << msg;
   }
 
   void ValidateStringPref(const std::string& extension_id,
                           const std::string& pref_path,
                           const std::string& expected_val) {
     std::string msg = " while checking: ";
     msg += extension_id;
     msg += ".manifest.";
     msg += pref_path;
     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";
     ASSERT_TRUE(dict->GetDictionary(manifest_path, &pref)) << msg;
     EXPECT_TRUE(pref != NULL) << msg;
     std::string val;
     ASSERT_TRUE(pref->GetString(pref_path, &val)) << msg;
     EXPECT_EQ(expected_val, val) << msg;
   }
 
   void SetPref(const std::string& extension_id,
                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;
     ASSERT_TRUE(dict->GetDictionary(extension_id, &pref)) << msg;
     EXPECT_TRUE(pref != NULL) << msg;
     pref->Set(pref_path, value);
   }
 
   void SetPrefInteg(const std::string& extension_id,
                     const std::string& pref_path,
@@ skipping 17 matching lines @@
     msg += (value ? "true" : "false");
 
     SetPref(extension_id, pref_path, new base::FundamentalValue(value), msg);
   }
 
   void ClearPref(const std::string& extension_id,
                  const std::string& pref_path) {
     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;
     ASSERT_TRUE(dict->GetDictionary(extension_id, &pref)) << msg;
     EXPECT_TRUE(pref != NULL) << msg;
     pref->Remove(pref_path, NULL);
   }
 
   void SetPrefStringSet(const std::string& extension_id,
                         const std::string& pref_path,
                         const std::set<std::string>& value) {
     std::string msg = " while setting: ";
     msg += extension_id + " " + pref_path;
 
     base::ListValue* list_value = new base::ListValue();
     for (std::set<std::string>::const_iterator iter = value.begin();
          iter != value.end(); ++iter)
       list_value->Append(new base::StringValue(*iter));
 
     SetPref(extension_id, pref_path, list_value, msg);
   }
 
   void InitPluginService() {
 #if defined(ENABLE_PLUGINS)
     PluginService::GetInstance()->Init();
 #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_;
   FeatureSwitch::ScopedOverride override_external_install_prompt_;
 
  private:
   // Create a CrxInstaller and install the CRX file.
   // Instead of calling this method yourself, use InstallCRX(), which does extra
   // error checking.
   void InstallCRXInternal(const base::FilePath& crx_path) {
     InstallCRXInternal(crx_path, Extension::NO_FLAGS);
   }
 
   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,
         content::Source<extensions::CrxInstaller>(installer));
 
     installer->InstallCrx(crx_path);
 
     observer.Wait();
   }
 
+  size_t expected_extensions_count_;

[Devlin, 2014/06/10 21:46:06]

STOP!  Every change past this line is the result of git cl format and using
accessors instead of direct member variables (e.g., service_ -> service()).

   content::NotificationRegistrar registrar_;
 };
 
 // Receives notifications from a PackExtensionJob, indicating either that
 // packing succeeded or that there was some error.
 class PackExtensionTestClient : public extensions::PackExtensionJob::Client {
  public:
   PackExtensionTestClient(const base::FilePath& expected_crx_path,
                           const base::FilePath& expected_private_key_path);
   virtual void OnPackSuccess(const base::FilePath& crx_path,
@@ skipping 35 matching lines @@
   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) {
   InitPluginService();
   InitializeGoodInstalledExtensionService();
-  service_->Init();
+  service()->Init();
 
   uint32 expected_num_extensions = 3u;
   ASSERT_EQ(expected_num_extensions, loaded_.size());
 
   EXPECT_EQ(std::string(good0), loaded_[0]->id());
   EXPECT_EQ(std::string("My extension 1"),
             loaded_[0]->name());
   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);
   ValidateIntegerPref(good0, "location", Manifest::INTERNAL);
   ValidateIntegerPref(good1, "state", Extension::ENABLED);
   ValidateIntegerPref(good1, "location", Manifest::INTERNAL);
   ValidateIntegerPref(good2, "state", Extension::ENABLED);
   ValidateIntegerPref(good2, "location", Manifest::INTERNAL);
 
   URLPatternSet expected_patterns;
@@ skipping 71 matching lines @@
   EXPECT_EQ(std::string(), loaded_[index]->description());
   EXPECT_EQ(0u,
             extensions::ContentScriptsInfo::GetContentScripts(
                 loaded_[index].get()).size());
   EXPECT_EQ(Manifest::INTERNAL, loaded_[index]->location());
 };
 
 // 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());
 
   EXPECT_TRUE(MatchPattern(base::UTF16ToUTF8(GetErrors()[0]),
       std::string("Could not load extension from '*'. ") +
       extensions::manifest_errors::kManifestUnreadable)) <<
       base::UTF16ToUTF8(GetErrors()[0]);
 
   EXPECT_TRUE(MatchPattern(base::UTF16ToUTF8(GetErrors()[1]),
       std::string("Could not load extension from '*'. ") +
       extensions::manifest_errors::kManifestUnreadable)) <<
       base::UTF16ToUTF8(GetErrors()[1]);
 
   EXPECT_TRUE(MatchPattern(base::UTF16ToUTF8(GetErrors()[2]),
       std::string("Could not load extension from '*'. ") +
       extensions::manifest_errors::kMissingFile)) <<
       base::UTF16ToUTF8(GetErrors()[2]);
 
   EXPECT_TRUE(MatchPattern(base::UTF16ToUTF8(GetErrors()[3]),
       std::string("Could not load extension from '*'. ") +
       extensions::manifest_errors::kManifestUnreadable)) <<
       base::UTF16ToUTF8(GetErrors()[3]);
 };
 
 // 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 = ExtensionPrefs::Get(profile_.get());
+  ExtensionPrefs* prefs = ExtensionPrefs::Get(profile());
   EXPECT_FALSE(
       prefs->GetDelayedInstallInfo("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"));
   EXPECT_FALSE(
       prefs->GetInstalledExtensionInfo("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"));
   EXPECT_FALSE(
       prefs->GetDelayedInstallInfo("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"));
   EXPECT_FALSE(
       prefs->GetInstalledExtensionInfo("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"));
   EXPECT_FALSE(
       prefs->GetDelayedInstallInfo("cccccccccccccccccccccccccccccccc"));
   EXPECT_FALSE(
       prefs->GetInstalledExtensionInfo("cccccccccccccccccccccccccccccccc"));
 
   // Make sure the import started for the extension with a dependency.
   EXPECT_TRUE(
       prefs->GetDelayedInstallInfo("behllobkkfkfnphdnhnkndlbkcpglgmj"));
   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
 // 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(ExtensionServiceTest, InstallExtension) {
   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.
 
   int pref_count = 0;
   ValidatePrefKeyCount(++pref_count);
   ValidateIntegerPref(good_crx, "state", Extension::ENABLED);
   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);
   ValidateIntegerPref(good2048, "location", Manifest::INTERNAL);
 
   // TODO(erikkay): add more tests for many of the failure cases.
   // TODO(erikkay): add tests for upgrade cases.
 }
 
 struct MockInstallObserver : public extensions::InstallObserver {
@@ skipping 14 matching lines @@
   std::string last_extension_installed;
   std::string last_extension_uninstalled;
 };
 
 // Test that correct notifications are sent to InstallTracker observers on
 // extension install and uninstall.
 TEST_F(ExtensionServiceTest, InstallObserverNotified) {
   InitializeEmptyExtensionService();
 
   extensions::InstallTracker* tracker(
-      extensions::InstallTrackerFactory::GetForProfile(profile_.get()));
+      extensions::InstallTrackerFactory::GetForProfile(profile()));
   MockInstallObserver observer;
   tracker->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);
 
   // Uninstall the extension.
   ASSERT_TRUE(observer.last_extension_uninstalled.empty());
   UninstallExtension(good_crx, false);
   ASSERT_EQ(good_crx, observer.last_extension_uninstalled);
 
   tracker->RemoveObserver(&observer);
 }
 
 // Tests that flags passed to OnExternalExtensionFileFound() make it to the
 // extension object.
 TEST_F(ExtensionServiceTest, InstallingExternalExtensionWithFlags) {
   const char kPrefFromBookmark[] = "from_bookmark";
 
   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,
       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 the handling of Extension::EXTERNAL_EXTENSION_UNINSTALLED
 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,
       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);
   ValidateIntegerPref(good_crx, "location",
                       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
 // the extension could not be loaded.
 // 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
       .DirName()
       .AppendASCII("PreferencesExperimental");
 
   // Aforementioned extension will not be loaded if
   // 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");
 
   const std::string wrong_id = all_zero;
   const std::string correct_id = good_crx;
   ASSERT_NE(correct_id, wrong_id);
 
   // 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,
       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,
       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,
       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,
       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)
 TEST_F(ExtensionServiceTest, InstallUserScript) {
   // The details of script conversion are tested elsewhere, this just tests
   // 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,
       GURL("http://www.aaronboodman.com/scripts/user_script_basic.user.js"));
 
   base::RunLoop().RunUntilIdle();
   std::vector<base::string16> errors = GetErrors();
   EXPECT_TRUE(installed_) << "Nothing was installed.";
   EXPECT_FALSE(was_update_) << path.value();
   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;
   loaded_.clear();
   ExtensionErrorReporter::GetInstance()->ClearErrors();
 }
 
 // Extensions don't install during shutdown.
 TEST_F(ExtensionServiceTest, InstallExtensionDuringShutdown) {
   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();
 
   EXPECT_FALSE(installed_) << "Extension installed during shutdown.";
   ASSERT_EQ(0u, loaded_.size()) << "Extension loaded during shutdown.";
 }
 
 // This tests that the granted permissions preferences are correctly set when
 // 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 = ExtensionPrefs::Get(profile_.get());
+  ExtensionPrefs* prefs = ExtensionPrefs::Get(profile());
 
   APIPermissionSet expected_api_perms;
   URLPatternSet expected_host_perms;
 
   // Make sure there aren't any granted permissions before the
   // extension is installed.
   scoped_refptr<PermissionSet> known_perms(
       prefs->GetGrantedPermissions(permissions_crx));
   EXPECT_FALSE(known_perms.get());
 
   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.
   expected_api_perms.insert(APIPermission::kTab);
 
   AddPattern(&expected_host_perms, "http://*.google.com/*");
   AddPattern(&expected_host_perms, "https://*.google.com/*");
   AddPattern(&expected_host_perms, "http://*.google.com.hk/*");
   AddPattern(&expected_host_perms, "http://www.example.com/*");
 
   known_perms = prefs->GetGrantedPermissions(extension->id());
   EXPECT_TRUE(known_perms.get());
   EXPECT_FALSE(known_perms->IsEmpty());
   EXPECT_EQ(expected_api_perms, known_perms->apis());
   EXPECT_FALSE(known_perms->HasEffectiveFullAccess());
   EXPECT_EQ(expected_host_perms, known_perms->effective_hosts());
 }
 
 
 #if !defined(OS_CHROMEOS)
 // This tests that the granted permissions preferences are correctly set for
 // 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 = ExtensionPrefs::Get(profile_.get());
+  ExtensionPrefs* prefs = ExtensionPrefs::Get(profile());
 
   APIPermissionSet expected_api_perms;
   URLPatternSet expected_host_perms;
 
   // Make sure there aren't any granted permissions before the
   // extension is installed.
   scoped_refptr<PermissionSet> known_perms(
       prefs->GetGrantedPermissions(permissions_crx));
   EXPECT_FALSE(known_perms.get());
 
   const Extension* extension = PackAndInstallCRX(
       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.
   expected_api_perms.insert(APIPermission::kTab);
 
   known_perms = prefs->GetGrantedPermissions(extension->id());
   EXPECT_TRUE(known_perms.get());
   EXPECT_FALSE(known_perms->IsEmpty());
   EXPECT_EQ(expected_api_perms, known_perms->apis());
   EXPECT_FALSE(known_perms->HasEffectiveFullAccess());
 }
 #endif
 
 #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.
 // Only run this on platforms that support NPAPI plugins.
 TEST_F(ExtensionServiceTest, GrantedFullAccessPermissions) {
   InitPluginService();
 
   InitializeEmptyExtensionService();
 
   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 = ExtensionPrefs::Get(profile_.get());
+  EXPECT_EQ(1u, registry()->enabled_extensions().size());
+  ExtensionPrefs* prefs = ExtensionPrefs::Get(profile());
 
   scoped_refptr<PermissionSet> permissions(
       prefs->GetGrantedPermissions(extension->id()));
   EXPECT_FALSE(permissions->IsEmpty());
   EXPECT_TRUE(permissions->HasEffectiveFullAccess());
   EXPECT_FALSE(permissions->apis().empty());
   EXPECT_TRUE(permissions->HasAPIPermission(APIPermission::kPlugin));
 
   // Full access implies full host access too...
   EXPECT_TRUE(permissions->HasEffectiveAccessToAllHosts());
 }
 #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(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 = ExtensionPrefs::Get(profile_.get());
+  ExtensionPrefs* prefs = ExtensionPrefs::Get(profile());
 
   APIPermissionSet expected_api_permissions;
   URLPatternSet expected_host_permissions;
 
   expected_api_permissions.insert(APIPermission::kTab);
   AddPattern(&expected_host_permissions, "http://*.google.com/*");
   AddPattern(&expected_host_permissions, "https://*.google.com/*");
   AddPattern(&expected_host_permissions, "http://*.google.com.hk/*");
   AddPattern(&expected_host_permissions, "http://www.example.com/*");
 
   std::set<std::string> host_permissions;
 
   // Test that the extension is disabled when an API permission is missing from
   // the extension's granted api permissions preference. (This simulates
   // 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(
       prefs->GetGrantedPermissions(extension_id));
   ASSERT_TRUE(current_perms.get());
   ASSERT_FALSE(current_perms->IsEmpty());
   ASSERT_FALSE(current_perms->HasEffectiveFullAccess());
   ASSERT_EQ(expected_api_permissions, current_perms->apis());
   ASSERT_EQ(expected_host_permissions, current_perms->effective_hosts());
 
   // Tests that the extension is disabled when a host permission is missing from
   // the extension's granted host permissions preference. (This simulates
   // updating the browser to a version which recognizes additional host
   // permissions).
   host_permissions.clear();
   current_perms = NULL;
 
   host_permissions.insert("http://*.google.com/*");
   host_permissions.insert("https://*.google.com/*");
   host_permissions.insert("http://*.google.com.hk/*");
 
   base::ListValue* api_permissions = new base::ListValue();
   api_permissions->Append(
       new base::StringValue("tabs"));
   SetPref(extension_id, "granted_permissions.api",
           api_permissions, "granted_permissions.api");
   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);
   ASSERT_TRUE(current_perms.get());
   ASSERT_FALSE(current_perms->IsEmpty());
   ASSERT_FALSE(current_perms->HasEffectiveFullAccess());
   ASSERT_EQ(expected_api_permissions, current_perms->apis());
   ASSERT_EQ(expected_host_permissions, current_perms->effective_hosts());
 }
 
 // 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());
   base::FilePath output_directory = temp_dir.path();
 
   base::FilePath crx_path(output_directory.AppendASCII("ex1.crx"));
   base::FilePath privkey_path(output_directory.AppendASCII("privkey.pem"));
 
   scoped_ptr<ExtensionCreator> creator(new ExtensionCreator());
   ASSERT_TRUE(creator->Run(input_directory, crx_path, base::FilePath(),
@@ skipping 37 matching lines @@
   std::string invalid_manifest_content = "I am not a manifest.";
   ASSERT_TRUE(base::WriteFile(
       temp_dir2.path().Append(extensions::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,
                             base::FilePath(), ExtensionCreator::kOverwriteCRX));
 
   // 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());
 
   // Extension names containing punctuation, and the expected names for the
   // packed extensions.
   const base::FilePath punctuated_names[] = {
     base::FilePath(FILE_PATH_LITERAL("this.extensions.name.has.periods")),
     base::FilePath(FILE_PATH_LITERAL(".thisextensionsnamestartswithaperiod")),
     base::FilePath(FILE_PATH_LITERAL("thisextensionhasaslashinitsname/")).
@@ skipping 45 matching lines @@
     InstallCRX(expected_crx_path, INSTALL_NEW);
   }
 }
 
 TEST_F(ExtensionServiceTest, PackExtensionContainingKeyFails) {
   InitializeEmptyExtensionService();
 
   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());
   base::FilePath output_directory = output_temp_dir.path();
 
   base::FilePath crx_path(output_directory.AppendASCII("ex1.crx"));
   base::FilePath privkey_path(output_directory.AppendASCII("privkey.pem"));
 
   // Pack the extension once to get a private key.
   scoped_ptr<ExtensionCreator> creator(new ExtensionCreator());
@@ skipping 17 matching lines @@
 }
 
 // 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(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;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   base::FilePath output_directory = temp_dir.path();
 
   base::FilePath crx_path(output_directory.AppendASCII("ex1.crx"));
 
   scoped_ptr<ExtensionCreator> creator(new ExtensionCreator());
   ASSERT_TRUE(creator->Run(input_directory, crx_path, privkey_path,
       base::FilePath(), ExtensionCreator::kOverwriteCRX));
 
   InstallCRX(crx_path, INSTALL_NEW);
 }
 
 #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);
   ValidateIntegerPref(theme_crx, "state", Extension::ENABLED);
   ValidateIntegerPref(theme_crx, "location", Manifest::INTERNAL);
 
   // 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);
   ValidateIntegerPref(theme2_crx, "location", Manifest::INTERNAL);
 
   // 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);
     EXPECT_TRUE(extension->is_theme());
     EXPECT_EQ(
         0u,
         extensions::ContentScriptsInfo::GetContentScripts(extension).size());
   }
 
   // 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());
 
   // Cleanup the "Cached Theme.pak" file. Ideally, this would be installed in a
   // temporary directory, but it automatically installs to the extension's
   // directory, and we don't want to copy the whole extension for a unittest.
   base::FilePath theme_file = extension_path.Append(chrome::kThemePackFilename);
   ASSERT_TRUE(base::PathExists(theme_file));
   ASSERT_TRUE(base::DeleteFile(theme_file, false));  // Not recursive.
 }
 
 // Tests that we can change the ID of an unpacked extension by adding a key
 // to its manifest.
 TEST_F(ExtensionServiceTest, UnpackedExtensionCanChangeID) {
   InitializeEmptyExtensionService();
 
   base::ScopedTempDir temp;
   ASSERT_TRUE(temp.CreateUniqueTempDir());
 
   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());
 
   // TODO(jstritar): Right now this just makes sure we don't crash and burn, but
   // we should also test that preferences are preserved.
 }
 
 #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");
   ASSERT_TRUE(base::PathExists(source_manifest));
   base::FilePath source_icon = source_data_dir.AppendASCII("icon.png");
   ASSERT_TRUE(base::PathExists(source_icon));
 
   // Set up the temporary extension directory.
   base::ScopedTempDir temp;
   ASSERT_TRUE(temp.CreateUniqueTempDir());
   base::FilePath extension_path = temp.path();
   base::FilePath manifest = extension_path.Append(
       extensions::kManifestFilename);
   base::FilePath icon_symlink = extension_path.AppendASCII("icon.png");
   base::CopyFile(source_manifest, manifest);
   base::CreateSymbolicLink(source_icon, icon_symlink);
 
   // 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());
 }
 
 TEST_F(ExtensionServiceTest, InstallApps) {
   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_EQ(1u, registry()->enabled_extensions().size());
   EXPECT_FALSE(
-      ExtensionPrefs::Get(profile_.get())->AllowFileAccess(extension->id()));
+      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());
 
   // 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());
 }
 
 // Verifies that the NTP page and launch ordinals are kept when updating apps.
 TEST_F(ExtensionServiceTest, UpdateAppsRetainOrdinals) {
   InitializeEmptyExtensionService();
-  AppSorting* sorting = ExtensionPrefs::Get(profile_.get())->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());
 
   // Modify the ordinals so we can distinguish them from the defaults.
   syncer::StringOrdinal new_page_ordinal =
       sorting->GetPageOrdinal(id).CreateAfter();
   syncer::StringOrdinal new_launch_ordinal =
       sorting->GetAppLaunchOrdinal(id).CreateBefore();
 
   sorting->SetPageOrdinal(id, new_page_ordinal);
   sorting->SetAppLaunchOrdinal(id, new_launch_ordinal);
 
   // 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)));
   ASSERT_TRUE(new_launch_ordinal.Equals(sorting->GetAppLaunchOrdinal(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 = ExtensionPrefs::Get(profile_.get())->app_sorting();
+  AppSorting* sorting = ExtensionPrefs::Get(profile())->app_sorting();
   EXPECT_TRUE(
       sorting->GetPageOrdinal(extension_misc::kWebStoreAppId).IsValid());
   EXPECT_TRUE(
       sorting->GetAppLaunchOrdinal(extension_misc::kWebStoreAppId).IsValid());
 }
 
 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->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->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.
 TEST_F(ExtensionServiceTest, Reinstall) {
   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);
   ValidateIntegerPref(good_crx, "state", Extension::ENABLED);
   ValidateIntegerPref(good_crx, "location", Manifest::INTERNAL);
 
   // Reinstall the same version, it should overwrite the previous one.
   InstallCRX(path, INSTALL_UPDATED);
 
   ValidatePrefKeyCount(1);
   ValidateIntegerPref(good_crx, "state", Extension::ENABLED);
   ValidateIntegerPref(good_crx, "location", Manifest::INTERNAL);
 }
 
 // Test that we can determine if extensions came from the
 // Chrome web store.
 TEST_F(ExtensionServiceTest, FromWebStore) {
   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();
 
   ValidatePrefKeyCount(1);
   ASSERT_TRUE(ValidateBooleanPref(good_crx, "from_webstore", false));
   ASSERT_FALSE(extension->from_webstore());
 
   // Test install from web store.
   InstallCRXFromWebStore(path, INSTALL_UPDATED);  // From web store.
 
   ValidatePrefKeyCount(1);
   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 upgrading a signed extension.
 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();
 
   ASSERT_EQ("1.0.0.0", extension->version()->GetString());
   ASSERT_EQ(0u, GetErrors().size());
 
   // 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());
   ASSERT_EQ(0u, GetErrors().size());
 }
 
 // Test upgrading a signed extension with a bad signature.
 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 a normal update via the UpdateExtension API
 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.
 TEST_F(ExtensionServiceTest, UpdateExtensionDuringShutdown) {
   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, 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());
 }
 
 // Makes sure you can't downgrade an extension via UpdateExtension
 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());
   UpdateExtension(good_crx, path, FAILED_SILENTLY);
 }
 
 // Tests that updating an extension does not clobber old state.
 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());
   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(), Extension::DISABLE_USER_ACTION);
-  extensions::util::SetIsIncognitoEnabled(good->id(), profile_.get(), true);
-  ExtensionPrefs::Get(profile_.get())
+  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(ExtensionPrefs::Get(profile_.get())
+  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);
 }
 
 // Makes sure that LOAD extension types can downgrade.
 TEST_F(ExtensionServiceTest, LoadExtensionsCanDowngrade) {
   InitializeEmptyExtensionService();
 
   base::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.
   base::FilePath extension_path = temp.path();
   base::FilePath manifest_path =
       extension_path.Append(extensions::kManifestFilename);
   ASSERT_FALSE(base::PathExists(manifest_path));
 
   // Start with version 2.0.
   base::DictionaryValue manifest;
   manifest.SetString("version", "2.0");
   manifest.SetString("name", "LOAD Downgrade Test");
   manifest.SetInteger("manifest_version", 2);
 
   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
   // the downgrade was accepted.
   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_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");
 
   // 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");
 
   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(
-      ExtensionPrefs::Get(profile_.get())->GetGrantedPermissions(good1));
+      ExtensionPrefs::Get(profile())->GetGrantedPermissions(good1));
   EXPECT_FALSE(permissions->IsEmpty());
   EXPECT_TRUE(permissions->HasEffectiveFullAccess());
   EXPECT_FALSE(permissions->apis().empty());
   EXPECT_TRUE(permissions->HasAPIPermission(APIPermission::kPlugin));
 
   // We should be able to reload the extension without getting another prompt.
   loaded_.clear();
   CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       switches::kAppsGalleryInstallAutoConfirmForTests,
       "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_POSIX) || defined(OS_MACOSX)
 
 namespace {
 
 bool IsExtension(const Extension* extension) {
   return extension->GetType() == Manifest::TYPE_EXTENSION;
 }
 
 #if defined(ENABLE_BLACKLIST_TESTS)
@@ skipping 14 matching lines @@
 // Test adding a pending extension.
 TEST_F(ExtensionServiceTest, AddPendingExtensionFromSync) {
   InitializeEmptyExtensionService();
 
   const std::string kFakeId(all_zero);
   const GURL kFakeUpdateURL("http:://fake.update/url");
   const bool kFakeInstallSilently(true);
   const bool kFakeRemoteInstall(false);
 
   EXPECT_TRUE(
-      service_->pending_extension_manager()->AddFromSync(kFakeId,
-                                                         kFakeUpdateURL,
-                                                         &IsExtension,
-                                                         kFakeInstallSilently,
-                                                         kFakeRemoteInstall));
+      service()->pending_extension_manager()->AddFromSync(kFakeId,
+                                                          kFakeUpdateURL,
+                                                          &IsExtension,
+                                                          kFakeInstallSilently,
+                                                          kFakeRemoteInstall));
 
   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 kGoodId[] = "ldnnhddmnhbkjipkidpdiheffobcpfmf";
 const char kGoodUpdateURL[] = "http://good.update/url";
 const bool kGoodIsFromSync = true;
 const bool kGoodInstallSilently = true;
 const bool kGoodRemoteInstall = false;
 }  // namespace
 
 // Test updating a pending extension.
 TEST_F(ExtensionServiceTest, UpdatePendingExtension) {
   InitializeEmptyExtensionService();
   EXPECT_TRUE(
-      service_->pending_extension_manager()->AddFromSync(kGoodId,
-                                                         GURL(kGoodUpdateURL),
-                                                         &IsExtension,
-                                                         kGoodInstallSilently,
-                                                         kGoodRemoteInstall));
-  EXPECT_TRUE(service_->pending_extension_manager()->IsIdPending(kGoodId));
+      service()->pending_extension_manager()->AddFromSync(kGoodId,
+                                                          GURL(kGoodUpdateURL),
+                                                          &IsExtension,
+                                                          kGoodInstallSilently,
+                                                          kGoodRemoteInstall));
+  EXPECT_TRUE(service()->pending_extension_manager()->IsIdPending(kGoodId));
 
-  base::FilePath path = data_dir_.AppendASCII("good.crx");
+  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);
 }
 
 namespace {
 
 bool IsTheme(const Extension* extension) {
   return extension->is_theme();
 }
 
 }  // namespace
 
 // Test updating a pending theme.
 // Disabled due to ASAN failure. http://crbug.com/108320
 TEST_F(ExtensionServiceTest, DISABLED_UpdatePendingTheme) {
   InitializeEmptyExtensionService();
-  EXPECT_TRUE(service_->pending_extension_manager()->AddFromSync(
+  EXPECT_TRUE(service()->pending_extension_manager()->AddFromSync(
       theme_crx, GURL(), &IsTheme, 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, 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(ExtensionPrefs::Get(profile_.get())
-                   ->IsExtensionDisabled(extension->id()));
-  EXPECT_TRUE(service_->IsExtensionEnabled(theme_crx));
+  EXPECT_FALSE(
+      ExtensionPrefs::Get(profile())->IsExtensionDisabled(extension->id()));
+  EXPECT_TRUE(service()->IsExtensionEnabled(theme_crx));
 }
 
 #if defined(OS_CHROMEOS)
 // Always fails on ChromeOS: http://crbug.com/79737
 #define MAYBE_UpdatePendingExternalCrx DISABLED_UpdatePendingExternalCrx
 #else
 #define MAYBE_UpdatePendingExternalCrx UpdatePendingExternalCrx
 #endif
 // 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(ExtensionServiceTest, MAYBE_UpdatePendingExternalCrx) {
   InitializeEmptyExtensionService();
-  EXPECT_TRUE(service_->pending_extension_manager()->AddFromExternalUpdateUrl(
+  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(ExtensionPrefs::Get(profile_.get())
-                   ->IsExtensionDisabled(extension->id()));
-  EXPECT_TRUE(service_->IsExtensionEnabled(extension->id()));
-  EXPECT_FALSE(extensions::util::IsIncognitoEnabled(extension->id(),
-                                                    profile_.get()));
+  EXPECT_FALSE(
+      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
 // 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(ExtensionServiceTest, UpdatePendingExternalCrxWinsOverSync) {
   InitializeEmptyExtensionService();
 
   // Add a crx to be installed from the update mechanism.
   EXPECT_TRUE(
-      service_->pending_extension_manager()->AddFromSync(kGoodId,
-                                                         GURL(kGoodUpdateURL),
-                                                         &IsExtension,
-                                                         kGoodInstallSilently,
-                                                         kGoodRemoteInstall));
+      service()->pending_extension_manager()->AddFromSync(kGoodId,
+                                                          GURL(kGoodUpdateURL),
+                                                          &IsExtension,
+                                                          kGoodInstallSilently,
+                                                          kGoodRemoteInstall));
 
   // 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(
+  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,
-                                                         kGoodRemoteInstall));
+      service()->pending_extension_manager()->AddFromSync(kGoodId,
+                                                          GURL(kGoodUpdateURL),
+                                                          &IsExtension,
+                                                          kGoodInstallSilently,
+                                                          kGoodRemoteInstall));
 
   // 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());
 }
 
 // Updating a theme should fail if the updater is explicitly told that
 // the CRX is not a theme.
 TEST_F(ExtensionServiceTest, UpdatePendingCrxThemeMismatch) {
   InitializeEmptyExtensionService();
-  EXPECT_TRUE(service_->pending_extension_manager()->AddFromSync(
+  EXPECT_TRUE(service()->pending_extension_manager()->AddFromSync(
       theme_crx, GURL(), &IsExtension, true, 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);
 }
 
 // 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 which fails the should-install test.
 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,
-                                                         kGoodRemoteInstall));
-  EXPECT_TRUE(service_->pending_extension_manager()->IsIdPending(kGoodId));
+      service()->pending_extension_manager()->AddFromSync(kGoodId,
+                                                          GURL(kGoodUpdateURL),
+                                                          &IsTheme,
+                                                          kGoodInstallSilently,
+                                                          kGoodRemoteInstall));
+  EXPECT_TRUE(service()->pending_extension_manager()->IsIdPending(kGoodId));
 
-  base::FilePath path = data_dir_.AppendASCII("good.crx");
+  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
 // unsyncable extensions are blocked.
 
 // Test updating a pending extension for one that is not 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
 // installed.
 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(
+  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)
 // Tests blacklisting then unblacklisting extensions after the service has been
 // initialized.
 TEST_F(ExtensionServiceTest, SetUnsetBlacklistInPrefs) {
   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));
   EXPECT_TRUE(enabled_extensions.Contains(good1) &&
               !blacklisted_extensions.Contains(good1));
   EXPECT_TRUE(enabled_extensions.Contains(good2) &&
               !blacklisted_extensions.Contains(good2));
 
   EXPECT_FALSE(IsPrefExist(good0, "blacklist"));
   EXPECT_FALSE(IsPrefExist(good1, "blacklist"));
@@ skipping 46 matching lines @@
 #endif  // defined(ENABLE_BLACKLIST_TESTS)
 
 #if defined(ENABLE_BLACKLIST_TESTS)
 // Tests trying to install a blacklisted extension.
 TEST_F(ExtensionServiceTest, BlacklistedExtensionWillNotInstall) {
   scoped_refptr<FakeSafeBrowsingDatabaseManager> blacklist_db(
       new FakeSafeBrowsingDatabaseManager(true));
   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)
 
 #if defined(ENABLE_BLACKLIST_TESTS)
 // Unload blacklisted extension on policy change.
 TEST_F(ExtensionServiceTest, UnloadBlacklistedExtensionPolicy) {
   extensions::TestBlacklist test_blacklist;
 
   // 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 = ExtensionPrefs::Get(profile_.get())->pref_service();
+  PrefService* prefs = ExtensionPrefs::Get(profile())->pref_service();
   whitelist.Append(new base::StringValue(good_crx));
   prefs->Set(extensions::pref_names::kInstallAllowList, whitelist);
 
   test_blacklist.SetBlacklistState(
       good_crx, extensions::BLACKLISTED_MALWARE, true);
   base::RunLoop().RunUntilIdle();
 
   // 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)
 
 #if defined(ENABLE_BLACKLIST_TESTS)
 // Tests that a blacklisted extension is eventually unloaded on startup, if it
 // wasn't already.
 TEST_F(ExtensionServiceTest, WillNotLoadBlacklistedExtensionsFromDirectory) {
   extensions::TestBlacklist test_blacklist;
 
   // 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)
 
 #if defined(ENABLE_BLACKLIST_TESTS)
 // Tests extensions blacklisted in prefs on startup; one still blacklisted by
 // safe browsing, the other not. The not-blacklisted one should recover.
 TEST_F(ExtensionServiceTest, BlacklistedInPrefsFromStartup) {
   extensions::TestBlacklist test_blacklist;
 
   InitializeGoodInstalledExtensionService();
-  test_blacklist.Attach(service_->blacklist_);
-  ExtensionPrefs::Get(profile_.get())->SetExtensionBlacklisted(good0, true);
-  ExtensionPrefs::Get(profile_.get())->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);
 
   // 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));
+  EXPECT_FALSE(service()->IsExtensionEnabled(good0));
+  EXPECT_FALSE(service()->IsExtensionEnabled(good1));
+  EXPECT_TRUE(service()->IsExtensionEnabled(good2));
 
-  service_->Init();
+  service()->Init();
 
-  EXPECT_EQ(2u, registry_->blacklisted_extensions().size());
-  EXPECT_EQ(1u, registry_->enabled_extensions().size());
+  EXPECT_EQ(2u, registry()->blacklisted_extensions().size());
+  EXPECT_EQ(1u, registry()->enabled_extensions().size());
 
-  EXPECT_TRUE(registry_->blacklisted_extensions().Contains(good0));
-  EXPECT_TRUE(registry_->blacklisted_extensions().Contains(good1));
-  EXPECT_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();
 
-  EXPECT_EQ(1u, registry_->blacklisted_extensions().size());
-  EXPECT_EQ(2u, registry_->enabled_extensions().size());
+  EXPECT_EQ(1u, registry()->blacklisted_extensions().size());
+  EXPECT_EQ(2u, registry()->enabled_extensions().size());
 
-  EXPECT_TRUE(registry_->enabled_extensions().Contains(good0));
-  EXPECT_TRUE(registry_->blacklisted_extensions().Contains(good1));
-  EXPECT_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)
 
 #if defined(ENABLE_BLACKLIST_TESTS)
 // Extension is added to blacklist with BLACKLISTED_POTENTIALLY_UNWANTED state
 // after it is installed. It is then successfully re-enabled by the user.
 TEST_F(ExtensionServiceTest, GreylistedExtensionDisabled) {
   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));
   EXPECT_TRUE(enabled_extensions.Contains(good2));
 
   // Blacklist good0 and good1 (and an invalid extension ID).
   test_blacklist.SetBlacklistState(
       good0, extensions::BLACKLISTED_CWS_POLICY_VIOLATION, true);
   test_blacklist.SetBlacklistState(
       good1, extensions::BLACKLISTED_POTENTIALLY_UNWANTED, true);
   test_blacklist.SetBlacklistState(
       "invalid_id", extensions::BLACKLISTED_MALWARE, true);
   base::RunLoop().RunUntilIdle();
 
   EXPECT_FALSE(enabled_extensions.Contains(good0));
   EXPECT_TRUE(disabled_extensions.Contains(good0));
   EXPECT_FALSE(enabled_extensions.Contains(good1));
   EXPECT_TRUE(disabled_extensions.Contains(good1));
   EXPECT_TRUE(enabled_extensions.Contains(good2));
   EXPECT_FALSE(disabled_extensions.Contains(good2));
 
   ValidateIntegerPref(
       good0, "blacklist_state", extensions::BLACKLISTED_CWS_POLICY_VIOLATION);
   ValidateIntegerPref(
       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));
   EXPECT_FALSE(enabled_extensions.Contains(good1));
   EXPECT_TRUE(disabled_extensions.Contains(good1));
 
   // Remove extensions from blacklist.
   test_blacklist.SetBlacklistState(
       good0, extensions::NOT_BLACKLISTED, true);
   test_blacklist.SetBlacklistState(
@@ skipping 10 matching lines @@
 }
 #endif  // defined(ENABLE_BLACKLIST_TESTS)
 
 #if defined(ENABLE_BLACKLIST_TESTS)
 // When extension is removed from greylist, do not re-enable it if it is
 // disabled by user.
 TEST_F(ExtensionServiceTest, GreylistDontEnableManuallyDisabled) {
   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);
   test_blacklist.SetBlacklistState(
       good1, extensions::BLACKLISTED_POTENTIALLY_UNWANTED, true);
   test_blacklist.SetBlacklistState(
       good2, extensions::BLACKLISTED_SECURITY_VULNERABILITY, true);
   base::RunLoop().RunUntilIdle();
 
   // All extensions disabled.
   EXPECT_FALSE(enabled_extensions.Contains(good0));
   EXPECT_TRUE(disabled_extensions.Contains(good0));
   EXPECT_FALSE(enabled_extensions.Contains(good1));
   EXPECT_TRUE(disabled_extensions.Contains(good1));
   EXPECT_FALSE(enabled_extensions.Contains(good2));
   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));
 
   // Remove extensions from blacklist.
   test_blacklist.SetBlacklistState(
       good0, extensions::NOT_BLACKLISTED, true);
   test_blacklist.SetBlacklistState(
       good1, extensions::NOT_BLACKLISTED, true);
   test_blacklist.SetBlacklistState(
       good2, extensions::NOT_BLACKLISTED, true);
   base::RunLoop().RunUntilIdle();
 
   // good0 and good1 remain disabled.
   EXPECT_FALSE(enabled_extensions.Contains(good0));
   EXPECT_TRUE(disabled_extensions.Contains(good0));
   EXPECT_FALSE(enabled_extensions.Contains(good1));
   EXPECT_TRUE(disabled_extensions.Contains(good1));
   EXPECT_TRUE(enabled_extensions.Contains(good2));
   EXPECT_FALSE(disabled_extensions.Contains(good2));
 }
 #endif  // defined(ENABLE_BLACKLIST_TESTS)
 
 #if defined(ENABLE_BLACKLIST_TESTS)
 // Blacklisted extension with unknown state are not enabled/disabled.
 TEST_F(ExtensionServiceTest, GreylistUnknownDontChange) {
   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);
   test_blacklist.SetBlacklistState(
       good1, extensions::BLACKLISTED_POTENTIALLY_UNWANTED, true);
   base::RunLoop().RunUntilIdle();
 
   EXPECT_FALSE(enabled_extensions.Contains(good0));
   EXPECT_TRUE(disabled_extensions.Contains(good0));
   EXPECT_FALSE(enabled_extensions.Contains(good1));
@@ skipping 17 matching lines @@
   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.Attach(service()->blacklist_);
 
   test_blacklist.SetBlacklistState(
       good1, extensions::BLACKLISTED_MALWARE, false);
-  service_->Init();
+  service()->Init();
   test_blacklist.SetBlacklistState(
       good2, extensions::BLACKLISTED_MALWARE, false);
   base::RunLoop().RunUntilIdle();
 
-  EXPECT_EQ(StringSet(good0), registry_->enabled_extensions().GetIDs());
+  EXPECT_EQ(StringSet(good0), registry()->enabled_extensions().GetIDs());
   EXPECT_EQ(StringSet(good1, good2),
-            registry_->blacklisted_extensions().GetIDs());
+            registry()->blacklisted_extensions().GetIDs());
 
-  service_->ReloadExtension(good1);
-  service_->ReloadExtension(good2);
+  service()->ReloadExtension(good1);
+  service()->ReloadExtension(good2);
   base::RunLoop().RunUntilIdle();
 
-  EXPECT_EQ(StringSet(good0), registry_->enabled_extensions().GetIDs());
+  EXPECT_EQ(StringSet(good0), registry()->enabled_extensions().GetIDs());
   EXPECT_EQ(StringSet(good1, good2),
-            registry_->blacklisted_extensions().GetIDs());
+            registry()->blacklisted_extensions().GetIDs());
 }
 
 #endif  // defined(ENABLE_BLACKLIST_TESTS)
 
 // Will not install extension blacklisted by policy.
 TEST_F(ExtensionServiceTest, BlacklistedByPolicyWillNotInstall) {
   InitializeEmptyExtensionService();
 
   // 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.
 TEST_F(ExtensionServiceTest, BlacklistedByPolicyRemovedIfRunning) {
   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);
 
     // Blacklist this extension.
     blacklist->Append(new base::StringValue(good_crx));
   }
 
   // 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.
 TEST_F(ExtensionServiceTest, ComponentExtensionWhitelisted) {
   InitializeEmptyExtensionService();
 
   // 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.
 TEST_F(ExtensionServiceTest, PolicyInstalledExtensionsWhitelisted) {
   InitializeEmptyExtensionService();
 
   {
     // 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,
       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
 // it. This functionality is implemented in CrxInstaller::ConfirmInstall().
 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
 // prohibits it. This functionality is implemented in InstalledLoader::Load().
 TEST_F(ExtensionServiceTest, ManagementPolicyProhibitsLoadFromPrefs) {
   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");
   // UNPACKED is for extensions loaded from a directory. We use it here, even
   // though we're testing loading from prefs, so that we don't need to provide
   // an extension key.
   extensions::ExtensionInfo extension_info(
       &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(), false, 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, false, 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
 // being installed are removed.
 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
 // enabled are re-enabled on reinstall.
 TEST_F(ExtensionServiceTest, ManagementPolicyRequiresEnable) {
   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
 #if defined(OS_WIN)
 #define MAYBE_ExternalExtensionAutoAcknowledgement DISABLED_ExternalExtensionAutoAcknowledgement
 #else
 #define MAYBE_ExternalExtensionAutoAcknowledgement ExternalExtensionAutoAcknowledgement
 #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,
       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 = ExtensionPrefs::Get(profile_.get());
+  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));
 }
 
 #if !defined(OS_CHROMEOS)
 // 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 =
         "{"
         "  \"ldnnhddmnhbkjipkidpdiheffobcpfmf\" : {"
         "    \"external_crx\": \"good.crx\","
         "    \"external_version\": \"1.0.0.0\","
         "    \"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,
       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());
 }
 #endif
 
 // Tests disabling extensions
 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(registry_->GetExtensionById(
+  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(registry_->GetExtensionById(
+  EXPECT_FALSE(registry()->GetExtensionById(
       good_crx, extensions::ExtensionRegistry::TERMINATED));
-  EXPECT_TRUE(service_->GetExtensionById(good_crx, true));
+  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.
 TEST_F(ExtensionServiceTest, ReloadExtensions) {
   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.
 TEST_F(ExtensionServiceTest, ReloadExtension) {
   InitializeEmptyExtensionService();
   InitializeProcessManager();
 
   // 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(
-      Extension::DISABLE_RELOAD,
-      ExtensionPrefs::Get(profile_.get())->GetDisableReasons(extension_id));
+  EXPECT_EQ(0u, registry()->enabled_extensions().size());
+  EXPECT_EQ(1u, registry()->disabled_extensions().size());
+  EXPECT_EQ(Extension::DISABLE_RELOAD,
+            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
 // if updated to a version with supported requirements as long as there are no
 // other disable reasons.
 TEST_F(ExtensionServiceTest, UpgradingRequirementsEnabled) {
   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();
 
   PackCRX(path.AppendASCII("v2_bad_requirements"),
           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.
 TEST_F(ExtensionServiceTest, UpgradingRequirementsDisabled) {
   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();
 
   PackCRX(path.AppendASCII("v2_bad_requirements"),
           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
 // permission increase.
 TEST_F(ExtensionServiceTest, UpgradingRequirementsPermissions) {
   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();
 
   PackCRX(path.AppendASCII("v2_bad_requirements_and_permissions"),
           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();
 
   PackCRX(path.AppendASCII("v3_bad_permissions"),
           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
 // requirements.
 TEST_F(ExtensionServiceTest, UnpackedRequirements) {
   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 {
  public:
   ExtensionCookieCallback()
     : result_(false),
       weak_factory_(base::MessageLoop::current()) {}
 
   void SetCookieCallback(bool result) {
     base::MessageLoop::current()->PostTask(FROM_HERE,
@@ skipping 10 matching lines @@
   bool result_;
   base::WeakPtrFactory<base::MessageLoop> weak_factory_;
 };
 
 // Verifies extension state is removed upon uninstall.
 TEST_F(ExtensionServiceTest, ClearExtensionData) {
   InitializeEmptyExtensionService();
   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);
   GURL ext_url(extension->url());
   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(
        ext_url, "dummy=value", options,
        base::Bind(&ExtensionCookieCallback::SetCookieCallback,
                   base::Unretained(&callback)));
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(callback.result_);
 
   cookie_monster->GetAllCookiesForURLAsync(
       ext_url,
       base::Bind(&ExtensionCookieCallback::GetAllCookiesCallback,
                  base::Unretained(&callback)));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1U, callback.list_.size());
 
   // 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;
   db_tracker->DatabaseOpened(origin_id, db_name, description, 1, &size);
   db_tracker->DatabaseClosed(origin_id, db_name);
   std::vector<webkit_database::OriginInfo> origins;
   db_tracker->GetAllOriginsInfo(&origins);
   EXPECT_EQ(1U, origins.size());
   EXPECT_EQ(origin_id, origins[0].GetOriginIdentifier());
 
   // Create local storage. We only simulate this by creating the backing files.
   // 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, 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::CreateDirectory(idb_path));
   EXPECT_TRUE(base::DirectoryExists(idb_path));
 
   // Uninstall the extension.
-  service_->UninstallExtension(good_crx, false, NULL);
+  service()->UninstallExtension(good_crx, false, NULL);
   base::RunLoop().RunUntilIdle();
 
   // Check that the cookie is gone.
   cookie_monster->GetAllCookiesForURLAsync(
        ext_url,
        base::Bind(&ExtensionCookieCallback::GetAllCookiesCallback,
                   base::Unretained(&callback)));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(0U, callback.list_.size());
 
@@ skipping 11 matching lines @@
 
 // Verifies app state is removed upon uninstall.
 TEST_F(ExtensionServiceTest, ClearAppData) {
   InitializeEmptyExtensionService();
   ExtensionCookieCallback callback;
 
   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->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->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(
        origin1, "dummy=value", options,
        base::Bind(&ExtensionCookieCallback::SetCookieCallback,
                   base::Unretained(&callback)));
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(callback.result_);
 
   cookie_monster->GetAllCookiesForURLAsync(
       origin1,
       base::Bind(&ExtensionCookieCallback::GetAllCookiesCallback,
                  base::Unretained(&callback)));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1U, callback.list_.size());
 
   // 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;
   db_tracker->DatabaseOpened(origin_id, db_name, description, 1, &size);
   db_tracker->DatabaseClosed(origin_id, db_name);
   std::vector<webkit_database::OriginInfo> origins;
   db_tracker->GetAllOriginsInfo(&origins);
   EXPECT_EQ(1U, origins.size());
   EXPECT_EQ(origin_id, origins[0].GetOriginIdentifier());
 
   // Create local storage. We only simulate this by creating the backing files.
   // 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, 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::CreateDirectory(idb_path));
   EXPECT_TRUE(base::DirectoryExists(idb_path));
 
   // 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(
        origin1,
        base::Bind(&ExtensionCookieCallback::GetAllCookiesCallback,
                   base::Unretained(&callback)));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1U, callback.list_.size());
 
   // 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(
        origin1,
        base::Bind(&ExtensionCookieCallback::GetAllCookiesCallback,
                   base::Unretained(&callback)));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(0U, callback.list_.size());
 
   // The database should have vanished as well.
   origins.clear();
   db_tracker->GetAllOriginsInfo(&origins);
   EXPECT_EQ(0U, origins.size());
 
   // Check that the LSO file has been removed.
   EXPECT_FALSE(base::PathExists(lso_file_path));
 
   // Check if the indexed db has disappeared too.
   EXPECT_FALSE(base::DirectoryExists(idb_path));
 }
 
 // Tests loading single extensions (like --load-extension)
 // Flaky crashes. http://crbug.com/231806
 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, false, 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
 // --load-extension.
 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());
   ASSERT_TRUE(Extension::IdIsValid(loaded_[0]->id()));
   EXPECT_EQ(loaded_[0]->location(), Manifest::UNPACKED);
 
   ValidatePrefKeyCount(1);
 
   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")
                                               .AppendASCII("ms")
                                               .AppendASCII("messages.json");
   EXPECT_THAT(base::UTF16ToUTF8(GetErrors()[0]), testing::AllOf(
        testing::HasSubstr(
            base::UTF16ToUTF8(ms_messages_file.LossyDisplayName())),
        testing::HasSubstr("Dictionary keys must be quoted.")));
   ASSERT_EQ(0u, loaded_.size());
 }
 
 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,
       content::NotificationService::AllSources());
-  service_->CheckForExternalUpdates();
+  service()->CheckForExternalUpdates();
   observer.Wait();
 
   ASSERT_EQ(0u, GetErrors().size());
   ASSERT_EQ(1u, loaded_.size());
   ASSERT_EQ(location, loaded_[0]->location());
   ASSERT_EQ("1.0.0.0", loaded_[0]->version()->GetString());
   ValidatePrefKeyCount(1);
   ValidateIntegerPref(good_crx, "state", Extension::ENABLED);
   ValidateIntegerPref(good_crx, "location", location);
 
   // 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());
   ValidatePrefKeyCount(1);
   ValidateIntegerPref(good_crx, "state", Extension::ENABLED);
   ValidateIntegerPref(good_crx, "location", location);
 
   // Now update the extension with a new version. We should get upgraded.
   source_path = source_path.DirName().AppendASCII("good2.crx");
   provider->UpdateOrAddExtension(good_crx, "1.0.0.1", source_path);
 
   loaded_.clear();
   content::WindowedNotificationObserver observer_2(
       chrome::NOTIFICATION_CRX_INSTALLER_DONE,
       content::NotificationService::AllSources());
-  service_->CheckForExternalUpdates();
+  service()->CheckForExternalUpdates();
   observer_2.Wait();
   ASSERT_EQ(0u, GetErrors().size());
   ASSERT_EQ(1u, loaded_.size());
   ASSERT_EQ("1.0.0.1", loaded_[0]->version()->GetString());
   ValidatePrefKeyCount(1);
   ValidateIntegerPref(good_crx, "state", Extension::ENABLED);
   ValidateIntegerPref(good_crx, "location", location);
 
   // Uninstall the extension and reload. Nothing should happen because the
   // 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, false, 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));
   } else {
     // 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);
     ValidateIntegerPref(good_crx, "state",
                         Extension::EXTERNAL_EXTENSION_UNINSTALLED);
     ValidateIntegerPref(good_crx, "location", location);
 
     // Now clear the preference and reinstall.
     SetPrefInteg(good_crx, "state", Extension::ENABLED);
 
     loaded_.clear();
     content::WindowedNotificationObserver observer(
         chrome::NOTIFICATION_CRX_INSTALLER_DONE,
         content::NotificationService::AllSources());
-    service_->CheckForExternalUpdates();
+    service()->CheckForExternalUpdates();
     observer.Wait();
     ASSERT_EQ(1u, loaded_.size());
   }
   ValidatePrefKeyCount(1);
   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
     // the pref entry).
     provider->RemoveExtension(good_crx);
 
     loaded_.clear();
-    service_->OnExternalProviderReady(provider);
+    service()->OnExternalProviderReady(provider);
     base::RunLoop().RunUntilIdle();
     ASSERT_EQ(0u, loaded_.size());
     ValidatePrefKeyCount(0);
 
     // The extension should also be gone from the install directory.
     ASSERT_FALSE(base::PathExists(install_path));
 
     // 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,
         content::NotificationService::AllSources());
     provider->UpdateOrAddExtension(good_crx, "1.0.0.1", source_path);
-    service_->CheckForExternalUpdates();
+    service()->CheckForExternalUpdates();
     observer.Wait();
 
     ASSERT_EQ(1u, loaded_.size());
     ASSERT_EQ(0u, GetErrors().size());
 
     // User uninstalls.
     loaded_.clear();
-    service_->UninstallExtension(id, false, NULL);
+    service()->UninstallExtension(id, false, NULL);
     base::RunLoop().RunUntilIdle();
     ASSERT_EQ(0u, loaded_.size());
 
     // Then remove the extension from the extension provider.
     provider->RemoveExtension(good_crx);
 
     // 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);
 
     EXPECT_EQ(5, provider->visit_count());
   }
 }
 
 // Tests the external installation feature
 #if defined(OS_WIN)
 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);
 }
 #endif
 
 TEST_F(ExtensionServiceTest, ExternalInstallPref) {
   InitializeEmptyExtensionService();
 
   // 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.
   // 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(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.
   // 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(service_,
-                                Manifest::EXTERNAL_POLICY_DOWNLOAD);
+      new MockExtensionProvider(service(), Manifest::EXTERNAL_POLICY_DOWNLOAD);
   AddMockExternalProvider(pref_provider);
   TestExternalProvider(pref_provider, Manifest::EXTERNAL_POLICY_DOWNLOAD);
 }
 
 // Tests that external extensions get uninstalled when the external extension
 // 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());
   ASSERT_EQ(0u, loaded_.size());
 }
 
 // Test that running multiple update checks simultaneously does not
 // keep the update from succeeding.
 TEST_F(ExtensionServiceTest, MultipleExternalUpdateCheck) {
   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(2, provider->visit_count());
   EXPECT_EQ(0u, GetErrors().size());
   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,
       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());
   ASSERT_EQ(1u, loaded_.size());
   ASSERT_EQ(Manifest::EXTERNAL_PREF, loaded_[0]->location());
   ASSERT_EQ("1.0.0.0", loaded_[0]->version()->GetString());
   ValidatePrefKeyCount(1);
   ValidateIntegerPref(good_crx, "state", Extension::ENABLED);
   ValidateIntegerPref(good_crx, "location", Manifest::EXTERNAL_PREF);
 
   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.
   // Because the external source no longer includes good_crx,
   // good_crx will be uninstalled.  So, expect that no extensions
   // are loaded.
   EXPECT_EQ(2, provider->visit_count());
   EXPECT_EQ(0u, GetErrors().size());
   EXPECT_EQ(0u, loaded_.size());
 }
@@ skipping 182 matching lines @@
       "}";
   EXPECT_EQ(1, was_installed_by_eom_visitor.Visit(json_data));
 }
 
 // Test loading good extensions from the profile directory.
 TEST_F(ExtensionServiceTest, LoadAndRelocalizeExtensions) {
   // Ensure we're testing in "en" and leave global state untouched.
   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());
 
   // This was equal to "sr" on load.
   ValidateStringPref(loaded_[0]->id(), keys::kCurrentLocale, "en");
 
   // These are untouched by re-localization.
   ValidateStringPref(loaded_[1]->id(), keys::kCurrentLocale, "en");
   EXPECT_FALSE(IsPrefExist(loaded_[1]->id(), keys::kCurrentLocale));
 
@@ skipping 124 matching lines @@
   profile.reset();
   service = NULL;
   // Execute any pending deletion tasks.
   base::RunLoop().RunUntilIdle();
 }
 
 // Test loading extensions that require limited and unlimited storage quotas.
 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")
       .AppendASCII("1.0");
 
   // The old permission name for unlimited quota was "unlimited_storage", but
   // we changed it to "unlimitedStorage". This tests both versions.
   base::FilePath unlimited_quota_ext =
       extensions_path.AppendASCII("unlimited_quota")
       .AppendASCII("1.0");
   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()));
 }
 
 // Tests ComponentLoader::Add().
 TEST_F(ExtensionServiceTest, ComponentExtensions) {
   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());
 }
 
 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.
                  &triggered_type));  // Safe due to WeakPtrFactory scope.
 
   // Install a component extension.
   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);
   ASSERT_EQ(syncer::UNSPECIFIED, triggered_type);
 }
 
 TEST_F(ExtensionServiceTest, DeferredSyncStartupPreInstalledNormal) {
   InitializeGoodInstalledExtensionService();
   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.
                  &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);
   ASSERT_EQ(syncer::UNSPECIFIED, triggered_type);
 }
 
 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);
   EXPECT_EQ(syncer::EXTENSIONS, triggered_type);
 
   // Reset.
   flare_was_called = false;
   triggered_type = syncer::UNSPECIFIED;
 
   // Once sync starts, flare should no longer be invoked.
-  extension_sync_service_->MergeDataAndStartSyncing(
+  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);
 
   InitializeInstalledExtensionService(pref_path, source_install_dir);
   InitializeExtensionSyncService();
 
   // 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));
+  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(
+  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);
 
   InitializeInstalledExtensionService(pref_path, source_install_dir);
   InitializeExtensionSyncService();
 
   // 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, false);
   syncer::SyncDataList sync_data;
   sync_data.push_back(disable_good_crx.GetSyncData());
-  extension_sync_service_->MergeDataAndStartSyncing(
+  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(
+  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),
             data.update_url());
   EXPECT_EQ(extension->name(), data.name());
 }
 
 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);
 
   syncer::FakeSyncChangeProcessor processor;
-  extension_sync_service_->MergeDataAndStartSyncing(
+  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),
             data.update_url());
   EXPECT_EQ(extension->name(), data.name());
 }
 
 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);
 
   syncer::FakeSyncChangeProcessor processor;
-  extension_sync_service_->MergeDataAndStartSyncing(
+  extension_sync_service()->MergeDataAndStartSyncing(
       syncer::APPS,
       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(), 0U);
 }
 
 TEST_F(ExtensionServiceTest, GetSyncExtensionDataUserSettings) {
   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);
 
   syncer::FakeSyncChangeProcessor processor;
-  extension_sync_service_->MergeDataAndStartSyncing(
+  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());
     EXPECT_TRUE(data.incognito_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);
 
   syncer::FakeSyncChangeProcessor processor;
-  extension_sync_service_->MergeDataAndStartSyncing(
+  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(ExtensionPrefs::Get(profile_.get())
-                  ->IsExternalExtensionUninstalled(good_crx));
+  EXPECT_TRUE(
+      ExtensionPrefs::Get(profile())->IsExternalExtensionUninstalled(good_crx));
 
   sync_pb::EntitySpecifics specifics;
   sync_pb::AppSpecifics* app_specifics = specifics.mutable_app();
   sync_pb::ExtensionSpecifics* extension_specifics =
       app_specifics->mutable_extension();
   extension_specifics->set_id(good_crx);
   extension_specifics->set_version("1.0");
   extension_specifics->set_enabled(true);
 
   syncer::SyncData sync_data =
       syncer::SyncData::CreateLocalData(good_crx, "Name", specifics);
   syncer::SyncChange sync_change(FROM_HERE,
                                  syncer::SyncChange::ACTION_UPDATE,
                                  sync_data);
   syncer::SyncChangeList list(1);
   list[0] = sync_change;
 
-  extension_sync_service_->ProcessSyncChanges(FROM_HERE, list);
-  EXPECT_TRUE(ExtensionPrefs::Get(profile_.get())
-                  ->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());
 
   syncer::FakeSyncChangeProcessor processor;
-  extension_sync_service_->MergeDataAndStartSyncing(
+  extension_sync_service()->MergeDataAndStartSyncing(
       syncer::APPS,
       syncer::SyncDataList(),
       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.app_launch_ordinal()));
     EXPECT_TRUE(initial_ordinal.Equals(app_sync_data.page_ordinal()));
   }
 
-  AppSorting* sorting = ExtensionPrefs::Get(profile_.get())->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]);
     EXPECT_TRUE(initial_ordinal.LessThan(app_sync_data.app_launch_ordinal()));
     EXPECT_TRUE(initial_ordinal.Equals(app_sync_data.page_ordinal()));
   }
 
   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]);
     EXPECT_TRUE(initial_ordinal.LessThan(app_sync_data.app_launch_ordinal()));
     EXPECT_TRUE(initial_ordinal.LessThan(app_sync_data.page_ordinal()));
   }
 }
 
 // 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());
   }
 
   syncer::FakeSyncChangeProcessor processor;
-  extension_sync_service_->MergeDataAndStartSyncing(
+  extension_sync_service()->MergeDataAndStartSyncing(
       syncer::APPS,
       syncer::SyncDataList(),
       scoped_ptr<syncer::SyncChangeProcessor>(
           new syncer::FakeSyncChangeProcessor),
       scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
 
-  ExtensionPrefs::Get(service_->GetBrowserContext())
+  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];
     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.
     syncer::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())
           app_launch_ordinals[i] = data[j].app_launch_ordinal();
       }
     }
 
     EXPECT_TRUE(app_launch_ordinals[1].LessThan(app_launch_ordinals[0]));
     EXPECT_TRUE(app_launch_ordinals[0].LessThan(app_launch_ordinals[2]));
   }
 }
 
 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);
+  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(
+  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(
+  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();
   syncer::FakeSyncChangeProcessor processor;
-  extension_sync_service_->MergeDataAndStartSyncing(
+  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;
   sync_pb::ExtensionSpecifics* ext_specifics = specifics.mutable_extension();
   ext_specifics->set_id(good_crx);
   ext_specifics->set_version("1.0");
   syncer::SyncData sync_data =
       syncer::SyncData::CreateLocalData(good_crx, "Name", specifics);
   syncer::SyncChange sync_change(FROM_HERE,
                                  syncer::SyncChange::ACTION_DELETE,
                                  sync_data);
   syncer::SyncChangeList list(1);
   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) {
   InitializeEmptyExtensionService();
   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();
   sync_pb::ExtensionSpecifics* extension_specifics =
       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);
     syncer::SyncData sync_data =
         syncer::SyncData::CreateLocalData(good_crx, "Name", specifics);
     syncer::SyncChange sync_change(FROM_HERE,
                                    syncer::SyncChange::ACTION_DELETE,
                                    sync_data);
     syncer::SyncChangeList list(1);
     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));
   }
 
   {
     extension_specifics->set_enabled(false);
     syncer::SyncData sync_data =
         syncer::SyncData::CreateLocalData(good_crx, "Name", specifics);
     syncer::SyncChange sync_change(FROM_HERE,
                                    syncer::SyncChange::ACTION_UPDATE,
                                    sync_data);
     syncer::SyncChangeList list(1);
     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));
   }
 }
 
 TEST_F(ExtensionServiceTest, ProcessSyncDataSettings) {
   InitializeEmptyExtensionService();
   InitializeProcessManager();
   InitializeExtensionSyncService();
   syncer::FakeSyncChangeProcessor processor;
-  extension_sync_service_->MergeDataAndStartSyncing(
+  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);
 
   {
     syncer::SyncData sync_data =
         syncer::SyncData::CreateLocalData(good_crx, "Name", specifics);
     syncer::SyncChange sync_change(FROM_HERE,
                                    syncer::SyncChange::ACTION_UPDATE,
                                    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()));
   }
 
   {
     ext_specifics->set_enabled(true);
     ext_specifics->set_incognito_enabled(true);
     syncer::SyncData sync_data =
         syncer::SyncData::CreateLocalData(good_crx, "Name", specifics);
     syncer::SyncChange sync_change(FROM_HERE,
                                    syncer::SyncChange::ACTION_UPDATE,
                                    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()));
   }
 
   {
     ext_specifics->set_enabled(false);
     ext_specifics->set_incognito_enabled(true);
     syncer::SyncData sync_data =
         syncer::SyncData::CreateLocalData(good_crx, "Name", specifics);
     syncer::SyncChange sync_change(FROM_HERE,
                                    syncer::SyncChange::ACTION_UPDATE,
                                    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();
   syncer::FakeSyncChangeProcessor processor;
-  extension_sync_service_->MergeDataAndStartSyncing(
+  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::SyncData::CreateLocalData(good_crx, "Name", specifics);
   syncer::SyncChange sync_change(FROM_HERE,
                                  syncer::SyncChange::ACTION_UPDATE,
                                  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();
   syncer::FakeSyncChangeProcessor processor;
-  extension_sync_service_->MergeDataAndStartSyncing(
+  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_enabled(true);
 
   {
     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,
                                    syncer::SyncChange::ACTION_UPDATE,
                                    sync_data);
     syncer::SyncChangeList list(1);
     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
   // the TODO in ProcessExtensionSyncData).
   {
     ext_specifics->set_version("0.0.0.0");
     syncer::SyncData sync_data =
         syncer::SyncData::CreateLocalData(good_crx, "Name", specifics);
     syncer::SyncChange sync_change(FROM_HERE,
                                    syncer::SyncChange::ACTION_UPDATE,
                                    sync_data);
     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.
   {
     ext_specifics->set_version("9.9.9.9");
     syncer::SyncData sync_data =
         syncer::SyncData::CreateLocalData(good_crx, "Name", specifics);
     syncer::SyncChange sync_change(FROM_HERE,
                                    syncer::SyncChange::ACTION_UPDATE,
                                    sync_data);
     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();
   syncer::FakeSyncChangeProcessor processor;
-  extension_sync_service_->MergeDataAndStartSyncing(
+  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;
   sync_pb::ExtensionSpecifics* ext_specifics = specifics.mutable_extension();
   ext_specifics->set_id(good_crx);
   ext_specifics->set_enabled(false);
   ext_specifics->set_incognito_enabled(true);
   ext_specifics->set_update_url("http://www.google.com/");
   ext_specifics->set_version("1.2.3.4");
   syncer::SyncData sync_data =
       syncer::SyncData::CreateLocalData(good_crx, "Name", specifics);
   syncer::SyncChange sync_change(FROM_HERE,
                                  syncer::SyncChange::ACTION_UPDATE,
                                  sync_data);
   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());
   EXPECT_EQ(Manifest::INTERNAL, info->install_source());
   // TODO(akalin): Figure out a way to test |info.ShouldAllowInstall()|.
 }
 
 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,
-                                                           std::string(),
-                                                           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));
 
   // Install when the location has higher priority.
-  EXPECT_TRUE(service_->OnExternalExtensionUpdateUrlFound(
+  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(
+  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));
 
   pending->Remove(kGoodId);
 
   // Skip install when the location has the same priority as the installed
   // location.
-  EXPECT_FALSE(service_->OnExternalExtensionUpdateUrlFound(kGoodId,
-                                                           std::string(),
-                                                           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));
 }
 
 TEST_F(ExtensionServiceTest, InstallPriorityExternalLocalFile) {
   Version older_version("0.1.0.0");
   Version newer_version("2.0.0.0");
 
   // We don't want the extension to be installed.  A path that doesn't
   // point to a valid CRX ensures this.
@@ skipping 13 matching lines @@
             Manifest::GetHigherPriorityLocation(Manifest::EXTERNAL_REGISTRY,
                                                  Manifest::EXTERNAL_PREF));
   ASSERT_EQ(Manifest::EXTERNAL_REGISTRY,
             Manifest::GetHigherPriorityLocation(Manifest::EXTERNAL_REGISTRY,
                                                  Manifest::INTERNAL));
   ASSERT_EQ(Manifest::EXTERNAL_PREF,
             Manifest::GetHigherPriorityLocation(Manifest::EXTERNAL_PREF,
                                                  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,
         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,
         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,
         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);
   ValidateIntegerPref(good_crx, "location", Manifest::INTERNAL);
 
   // Now test the logic of OnExternalExtensionFileFound() when the extension
   // being added is already installed.
 
   // Tests assume |older_version| is less than the installed version, and
   // |newer_version| is greater.  Verify this:
   ASSERT_TRUE(older_version.IsOlderThan(ext->VersionString()));
   ASSERT_TRUE(ext->version()->IsOlderThan(newer_version.GetString()));
 
   // An external install for the same location should fail if the version is
   // 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));
 }
 
 TEST_F(ExtensionServiceTest, ConcurrentExternalLocalFile) {
   Version kVersion123("1.2.3");
   Version kVersion124("1.2.4");
   Version kVersion125("1.2.5");
   const base::FilePath kInvalidPathToCrx = base::FilePath();
   const int kCreationFlags = 0;
   const bool kDontMarkAcknowledged = false;
 
   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(
+  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());
 }
 
 // This makes sure we can package and install CRX files that use whitelisted
 // permissions.
 TEST_F(ExtensionServiceTest, InstallWhitelistedExtension) {
   std::string test_id = "hdkklepkcpckhnpgjnmbdfhehckloojk";
   CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       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
       .AppendASCII("whitelist");
 
   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());
 }
 
 // Test that when multiple sources try to install an extension,
 // we consistently choose the right one. To make tests easy to read,
 // methods that fake requests to install crx files in several ways
 // are provided.
 class ExtensionSourcePriorityTest : public ExtensionServiceTest {
  public:
   virtual void SetUp() {
     ExtensionServiceTest::SetUp();
 
     // 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(
+    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(
+    return service()->pending_extension_manager()->AddFromSync(
         crx_id_,
         GURL(kGoodUpdateURL),
         &IsExtension,
         kGoodInstallSilently,
         kGoodRemoteInstall);
   }
 
   // Fake a policy install.
   bool AddPendingPolicyInstall() {
     // Get path to the CRX with id |kGoodId|.
-    return service_->OnExternalExtensionUpdateUrlFound(
+    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:
   // All tests use a single extension.  Making the id and path member
   // vars avoids pasing the same argument to every method.
   std::string crx_id_;
   base::FilePath crx_path_;
 };
 
 // Test that a pending request for installation of an external CRX from
@@ skipping 79 matching lines @@
   ASSERT_FALSE(AddPendingSyncInstall());
 }
 
 // Test that installing an external extension displays a GlobalError.
 TEST_F(ExtensionServiceTest, ExternalInstallGlobalError) {
   FeatureSwitch::ScopedOverride prompt(
       FeatureSwitch::prompt_for_external_extensions(), true);
 
   InitializeEmptyExtensionService();
   MockExtensionProvider* provider =
-      new MockExtensionProvider(service_, Manifest::EXTERNAL_PREF);
+      new MockExtensionProvider(service(), Manifest::EXTERNAL_PREF);
   AddMockExternalProvider(provider);
 
-  service_->UpdateExternalExtensionAlert();
+  service()->UpdateExternalExtensionAlert();
   // Should return false, meaning there aren't any extensions that the user
   // needs to know about.
-  EXPECT_FALSE(extensions::HasExternalInstallError(service_));
+  EXPECT_FALSE(extensions::HasExternalInstallError(service()));
 
   // 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(extensions::HasExternalInstallError(service()));
 
   // 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,
       content::NotificationService::AllSources());
-  service_->CheckForExternalUpdates();
+  service()->CheckForExternalUpdates();
   observer.Wait();
-  EXPECT_FALSE(extensions::HasExternalInstallError(service_));
+  EXPECT_FALSE(extensions::HasExternalInstallError(service()));
 
   // 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,
       content::NotificationService::AllSources());
-  service_->CheckForExternalUpdates();
+  service()->CheckForExternalUpdates();
   observer2.Wait();
-  EXPECT_TRUE(extensions::HasExternalInstallError(service_));
+  EXPECT_TRUE(extensions::HasExternalInstallError(service()));
 }
 
 // Test that external extensions are initially disabled, and that enabling
 // them clears the prompt.
 TEST_F(ExtensionServiceTest, ExternalInstallInitiallyDisabled) {
   FeatureSwitch::ScopedOverride prompt(
       FeatureSwitch::prompt_for_external_extensions(), true);
 
   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,
       content::NotificationService::AllSources());
-  service_->CheckForExternalUpdates();
+  service()->CheckForExternalUpdates();
   observer.Wait();
-  EXPECT_TRUE(extensions::HasExternalInstallError(service_));
-  EXPECT_FALSE(service_->IsExtensionEnabled(page_action));
+  EXPECT_TRUE(extensions::HasExternalInstallError(service()));
+  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(extensions::HasExternalInstallError(service()));
+  EXPECT_TRUE(service()->IsExtensionEnabled(page_action));
 }
 
 // Test that installing multiple external extensions works.
 // Flaky on windows; http://crbug.com/295757 .
 #if defined(OS_WIN)
 #define MAYBE_ExternalInstallMultiple DISABLED_ExternalInstallMultiple
 #else
 #define MAYBE_ExternalInstallMultiple ExternalInstallMultiple
 #endif
 TEST_F(ExtensionServiceTest, MAYBE_ExternalInstallMultiple) {
   FeatureSwitch::ScopedOverride prompt(
       FeatureSwitch::prompt_for_external_extensions(), true);
 
   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,
       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));
+  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_));
+  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()));
 }
 
 // Test that there is a bubble for external extensions that update
 // from the webstore if the profile is not new.
 TEST_F(ExtensionServiceTest, ExternalInstallUpdatesFromWebstoreOldProfile) {
   FeatureSwitch::ScopedOverride prompt(
       FeatureSwitch::prompt_for_external_extensions(), true);
 
   // This sets up the ExtensionPrefs used by our ExtensionService to be
   // post-first run.
   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"),
+  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,
       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(extensions::HasExternalInstallError(service()));
+  EXPECT_TRUE(extensions::HasExternalInstallBubble(service()));
+  EXPECT_FALSE(service()->IsExtensionEnabled(updates_from_webstore));
 }
 
 // Test that there is no bubble for external extensions if the profile is new.
 TEST_F(ExtensionServiceTest, ExternalInstallUpdatesFromWebstoreNewProfile) {
   FeatureSwitch::ScopedOverride prompt(
       FeatureSwitch::prompt_for_external_extensions(), true);
 
   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);
+      new MockExtensionProvider(service(), Manifest::EXTERNAL_PREF);
   AddMockExternalProvider(provider);
   provider->UpdateOrAddExtension(updates_from_webstore, "1", crx_path);
 
   content::WindowedNotificationObserver observer(
       chrome::NOTIFICATION_CRX_INSTALLER_DONE,
       content::NotificationService::AllSources());
-  service_->CheckForExternalUpdates();
+  service()->CheckForExternalUpdates();
   observer.Wait();
-  EXPECT_TRUE(extensions::HasExternalInstallError(service_));
-  EXPECT_FALSE(extensions::HasExternalInstallBubble(service_));
-  EXPECT_FALSE(service_->IsExtensionEnabled(updates_from_webstore));
+  EXPECT_TRUE(extensions::HasExternalInstallError(service()));
+  EXPECT_FALSE(extensions::HasExternalInstallBubble(service()));
+  EXPECT_FALSE(service()->IsExtensionEnabled(updates_from_webstore));
 }
 
 TEST_F(ExtensionServiceTest, InstallBlacklistedExtension) {
   InitializeEmptyExtensionService();
 
   scoped_refptr<Extension> extension = extensions::ExtensionBuilder()
       .SetManifest(extensions::DictionaryBuilder()
           .Set("name", "extension")
           .Set("version", "1.0")
           .Set("manifest_version", 2).Build())
       .Build();
   ASSERT_TRUE(extension.get());
   const std::string& id = extension->id();
 
   std::set<std::string> id_set;
   id_set.insert(id);
   extensions::ExtensionNotificationObserver notifications(
       content::NotificationService::AllSources(), id_set);
 
   // Installation should be allowed but the extension should never have been
   // loaded and it should be blacklisted in prefs.
-  service_->OnExtensionInstalled(
-      extension.get(),
-      syncer::StringOrdinal(),
-      false /* has requirement errors */,
-      extensions::BLACKLISTED_MALWARE,
-      false /* is ephemeral */,
-      false /* wait for idle */);
+  service()->OnExtensionInstalled(extension.get(),
+                                  syncer::StringOrdinal(),
+                                  false /* has requirement errors */,
+                                  extensions::BLACKLISTED_MALWARE,
+                                  false /* is ephemeral */,
+                                  false /* wait for idle */);
   base::RunLoop().RunUntilIdle();
 
   // Extension was installed but not loaded.
   EXPECT_TRUE(notifications.CheckNotifications(
       chrome::NOTIFICATION_EXTENSION_INSTALLED_DEPRECATED));
-  EXPECT_TRUE(service_->GetInstalledExtension(id));
+  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(ExtensionPrefs::Get(profile_.get())->IsExtensionBlacklisted(id));
-  EXPECT_TRUE(ExtensionPrefs::Get(profile_.get())
-                  ->IsBlacklistedExtensionAcknowledged(id));
+  EXPECT_TRUE(ExtensionPrefs::Get(profile())->IsExtensionBlacklisted(id));
+  EXPECT_TRUE(
+      ExtensionPrefs::Get(profile())->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();
+  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_extensions, registry()->enabled_extensions().GetIDs());
   EXPECT_EQ(expected_disabled_extensions,
-            registry_->disabled_extensions().GetIDs());
+            registry()->disabled_extensions().GetIDs());
 }
 
 TEST_F(ExtensionServiceTest, ReconcileKnownDisabledWithSideEnable) {
   // A profile with 3 extensions installed: good0, good1, and good2.
   InitializeGoodInstalledExtensionService();
 
-  ExtensionPrefs* extension_prefs = ExtensionPrefs::Get(profile_.get());
+  ExtensionPrefs* extension_prefs = ExtensionPrefs::Get(profile());
 
   // 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();
+  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_extensions, registry()->enabled_extensions().GetIDs());
   EXPECT_EQ(expected_disabled_extensions,
-            registry_->disabled_extensions().GetIDs());
+            registry()->disabled_extensions().GetIDs());
 
   // Make sure that re-enabling an extension sticks across calls to
   // ReconcileKnownDisabled().
-  service_->EnableExtension(good2);
-  service_->ReconcileKnownDisabled();
+  service()->EnableExtension(good2);
+  service()->ReconcileKnownDisabled();
   expected_extensions.insert(good2);
   expected_disabled_extensions.erase(good2);
 
-  EXPECT_EQ(expected_extensions, registry_->enabled_extensions().GetIDs());
+  EXPECT_EQ(expected_extensions, registry()->enabled_extensions().GetIDs());
   EXPECT_EQ(expected_disabled_extensions,
-            registry_->disabled_extensions().GetIDs());
+            registry()->disabled_extensions().GetIDs());
 }
 
 // Tests a profile being destroyed correctly disables extensions.
 TEST_F(ExtensionServiceTest, DestroyingProfileClearsExtensions) {
   InitializeEmptyExtensionService();
 
-  InstallCRX(data_dir_.AppendASCII("good.crx"), INSTALL_NEW);
+  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());
+  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_.get()),
-                    content::NotificationService::NoDetails());
+  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());
+  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());
 }