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 304 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));

[Bernhard Bauer, 2011/10/25 13:11:21]

Is it actually necessary to go through CookieSettings here?

[marja, 2011/10/26 13:03:21]

There are 2 approaches: 1) Everything goes via CookieSettings (except extensions
which write directly to ExtensionContentSettingsStore) 2) CookieSettings is just
an alternative frontend to HostContentSettingsMap. I tried to do 1), to be able
to change the representation format inside CookieSettings without causing
changes in other components. But it's not that clear which is better.

[Bernhard Bauer, 2011/10/26 13:24:09]

I think it's fine if code that is not specific to cookies goes directly through
the HostContentSettingsMap. 

If we really want to do 1) we should make sure that no one accesses the
HostContentSettingsMap directly (but then we'd need to duplicate the code that
finds the correct map at all call sites, which is what you're starting to do
here. I just think that's unnecessary).

[marja, 2011/10/27 08:48:51]

Ok, I removed the CookieSettings usage here.

+      }
+    } 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),
+        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;
+}