Removal of Profile from content part 6.

chrome/browser/ui/webui/options/content_settings_handler.cc

 // Copyright (c) 2011 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/options/content_settings_handler.h"
 
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/content_settings/content_settings_details.h"
 #include "chrome/browser/content_settings/content_settings_utils.h"
 #include "chrome/browser/content_settings/host_content_settings_map.h"
 #include "chrome/browser/custom_handlers/protocol_handler_registry.h"
 #include "chrome/browser/geolocation/geolocation_content_settings_map.h"
 #include "chrome/browser/notifications/desktop_notification_service.h"
 #include "chrome/browser/notifications/desktop_notification_service_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/content_settings_helper.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
+#include "content/browser/tab_contents/tab_contents.h"
 #include "content/common/content_notification_types.h"
 #include "content/common/notification_service.h"
 #include "content/common/notification_source.h"
 #include "grit/generated_resources.h"
 #include "grit/locale_settings.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace {
 
 struct ContentSettingsTypeNameEntry {
@@ skipping 237 matching lines @@
       NotificationService::AllSources());
 
   UpdateHandlersEnabledRadios();
   UpdateAllExceptionsViewsFromModel();
   notification_registrar_.Add(
       this, chrome::NOTIFICATION_CONTENT_SETTINGS_CHANGED,
       Source<HostContentSettingsMap>(settings_map));
   notification_registrar_.Add(
       this, chrome::NOTIFICATION_DESKTOP_NOTIFICATION_SETTINGS_CHANGED,
       NotificationService::AllSources());
+  Profile* profile =
+      Profile::FromBrowserContext(web_ui_->tab_contents()->browser_context());
   notification_registrar_.Add(
       this, chrome::NOTIFICATION_PROTOCOL_HANDLER_REGISTRY_CHANGED,
-      Source<Profile>(web_ui_->GetProfile()));
+      Source<Profile>(profile));
 
-  PrefService* prefs = web_ui_->GetProfile()->GetPrefs();
+  PrefService* prefs = profile->GetPrefs();
   pref_change_registrar_.Init(prefs);
   pref_change_registrar_.Add(prefs::kGeolocationContentSettings, this);
 }
 
 void ContentSettingsHandler::Observe(int type,
                                      const NotificationSource& source,
                                      const NotificationDetails& details) {
   switch (type) {
     case chrome::NOTIFICATION_PROFILE_DESTROYED: {
       if (Source<Profile>(source).ptr()->IsOffTheRecord()) {
@@ skipping 50 matching lines @@
       GetSettingDefaultFromModel(type));
   filter_settings.SetBoolean(ContentSettingsTypeToGroupName(type) + ".managed",
       GetDefaultSettingManagedFromModel(type));
 
   web_ui_->CallJavascriptFunction(
       "ContentSettings.setContentFilterSettingsValue", filter_settings);
 }
 
 std::string ContentSettingsHandler::GetSettingDefaultFromModel(
     ContentSettingsType type) {
+  Profile* profile =
+      Profile::FromBrowserContext(web_ui_->tab_contents()->browser_context());
   ContentSetting default_setting;
   if (type == CONTENT_SETTINGS_TYPE_NOTIFICATIONS) {
-    default_setting = DesktopNotificationServiceFactory::GetForProfile(
-        web_ui_->GetProfile())->GetDefaultContentSetting();
+    default_setting =
+        DesktopNotificationServiceFactory::GetForProfile(profile)->
+            GetDefaultContentSetting();
   } else {
-    default_setting = web_ui_->GetProfile()->
-        GetHostContentSettingsMap()->GetDefaultContentSetting(type);
+    default_setting =
+        profile-> GetHostContentSettingsMap()->GetDefaultContentSetting(type);
   }
 
   return ContentSettingToString(default_setting);
 }
 
 bool ContentSettingsHandler::GetDefaultSettingManagedFromModel(
     ContentSettingsType type) {
   if (type == CONTENT_SETTINGS_TYPE_NOTIFICATIONS) {
-    return DesktopNotificationServiceFactory::GetForProfile(
-        web_ui_->GetProfile())->IsDefaultContentSettingManaged();
+    Profile* profile =
+        Profile::FromBrowserContext(web_ui_->tab_contents()->browser_context());
+    return DesktopNotificationServiceFactory::GetForProfile(profile)->
+        IsDefaultContentSettingManaged();
   } else {
     return GetContentSettingsMap()->IsDefaultContentSettingManaged(type);
   }
 }
 
 void ContentSettingsHandler::UpdateHandlersEnabledRadios() {
 #if defined(ENABLE_REGISTER_PROTOCOL_HANDLER)
   DCHECK(web_ui_);
   FundamentalValue handlers_enabled(GetProtocolHandlerRegistry()->enabled());
 
@@ skipping 37 matching lines @@
     case CONTENT_SETTINGS_TYPE_GEOLOCATION:
     case CONTENT_SETTINGS_TYPE_NOTIFICATIONS:
       break;
     default:
       UpdateExceptionsViewFromOTRHostContentSettingsMap(type);
       break;
   }
 }
 
 void ContentSettingsHandler::UpdateGeolocationExceptionsView() {
-  GeolocationContentSettingsMap* map =
-      web_ui_->GetProfile()->GetGeolocationContentSettingsMap();
+  GeolocationContentSettingsMap* map = web_ui_->tab_contents()->
+      browser_context()->GetGeolocationContentSettingsMap();
   GeolocationContentSettingsMap::AllOriginsSettings all_settings =
       map->GetAllOriginsSettings();
   GeolocationContentSettingsMap::AllOriginsSettings::const_iterator i;
 
   ListValue exceptions;
   for (i = all_settings.begin(); i != all_settings.end(); ++i) {
     const GURL& origin = i->first;
     const GeolocationContentSettingsMap::OneOriginSettings& one_settings =
         i->second;
 
@@ skipping 22 matching lines @@
       ContentSettingsTypeToGroupName(CONTENT_SETTINGS_TYPE_GEOLOCATION));
   web_ui_->CallJavascriptFunction("ContentSettings.setExceptions",
                                   type_string, exceptions);
 
   // This is mainly here to keep this function ideologically parallel to
   // UpdateExceptionsViewFromHostContentSettingsMap().
   UpdateSettingDefaultFromModel(CONTENT_SETTINGS_TYPE_GEOLOCATION);
 }
 
 void ContentSettingsHandler::UpdateNotificationExceptionsView() {
+  Profile* profile =
+      Profile::FromBrowserContext(web_ui_->tab_contents()->browser_context());
   DesktopNotificationService* service =
-      DesktopNotificationServiceFactory::GetForProfile(web_ui_->GetProfile());
+      DesktopNotificationServiceFactory::GetForProfile(profile);
 
   std::vector<GURL> allowed(service->GetAllowedOrigins());
   std::vector<GURL> blocked(service->GetBlockedOrigins());
 
   ListValue exceptions;
   for (size_t i = 0; i < allowed.size(); ++i) {
     exceptions.Append(
         GetNotificationExceptionForPage(allowed[i], CONTENT_SETTING_ALLOW));
   }
   for (size_t i = 0; i < blocked.size(); ++i) {
@@ skipping 74 matching lines @@
   std::string group, setting;
   if (!(args->GetString(0, &group) &&
         args->GetString(1, &setting))) {
     NOTREACHED();
     return;
   }
 
   ContentSetting default_setting = ContentSettingFromString(setting);
   ContentSettingsType content_type = ContentSettingsTypeFromGroupName(group);
   if (content_type == CONTENT_SETTINGS_TYPE_NOTIFICATIONS) {
-    DesktopNotificationServiceFactory::GetForProfile(web_ui_->GetProfile())->
+    Profile* profile =
+        Profile::FromBrowserContext(web_ui_->tab_contents()->browser_context());
+    DesktopNotificationServiceFactory::GetForProfile(profile)->
         SetDefaultContentSetting(default_setting);
   } else {
     GetContentSettingsMap()->
         SetDefaultContentSetting(content_type, default_setting);
   }
 }
 
 void ContentSettingsHandler::RemoveException(const ListValue* args) {
   size_t arg_i = 0;
   std::string type_string;
   CHECK(args->GetString(arg_i++, &type_string));
 
+  Profile* profile =
+      Profile::FromBrowserContext(web_ui_->tab_contents()->browser_context());
   ContentSettingsType type = ContentSettingsTypeFromGroupName(type_string);
   if (type == CONTENT_SETTINGS_TYPE_GEOLOCATION) {
     std::string origin;
     std::string embedding_origin;
     bool rv = args->GetString(arg_i++, &origin);
     DCHECK(rv);
     rv = args->GetString(arg_i++, &embedding_origin);
     DCHECK(rv);
 
-    web_ui_->GetProfile()->GetGeolocationContentSettingsMap()->
+    profile->GetGeolocationContentSettingsMap()->
         SetContentSetting(GURL(origin),
                           GURL(embedding_origin),
                           CONTENT_SETTING_DEFAULT);
   } else if (type == CONTENT_SETTINGS_TYPE_NOTIFICATIONS) {
     std::string origin;
     std::string setting;
     bool rv = args->GetString(arg_i++, &origin);
     DCHECK(rv);
     rv = args->GetString(arg_i++, &setting);
     DCHECK(rv);
     ContentSetting content_setting = ContentSettingFromString(setting);
     if (content_setting == CONTENT_SETTING_ALLOW) {
-      DesktopNotificationServiceFactory::GetForProfile(web_ui_->GetProfile())->
+      DesktopNotificationServiceFactory::GetForProfile(profile)->
           ResetAllowedOrigin(GURL(origin));
     } else {
       DCHECK_EQ(content_setting, CONTENT_SETTING_BLOCK);
-      DesktopNotificationServiceFactory::GetForProfile(web_ui_->GetProfile())->
+      DesktopNotificationServiceFactory::GetForProfile(profile)->
           ResetBlockedOrigin(GURL(origin));
     }
   } else {
     std::string mode;
     bool rv = args->GetString(arg_i++, &mode);
     DCHECK(rv);
 
     std::string pattern;
     rv = args->GetString(arg_i++, &pattern);
     DCHECK(rv);
@@ skipping 78 matching lines @@
   for (size_t i = 0; i < arraysize(kContentSettingsTypeGroupNames); ++i) {
     if (type == kContentSettingsTypeGroupNames[i].type)
       return kContentSettingsTypeGroupNames[i].name;
   }
 
   NOTREACHED();
   return std::string();
 }
 
 HostContentSettingsMap* ContentSettingsHandler::GetContentSettingsMap() {
-  return web_ui_->GetProfile()->GetHostContentSettingsMap();
+  Profile* profile =
+      Profile::FromBrowserContext(web_ui_->tab_contents()->browser_context());
+  return profile->GetHostContentSettingsMap();
 }
 
 ProtocolHandlerRegistry* ContentSettingsHandler::GetProtocolHandlerRegistry() {
-  return web_ui_->GetProfile()->GetProtocolHandlerRegistry();
+  Profile* profile =
+      Profile::FromBrowserContext(web_ui_->tab_contents()->browser_context());
+  return profile->GetProtocolHandlerRegistry();
 }
 
 HostContentSettingsMap*
     ContentSettingsHandler::GetOTRContentSettingsMap() {
-  Profile* profile = web_ui_->GetProfile();
+  Profile* profile =
+      Profile::FromBrowserContext(web_ui_->tab_contents()->browser_context());
   if (profile->HasOffTheRecordProfile())
     return profile->GetOffTheRecordProfile()->GetHostContentSettingsMap();
   return NULL;
 }