HostContentSettingsMap refactoring.

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/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_pattern.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/pref_names.h"
 #include "chrome/common/url_constants.h"
@@ skipping 26 matching lines @@
 const ContentSettingsTypeNameEntry kContentSettingsTypeGroupNames[] = {
   {CONTENT_SETTINGS_TYPE_COOKIES, "cookies"},
   {CONTENT_SETTINGS_TYPE_IMAGES, "images"},
   {CONTENT_SETTINGS_TYPE_JAVASCRIPT, "javascript"},
   {CONTENT_SETTINGS_TYPE_PLUGINS, "plugins"},
   {CONTENT_SETTINGS_TYPE_POPUPS, "popups"},
   {CONTENT_SETTINGS_TYPE_GEOLOCATION, "location"},
   {CONTENT_SETTINGS_TYPE_NOTIFICATIONS, "notifications"},
   {CONTENT_SETTINGS_TYPE_INTENTS, "intents"},
   {CONTENT_SETTINGS_TYPE_AUTO_SELECT_CERTIFICATE, "auto-select-certificate"},
+  {CONTENT_SETTINGS_TYPE_PERMANENT_COOKIES, "permanent-cookies"},
 };
 COMPILE_ASSERT(arraysize(kContentSettingsTypeGroupNames) ==
                    CONTENT_SETTINGS_NUM_TYPES,
                MISSING_CONTENT_SETTINGS_TYPE);
 
 ContentSettingsType ContentSettingsTypeFromGroupName(const std::string& name) {
   for (size_t i = 0; i < arraysize(kContentSettingsTypeGroupNames); ++i) {
     if (name == kContentSettingsTypeGroupNames[i].name)
       return kContentSettingsTypeGroupNames[i].type;
   }
@@ skipping 289 matching lines @@
 }
 
 std::string ContentSettingsHandler::GetSettingDefaultFromModel(
     ContentSettingsType type) {
   Profile* profile = Profile::FromWebUI(web_ui_);
   ContentSetting default_setting;
   if (type == CONTENT_SETTINGS_TYPE_NOTIFICATIONS) {
     default_setting =
         DesktopNotificationServiceFactory::GetForProfile(profile)->
             GetDefaultContentSetting();
+  } else if (type == CONTENT_SETTINGS_TYPE_COOKIES) {
+    default_setting =
+        CookieSettings::GetForProfile(profile)->GetDefaultCookieSetting();
   } else {
     default_setting =
         profile->GetHostContentSettingsMap()->GetDefaultContentSetting(type);
   }
 
   return ContentSettingToString(default_setting);
 }
 
 bool ContentSettingsHandler::GetDefaultSettingManagedFromModel(
     ContentSettingsType type) {
@@ skipping 18 matching lines @@
 }
 
 void ContentSettingsHandler::UpdateAllExceptionsViewsFromModel() {
   for (int type = CONTENT_SETTINGS_TYPE_DEFAULT + 1;
        type < CONTENT_SETTINGS_NUM_TYPES; ++type) {
     // The content settings type CONTENT_SETTINGS_TYPE_AUTO_SELECT_CERTIFICATE
     // is supposed to be set by policy only. Hence there is no user facing UI
     // for this content type and we skip it here.
     if (type == CONTENT_SETTINGS_TYPE_AUTO_SELECT_CERTIFICATE)
       continue;
+    // No UI for permanent cookies; cookie settings are handled by
+    // CONTENT_SETTINGS_TYPE_COOKIES.
+    if (type == CONTENT_SETTINGS_TYPE_PERMANENT_COOKIES)
+      continue;
     UpdateExceptionsViewFromModel(static_cast<ContentSettingsType>(type));
   }
 }
 
 void ContentSettingsHandler::UpdateAllOTRExceptionsViewsFromModel() {
   for (int type = CONTENT_SETTINGS_TYPE_DEFAULT + 1;
        type < CONTENT_SETTINGS_NUM_TYPES; ++type) {
+    // No UI for permanent cookies; cookie settings are handled by
+    // CONTENT_SETTINGS_TYPE_COOKIES.
+    if (type == CONTENT_SETTINGS_TYPE_PERMANENT_COOKIES)
+      continue;
     UpdateOTRExceptionsViewFromModel(static_cast<ContentSettingsType>(type));
   }
 }
 
 void ContentSettingsHandler::UpdateExceptionsViewFromModel(
     ContentSettingsType type) {
   switch (type) {
     case CONTENT_SETTINGS_TYPE_GEOLOCATION:
       UpdateGeolocationExceptionsView();
       break;
     case CONTENT_SETTINGS_TYPE_NOTIFICATIONS:
       UpdateNotificationExceptionsView();
       break;
+    case CONTENT_SETTINGS_TYPE_COOKIES:
+      UpdateCookieExceptionsView();
+      break;
     default:
       UpdateExceptionsViewFromHostContentSettingsMap(type);
       break;
   }
 }
 
 void ContentSettingsHandler::UpdateOTRExceptionsViewFromModel(
     ContentSettingsType type) {
   switch (type) {
     case CONTENT_SETTINGS_TYPE_GEOLOCATION:
@@ skipping 85 matching lines @@
   StringValue type_string(
       ContentSettingsTypeToGroupName(CONTENT_SETTINGS_TYPE_NOTIFICATIONS));
   web_ui_->CallJavascriptFunction("ContentSettings.setExceptions",
                                   type_string, exceptions);
 
   // This is mainly here to keep this function ideologically parallel to
   // UpdateExceptionsViewFromHostContentSettingsMap().
   UpdateSettingDefaultFromModel(CONTENT_SETTINGS_TYPE_NOTIFICATIONS);
 }
 
+void ContentSettingsHandler::UpdateCookieExceptionsView() {
+  UpdateCookieExceptionsViewFromCookieSettings(
+      GetCookieSettings(), "ContentSettings.setExceptions");
+  UpdateCookieExceptionsViewFromCookieSettings(
+      GetOTRCookieSettings(), "ContentSettings.setOTRExceptions");
+  // This is mainly here to keep this function ideologically parallel to
+  // UpdateExceptionsViewFromHostContentSettingsMap().
+  UpdateSettingDefaultFromModel(CONTENT_SETTINGS_TYPE_COOKIES);
+}
+
+void ContentSettingsHandler::UpdateCookieExceptionsViewFromCookieSettings(
+    CookieSettings* cookie_settings,
+    const std::string& function_name) {
+  if (!cookie_settings)
+    return;
+
+  HostContentSettingsMap::SettingsForOneType entries;
+  cookie_settings->GetCookieSettings(&entries);
+
+  ListValue exceptions;
+  for (size_t i = 0; i < entries.size(); ++i) {
+    exceptions.Append(
+        GetExceptionForPage(entries[i].a, entries[i].c, entries[i].d));
+  }
+
+  StringValue type_string(
+      ContentSettingsTypeToGroupName(CONTENT_SETTINGS_TYPE_COOKIES));
+  web_ui_->CallJavascriptFunction(function_name, type_string, exceptions);
+}
+
 void ContentSettingsHandler::UpdateExceptionsViewFromHostContentSettingsMap(
     ContentSettingsType type) {
   HostContentSettingsMap::SettingsForOneType entries;
   GetContentSettingsMap()->GetSettingsForOneType(type, "", &entries);
 
   ListValue exceptions;
   for (size_t i = 0; i < entries.size(); ++i) {
     // The content settings UI does not support secondary content settings
     // pattern yet. For content settings set through the content settings UI the
     // secondary pattern is by default a wildcard pattern. Hence users are not
@@ skipping 63 matching lines @@
     NOTREACHED();
     return;
   }
 
   ContentSetting default_setting = ContentSettingFromString(setting);
   ContentSettingsType content_type = ContentSettingsTypeFromGroupName(group);
   if (content_type == CONTENT_SETTINGS_TYPE_NOTIFICATIONS) {
     Profile* profile = Profile::FromWebUI(web_ui_);
     DesktopNotificationServiceFactory::GetForProfile(profile)->
         SetDefaultContentSetting(default_setting);
+  } else if (content_type == CONTENT_SETTINGS_TYPE_COOKIES) {
+    GetCookieSettings()->SetDefaultCookieSetting(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));
@@ skipping 35 matching lines @@
     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();
+        if (cookie_settings == NULL) {
+          NOTREACHED();
+          return;
+        }
+        cookie_settings->ResetCookieSetting(
+            ContentSettingsPattern::FromString(pattern));
+      } else {
+        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();
-
   // 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));
+  if (type == CONTENT_SETTINGS_TYPE_COOKIES) {
+    CookieSettings* cookie_settings =
+        mode == "normal" ? GetCookieSettings() : GetOTRCookieSettings();
+    DCHECK(cookie_settings != NULL);
+    cookie_settings->SetCookieSetting(
+        ContentSettingsPattern::FromString(pattern),
+        ContentSettingFromString(setting));
+  } else {
+    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;
+}