Delegating the "are images allowed" decision to renderer.

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/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.h"
 #include "chrome/common/content_settings_pattern.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/common/content_switches.h"
 #include "grit/generated_resources.h"
 #include "grit/locale_settings.h"
@@ skipping 424 matching lines @@
     default:
       UpdateExceptionsViewFromOTRHostContentSettingsMap(type);
       break;
   }
 }
 
 void ContentSettingsHandler::UpdateGeolocationExceptionsView() {
   Profile* profile = Profile::FromWebUI(web_ui_);
   HostContentSettingsMap* map = profile->GetHostContentSettingsMap();
 
-  HostContentSettingsMap::SettingsForOneType all_settings;
+  ContentSettingsForOneType all_settings;
   map->GetSettingsForOneType(
       CONTENT_SETTINGS_TYPE_GEOLOCATION,
       std::string(),
       &all_settings);
 
   // Group geolocation settings by primary_pattern.
   AllPatternsSettings all_patterns_settings;
-  for (HostContentSettingsMap::SettingsForOneType::iterator i =
+  for (ContentSettingsForOneType::iterator i =
            all_settings.begin();
        i != all_settings.end();
        ++i) {
-    all_patterns_settings[i->a][i->b] = i->c;
+    all_patterns_settings[i->primary_pattern][i->secondary_pattern] =
+        i->setting;
   }
 
   ListValue exceptions;
   for (AllPatternsSettings::iterator i = all_patterns_settings.begin();
        i != all_patterns_settings.end();
        ++i) {
     const ContentSettingsPattern& primary_pattern = i->first;
     const OnePatternSettings& one_settings = i->second;
 
     OnePatternSettings::const_iterator parent =
@@ skipping 27 matching lines @@
   // This is mainly here to keep this function ideologically parallel to
   // UpdateExceptionsViewFromHostContentSettingsMap().
   UpdateSettingDefaultFromModel(CONTENT_SETTINGS_TYPE_GEOLOCATION);
 }
 
 void ContentSettingsHandler::UpdateNotificationExceptionsView() {
   Profile* profile = Profile::FromWebUI(web_ui_);
   DesktopNotificationService* service =
       DesktopNotificationServiceFactory::GetForProfile(profile);
 
-  HostContentSettingsMap::SettingsForOneType settings;
+  ContentSettingsForOneType settings;
   service->GetNotificationsSettings(&settings);
 
   ListValue exceptions;
-  for (HostContentSettingsMap::SettingsForOneType::const_iterator i =
+  for (ContentSettingsForOneType::const_iterator i =
            settings.begin();
        i != settings.end();
        ++i) {
-    const HostContentSettingsMap::PatternSettingSourceTuple& tuple(*i);
     exceptions.Append(
-        GetNotificationExceptionForPage(tuple.a, tuple.c, tuple.d));
+        GetNotificationExceptionForPage(i->primary_pattern, i->setting,
+                                        i->source));
   }
 
   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::UpdateExceptionsViewFromHostContentSettingsMap(
     ContentSettingsType type) {
-  HostContentSettingsMap::SettingsForOneType entries;
+  ContentSettingsForOneType entries;
   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") {
+    if (entries[i].primary_pattern == ContentSettingsPattern::Wildcard() &&
+        entries[i].secondary_pattern == ContentSettingsPattern::Wildcard() &&
+        entries[i].source != "preference") {
       continue;
     }
     // 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
     // able to modify content settings with a secondary pattern other than the
     // wildcard pattern. So only show settings that the user is able to modify.
     // TODO(bauerb): Support a read-only view for those patterns.
-    if (entries[i].b == ContentSettingsPattern::Wildcard()) {
+    if (entries[i].secondary_pattern == ContentSettingsPattern::Wildcard()) {
       exceptions.Append(
-          GetExceptionForPage(entries[i].a, entries[i].c, entries[i].d));
+          GetExceptionForPage(entries[i].primary_pattern, entries[i].setting,
+                              entries[i].source));
     } else {
       LOG(ERROR) << "Secondary content settings patterns are not "
                  << "supported by the content settings UI";
     }
   }
 
   StringValue type_string(ContentSettingsTypeToGroupName(type));
   web_ui_->CallJavascriptFunction("ContentSettings.setExceptions", type_string,
                                   exceptions);
 
   UpdateExceptionsViewFromOTRHostContentSettingsMap(type);
 
   // The default may also have changed (we won't get a separate notification).
   // If it hasn't changed, this call will be harmless.
   UpdateSettingDefaultFromModel(type);
 }
 
 void ContentSettingsHandler::UpdateExceptionsViewFromOTRHostContentSettingsMap(
     ContentSettingsType type) {
   const HostContentSettingsMap* otr_settings_map = GetOTRContentSettingsMap();
   if (!otr_settings_map)
     return;
 
-  HostContentSettingsMap::SettingsForOneType otr_entries;
+  ContentSettingsForOneType otr_entries;
   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)
+    if (!otr_entries[i].incognito)
       continue;
     // 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
     // able to modify content settings with a secondary pattern other than the
     // wildcard pattern. So only show settings that the user is able to modify.
     // TODO(bauerb): Support a read-only view for those patterns.
-    if (otr_entries[i].b == ContentSettingsPattern::Wildcard()) {
+    if (otr_entries[i].secondary_pattern ==
+        ContentSettingsPattern::Wildcard()) {
       otr_exceptions.Append(
-          GetExceptionForPage(otr_entries[i].a,
-                              otr_entries[i].c,
-                              otr_entries[i].d));
+          GetExceptionForPage(otr_entries[i].primary_pattern,
+                              otr_entries[i].setting,
+                              otr_entries[i].source));
     } else {
       LOG(ERROR) << "Secondary content settings patterns are not "
                  << "supported by the content settings UI";
     }
   }
 
   StringValue type_string(ContentSettingsTypeToGroupName(type));
   web_ui_->CallJavascriptFunction("ContentSettings.setOTRExceptions",
                                   type_string, otr_exceptions);
 }
@@ skipping 171 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;
 }