Remove ExtensionService::extension_prefs()

chrome/browser/ui/webui/extensions/extension_settings_handler.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/ui/webui/extensions/extension_settings_handler.h"
 
 #include "apps/app_load_service.h"
 #include "apps/app_restore_service.h"
 #include "apps/saved_files_service.h"
 #include "apps/shell_window.h"
@@ skipping 180 matching lines @@
 }
 
 base::DictionaryValue* ExtensionSettingsHandler::CreateExtensionDetailValue(
     const Extension* extension,
     const std::vector<ExtensionPage>& pages,
     const ExtensionWarningService* warning_service) {
   base::DictionaryValue* extension_data = new base::DictionaryValue();
   bool enabled = extension_service_->IsExtensionEnabled(extension->id());
   GetExtensionBasicInfo(extension, enabled, extension_data);
 
-  ExtensionPrefs* prefs = extension_service_->extension_prefs();
+  ExtensionPrefs* prefs = ExtensionPrefs::Get(extension_service_->profile());
   int disable_reasons = prefs->GetDisableReasons(extension->id());
 
   bool suspicious_install =
       (disable_reasons & Extension::DISABLE_NOT_VERIFIED) != 0;
   extension_data->SetBoolean("suspiciousInstall", suspicious_install);
   if (suspicious_install)
     should_do_verification_check_ = true;
 
   bool managed_install =
       !management_policy_->UserMayModifySettings(extension, NULL);
@@ skipping 40 matching lines @@
       !ManifestURL::UpdatesFromGallery(extension)) {
     location_text = l10n_util::GetStringUTF16(
         IDS_OPTIONS_INSTALL_LOCATION_UNKNOWN);
   } else if (extension->location() == Manifest::EXTERNAL_REGISTRY) {
     location_text = l10n_util::GetStringUTF16(
         IDS_OPTIONS_INSTALL_LOCATION_3RD_PARTY);
   }
   extension_data->SetString("locationText", location_text);
 
   base::string16 blacklist_text;
-  switch (extension_service_->extension_prefs()->GetExtensionBlacklistState(
-              extension->id())) {
+  switch (prefs->GetExtensionBlacklistState(extension->id())) {
     case BLACKLISTED_SECURITY_VULNERABILITY:
       blacklist_text = l10n_util::GetStringUTF16(
           IDS_OPTIONS_BLACKLISTED_SECURITY_VULNERABILITY);
       break;
 
     case BLACKLISTED_CWS_POLICY_VIOLATION:
       blacklist_text = l10n_util::GetStringUTF16(
           IDS_OPTIONS_BLACKLISTED_CWS_POLICY_VIOLATION);
       break;
 
     case BLACKLISTED_POTENTIALLY_UNWANTED:
       blacklist_text = l10n_util::GetStringUTF16(
           IDS_OPTIONS_BLACKLISTED_POTENTIALLY_UNWANTED);
       break;
 
     default:
       break;
   }
   extension_data->SetString("blacklistText", blacklist_text);
 
   // Force unpacked extensions to show at the top.
   if (Manifest::IsUnpackedLocation(extension->location()))
     extension_data->SetInteger("order", 1);
   else
     extension_data->SetInteger("order", 2);
 
-  if (!ExtensionActionAPI::GetBrowserActionVisibility(
-          extension_service_->extension_prefs(), extension->id())) {
+  if (!ExtensionActionAPI::GetBrowserActionVisibility(prefs, extension->id())) {
     extension_data->SetBoolean("enable_show_button", true);
   }
 
   // Add views
   base::ListValue* views = new base::ListValue;
   for (std::vector<ExtensionPage>::const_iterator iter = pages.begin();
        iter != pages.end(); ++iter) {
     base::DictionaryValue* view_value = new base::DictionaryValue;
     if (iter->url.scheme() == kExtensionScheme) {
       // No leading slash.
@@ skipping 443 matching lines @@
   results.Set("extensions", extensions_list);
 
   bool is_managed = profile->IsManaged();
   bool developer_mode =
       !is_managed &&
       profile->GetPrefs()->GetBoolean(prefs::kExtensionsUIDeveloperMode);
   results.SetBoolean("profileIsManaged", is_managed);
   results.SetBoolean("developerMode", developer_mode);
 
   bool load_unpacked_disabled =
-      extension_service_->extension_prefs()->ExtensionsBlacklistedByDefault();
+      ExtensionPrefs::Get(profile)->ExtensionsBlacklistedByDefault();
   results.SetBoolean("loadUnpackedDisabled", load_unpacked_disabled);
 
   web_ui()->CallJavascriptFunction(
       "extensions.ExtensionSettings.returnExtensionsData", results);
 
   MaybeRegisterForNotifications();
   UMA_HISTOGRAM_BOOLEAN("ExtensionSettings.ShouldDoVerificationCheck",
                         should_do_verification_check_);
   if (should_do_verification_check_) {
     should_do_verification_check_ = false;
@@ skipping 80 matching lines @@
   const Extension* extension =
       extension_service_->GetInstalledExtension(extension_id);
   if (!extension ||
       !management_policy_->UserMayModifySettings(extension, NULL)) {
     LOG(ERROR) << "Attempt to enable an extension that is non-usermanagable was"
                << "made. Extension id: " << extension->id();
     return;
   }
 
   if (enable_str == "true") {
-    ExtensionPrefs* prefs = extension_service_->extension_prefs();
+    ExtensionPrefs* prefs = ExtensionPrefs::Get(extension_service_->profile());
     if (prefs->DidExtensionEscalatePermissions(extension_id)) {
       ShowExtensionDisabledDialog(
           extension_service_, web_ui()->GetWebContents(), extension);
     } else if ((prefs->GetDisableReasons(extension_id) &
                    Extension::DISABLE_UNSUPPORTED_REQUIREMENT) &&
                !requirements_checker_.get()) {
       // Recheck the requirements.
       scoped_refptr<const Extension> extension =
           extension_service_->GetExtensionById(extension_id,
                                                true /* include disabled */);
@@ skipping 124 matching lines @@
   prompt_->ReviewPermissions(
       new BrokerDelegate(AsWeakPtr()), extension, retained_file_paths);
 }
 
 void ExtensionSettingsHandler::HandleShowButtonMessage(
     const base::ListValue* args) {
   const Extension* extension = GetActiveExtension(args);
   if (!extension)
     return;
   ExtensionActionAPI::SetBrowserActionVisibility(
-      extension_service_->extension_prefs(), extension->id(), true);
+      ExtensionPrefs::Get(extension_service_->profile()),
+      extension->id(),
+      true);
 }
 
 void ExtensionSettingsHandler::HandleAutoUpdateMessage(
     const base::ListValue* args) {
   ExtensionUpdater* updater = extension_service_->updater();
   if (updater) {
     ExtensionUpdater::CheckParams params;
     params.install_immediately = true;
     updater->CheckNow(params);
   }
@@ skipping 64 matching lines @@
                  content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Add(this,
                  chrome::NOTIFICATION_BACKGROUND_CONTENTS_NAVIGATED,
                  content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Add(this,
                  chrome::NOTIFICATION_BACKGROUND_CONTENTS_DELETED,
                  content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Add(
       this,
       chrome::NOTIFICATION_EXTENSION_BROWSER_ACTION_VISIBILITY_CHANGED,
-      content::Source<ExtensionPrefs>(
-          profile->GetExtensionService()->extension_prefs()));
+      content::Source<ExtensionPrefs>(ExtensionPrefs::Get(profile)));
   registrar_.Add(this,
                  chrome::NOTIFICATION_EXTENSION_HOST_DESTROYED,
                  content::NotificationService::AllBrowserContextsAndSources());
 
   registrar_.Add(this,
                  content::NOTIFICATION_RENDER_WIDGET_HOST_DESTROYED,
                  content::NotificationService::AllBrowserContextsAndSources());
 
   content::WebContentsObserver::Observe(web_ui()->GetWebContents());
 
@@ skipping 149 matching lines @@
     extension_service_->EnableExtension(extension_id);
   } else {
     ExtensionErrorReporter::GetInstance()->ReportError(
         base::UTF8ToUTF16(JoinString(requirement_errors, ' ')),
         true /* be noisy */);
   }
   requirements_checker_.reset();
 }
 
 }  // namespace extensions