Flesh out the content settings exceptions lists a bit more.

chrome/browser/dom_ui/content_settings_handler.cc

 // Copyright (c) 2010 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/dom_ui/content_settings_handler.h"
 
 #include "app/l10n_util.h"
 #include "base/callback.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/host_content_settings_map.h"
 #include "chrome/browser/profile.h"
+#include "chrome/common/notification_service.h"
+#include "chrome/common/notification_source.h"
+#include "chrome/common/notification_type.h"
 #include "chrome/common/url_constants.h"
 #include "grit/generated_resources.h"
 #include "grit/locale_settings.h"
 
+typedef HostContentSettingsMap::ContentSettingsDetails ContentSettingsDetails;
+
 namespace {
 
 std::wstring ContentSettingsTypeToGroupName(ContentSettingsType type) {
   switch (type) {
     case CONTENT_SETTINGS_TYPE_COOKIES:
       return L"cookies";
     case CONTENT_SETTINGS_TYPE_IMAGES:
       return L"images";
     case CONTENT_SETTINGS_TYPE_JAVASCRIPT:
       return L"javascript";
@@ skipping 72 matching lines @@
   DCHECK(localized_strings);
 
   localized_strings->SetString(L"content_exceptions",
       l10n_util::GetString(IDS_COOKIES_EXCEPTIONS_BUTTON));
   localized_strings->SetString(L"contentSettingsPage",
       l10n_util::GetString(IDS_CONTENT_SETTINGS_TITLE));
   localized_strings->SetString(L"allowException",
       l10n_util::GetString(IDS_EXCEPTIONS_ALLOW_BUTTON));
   localized_strings->SetString(L"blockException",
       l10n_util::GetString(IDS_EXCEPTIONS_BLOCK_BUTTON));
+  localized_strings->SetString(L"addExceptionRow",
+      l10n_util::GetString(IDS_EXCEPTIONS_ADD_BUTTON));
+  localized_strings->SetString(L"removeExceptionRow",
+      l10n_util::GetString(IDS_EXCEPTIONS_REMOVE_BUTTON));
 
   // Cookies filter.
   localized_strings->SetString(L"cookies_tab_label",
       l10n_util::GetString(IDS_COOKIES_TAB_LABEL));
   localized_strings->SetString(L"cookies_modify",
       l10n_util::GetString(IDS_MODIFY_COOKIE_STORING_LABEL));
   localized_strings->SetString(L"cookies_allow",
       l10n_util::GetString(IDS_COOKIES_ALLOW_RADIO));
   localized_strings->SetString(L"cookies_block",
       l10n_util::GetString(IDS_COOKIES_BLOCK_RADIO));
@@ skipping 95 matching lines @@
 
   dom_ui_->CallJavascriptFunction(
       L"ContentSettings.setInitialContentFilterSettingsValue", filter_settings);
 
   scoped_ptr<Value> bool_value(Value::CreateBooleanValue(
       settings_map->BlockThirdPartyCookies()));
   dom_ui_->CallJavascriptFunction(
       L"ContentSettings.setBlockThirdPartyCookies", *bool_value.get());
 
   UpdateImagesExceptionsViewFromModel();
+  notification_registrar_.Add(
+      this, NotificationType::CONTENT_SETTINGS_CHANGED,
+      Source<const HostContentSettingsMap>(settings_map));
 }
 
 // TODO(estade): generalize this function to work on all content settings types
 // rather than just images.
-// TODO(estade): call this in response to content exceptions change
-// notifications.
+void ContentSettingsHandler::Observe(NotificationType type,
+                                     const NotificationSource& source,
+                                     const NotificationDetails& details) {
+  if (type != NotificationType::CONTENT_SETTINGS_CHANGED)
+    return OptionsPageUIHandler::Observe(type, source, details);
+
+  const ContentSettingsDetails* settings_details =
+      static_cast<Details<const ContentSettingsDetails> >(details).ptr();
+
+  if (settings_details->type() == CONTENT_SETTINGS_TYPE_IMAGES ||
+      settings_details->update_all_types()) {
+    // TODO(estade): we pretend update_all() is always true.
+    UpdateImagesExceptionsViewFromModel();
+  }
+}
+
+// TODO(estade): generalize this function to work on all content settings types
+// rather than just images.
 void ContentSettingsHandler::UpdateImagesExceptionsViewFromModel() {
   HostContentSettingsMap::SettingsForOneType entries;
   const HostContentSettingsMap* settings_map =
       dom_ui_->GetProfile()->GetHostContentSettingsMap();
   settings_map->GetSettingsForOneType(CONTENT_SETTINGS_TYPE_IMAGES, &entries);
 
   ListValue exceptions;
   for (size_t i = 0; i < entries.size(); ++i) {
     ListValue* exception = new ListValue();
     exception->Append(new StringValue(entries[i].first.AsString()));
     exception->Append(
         new StringValue(ContentSettingToString(entries[i].second)));
     exceptions.Append(exception);
   }
 
   dom_ui_->CallJavascriptFunction(
       L"ContentSettings.setImagesExceptions", exceptions);
 }
 
 void ContentSettingsHandler::RegisterMessages() {
   dom_ui_->RegisterMessageCallback("setContentFilter",
       NewCallback(this,
                   &ContentSettingsHandler::SetContentFilter));
   dom_ui_->RegisterMessageCallback("setAllowThirdPartyCookies",
       NewCallback(this,
                   &ContentSettingsHandler::SetAllowThirdPartyCookies));
+  dom_ui_->RegisterMessageCallback("removeImageExceptions",
+      NewCallback(this,
+                  &ContentSettingsHandler::RemoveExceptions));
 }
 
 void ContentSettingsHandler::SetContentFilter(const Value* value) {
   const ListValue* list_value = static_cast<const ListValue*>(value);
   DCHECK_EQ(2U, list_value->GetSize());
   std::string group, setting;
   if (!(list_value->GetString(0, &group) &&
         list_value->GetString(1, &setting))) {
     NOTREACHED();
     return;
   }
 
   dom_ui_->GetProfile()->GetHostContentSettingsMap()->SetDefaultContentSetting(
       ContentSettingsTypeFromGroupName(group),
       ContentSettingFromString(setting));
 }
 
 void ContentSettingsHandler::SetAllowThirdPartyCookies(const Value* value) {
   std::wstring allow = ExtractStringValue(value);
 
   dom_ui_->GetProfile()->GetHostContentSettingsMap()->SetBlockThirdPartyCookies(
       allow == L"true");
 }
+
+// TODO(estade): generalize this function to work on all content settings types
+// rather than just images.
+void ContentSettingsHandler::RemoveExceptions(const Value* value) {
+  const ListValue* list_value = static_cast<const ListValue*>(value);
+
+  HostContentSettingsMap* settings_map =
+      dom_ui_->GetProfile()->GetHostContentSettingsMap();
+  for (size_t i = 0; i < list_value->GetSize(); ++i) {
+    std::string pattern;
+    bool rv = list_value->GetString(i, &pattern);
+    DCHECK(rv);
+    settings_map->SetContentSetting(HostContentSettingsMap::Pattern(pattern),
+                                    CONTENT_SETTINGS_TYPE_IMAGES,
+                                    CONTENT_SETTING_DEFAULT);
+  }
+}