Adding CookieSettings for storing cookie content settings.

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 <map>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.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/cookie_settings.h"
 #include "chrome/browser/content_settings/host_content_settings_map.h"
 #include "chrome/browser/custom_handlers/protocol_handler_registry.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_pattern.h"
 #include "chrome/common/pref_names.h"
@@ skipping 348 matching lines @@
 }
 
 std::string ContentSettingsHandler::GetSettingDefaultFromModel(
     ContentSettingsType type, std::string* provider_id) {
   Profile* profile = Profile::FromWebUI(web_ui_);
   ContentSetting default_setting;
   if (type == CONTENT_SETTINGS_TYPE_NOTIFICATIONS) {
     default_setting =
         DesktopNotificationServiceFactory::GetForProfile(profile)->
             GetDefaultContentSetting(provider_id);
+  } else if (type == CONTENT_SETTINGS_TYPE_COOKIES) {
+    default_setting = CookieSettings::GetForProfile(profile)->
+        GetDefaultCookieSetting(provider_id);
   } else {
     default_setting =
         profile->GetHostContentSettingsMap()->
             GetDefaultContentSetting(type, provider_id);
   }
 
   return ContentSettingToString(default_setting);
 }
 
 void ContentSettingsHandler::UpdateHandlersEnabledRadios() {
@@ skipping 150 matching lines @@
                                   type_string, exceptions);
 
   // This is mainly here to keep this function ideologically parallel to
   // UpdateExceptionsViewFromHostContentSettingsMap().
   UpdateSettingDefaultFromModel(CONTENT_SETTINGS_TYPE_NOTIFICATIONS);
 }
 
 void ContentSettingsHandler::UpdateExceptionsViewFromHostContentSettingsMap(
     ContentSettingsType type) {
   HostContentSettingsMap::SettingsForOneType entries;
-  GetContentSettingsMap()->GetSettingsForOneType(type, "", &entries);
+  if (type == CONTENT_SETTINGS_TYPE_COOKIES)
+    GetCookieSettings()->GetCookieSettings(&entries);
+  else
+    GetContentSettingsMap()->GetSettingsForOneType(type, "", &entries);
 
   ListValue exceptions;
   for (size_t i = 0; i < entries.size(); ++i) {
     // Skip default settings from extensions and policy, and the default content
     // settings; all of them will affect the default setting UI.
     if (entries[i].a == ContentSettingsPattern::Wildcard() &&
         entries[i].b == ContentSettingsPattern::Wildcard() &&
         entries[i].d != "preference") {
       continue;
     }
@@ skipping 23 matching lines @@
   UpdateSettingDefaultFromModel(type);
 }
 
 void ContentSettingsHandler::UpdateExceptionsViewFromOTRHostContentSettingsMap(
     ContentSettingsType type) {
   const HostContentSettingsMap* otr_settings_map = GetOTRContentSettingsMap();
   if (!otr_settings_map)
     return;
 
   HostContentSettingsMap::SettingsForOneType otr_entries;
-  otr_settings_map->GetSettingsForOneType(type, "", &otr_entries);
+  if (type == CONTENT_SETTINGS_TYPE_COOKIES) {
+    const CookieSettings* otr_cookie_settings = GetOTRCookieSettings();
+    if (!otr_cookie_settings)
+      return;
+    otr_cookie_settings->GetCookieSettings(&otr_entries);
+  } else {
+    otr_settings_map->GetSettingsForOneType(type, "", &otr_entries);
+  }
 
   ListValue otr_exceptions;
   for (size_t i = 0; i < otr_entries.size(); ++i) {
     // Off-the-record HostContentSettingsMap contains incognito content settings
     // as well as normal content settings. Here, we use the incongnito settings
     // only.
     if (!otr_entries[i].e)
       continue;
     // The content settings UI does not support secondary content settings
     // pattern yet. For content settings set through the content settings UI the
@@ skipping 89 matching lines @@
         ClearSetting(ContentSettingsPattern::FromString(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);
 
-    HostContentSettingsMap* settings_map =
-        mode == "normal" ? GetContentSettingsMap() :
-                           GetOTRContentSettingsMap();
-    // The settings map could be null if the mode was OTR but the OTR profile
-    // got destroyed before we received this message.
-    if (settings_map) {
-      settings_map->SetContentSetting(
-          ContentSettingsPattern::FromString(pattern),
-          ContentSettingsPattern::Wildcard(),
-          ContentSettingsTypeFromGroupName(type_string),
-          "",
-          CONTENT_SETTING_DEFAULT);
+    if (type == CONTENT_SETTINGS_TYPE_COOKIES) {
+      CookieSettings* cookie_settings =
+          mode == "normal" ? GetCookieSettings() :
+                             GetOTRCookieSettings();
+      // |cookie_settings| could be null if the mode was OTR but the OTR profile
+      // got destroyed before we received this message.
+      if (cookie_settings) {
+        cookie_settings->ResetCookieSetting(
+            ContentSettingsPattern::FromString(pattern),
+            ContentSettingsPattern::Wildcard());
+      }
+    } else {
+      HostContentSettingsMap* settings_map =
+          mode == "normal" ? GetContentSettingsMap() :
+                             GetOTRContentSettingsMap();
+      // |settings_map| could be null if the mode was OTR but the OTR profile
+      // got destroyed before we received this message.
+      if (settings_map) {
+        settings_map->SetContentSetting(
+            ContentSettingsPattern::FromString(pattern),
+            ContentSettingsPattern::Wildcard(),
+            ContentSettingsTypeFromGroupName(type_string),
+            "",
+            CONTENT_SETTING_DEFAULT);
+      }
     }
   }
 }
 
 void ContentSettingsHandler::SetException(const ListValue* args) {
   size_t arg_i = 0;
   std::string type_string;
   CHECK(args->GetString(arg_i++, &type_string));
   std::string mode;
   CHECK(args->GetString(arg_i++, &mode));
   std::string pattern;
   CHECK(args->GetString(arg_i++, &pattern));
   std::string setting;
   CHECK(args->GetString(arg_i++, &setting));
 
   ContentSettingsType type = ContentSettingsTypeFromGroupName(type_string);
   if (type == CONTENT_SETTINGS_TYPE_GEOLOCATION ||
       type == CONTENT_SETTINGS_TYPE_NOTIFICATIONS) {
     NOTREACHED();
     return;
   }
 
-  HostContentSettingsMap* settings_map =
-      mode == "normal" ? GetContentSettingsMap() :
-                         GetOTRContentSettingsMap();
+  if (type == CONTENT_SETTINGS_TYPE_COOKIES) {
+    CookieSettings* cookie_settings =
+        mode == "normal" ? GetCookieSettings() :
+                           GetOTRCookieSettings();
 
-  // The settings map could be null if the mode was OTR but the OTR profile
-  // got destroyed before we received this message.
-  if (!settings_map)
-    return;
-  settings_map->SetContentSetting(ContentSettingsPattern::FromString(pattern),
-                                  ContentSettingsPattern::Wildcard(),
-                                  type,
-                                  "",
-                                  ContentSettingFromString(setting));
+    // |cookie_settings| could be null if the mode was OTR but the OTR profile
+    // got destroyed before we received this message.
+    if (!cookie_settings)
+      return;
+    cookie_settings->SetCookieSetting(
+        ContentSettingsPattern::FromString(pattern),
+        ContentSettingsPattern::Wildcard(),
+        ContentSettingFromString(setting));
+  } else {
+    HostContentSettingsMap* settings_map =
+        mode == "normal" ? GetContentSettingsMap() :
+                           GetOTRContentSettingsMap();
+
+    // |settings_map| could be null if the mode was OTR but the OTR profile
+    // got destroyed before we received this message.
+    if (!settings_map)
+      return;
+    settings_map->SetContentSetting(ContentSettingsPattern::FromString(pattern),
+                                    ContentSettingsPattern::Wildcard(),
+                                    type,
+                                    "",
+                                    ContentSettingFromString(setting));
+  }
 }
 
 void ContentSettingsHandler::CheckExceptionPatternValidity(
     const ListValue* args) {
   size_t arg_i = 0;
   Value* type;
   CHECK(args->Get(arg_i++, &type));
   std::string mode_string;
   CHECK(args->GetString(arg_i++, &mode_string));
   std::string pattern_string;
@@ skipping 34 matching lines @@
   return Profile::FromWebUI(web_ui_)->GetProtocolHandlerRegistry();
 }
 
 HostContentSettingsMap*
     ContentSettingsHandler::GetOTRContentSettingsMap() {
   Profile* profile = Profile::FromWebUI(web_ui_);
   if (profile->HasOffTheRecordProfile())
     return profile->GetOffTheRecordProfile()->GetHostContentSettingsMap();
   return NULL;
 }
+
+CookieSettings* ContentSettingsHandler::GetCookieSettings() {
+  return CookieSettings::GetForProfile(Profile::FromWebUI(web_ui_));
+}
+
+CookieSettings* ContentSettingsHandler::GetOTRCookieSettings() {
+  Profile* profile = Profile::FromWebUI(web_ui_);
+  if (profile->HasOffTheRecordProfile())
+    return CookieSettings::GetForProfile(profile->GetOffTheRecordProfile());
+  return NULL;
+}