Implement HostContentSettingsMap

This map stores whether a given host may load images or use plugins and javascript. And makes this information available to the render view

BUG=32782
TEST=none

Review URL: http://codereview.chromium.org/551149

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@37508 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 174 insertions, 0 deletions

diff --git a/chrome/browser/host_content_settings_map.cc b/chrome/browser/host_content_settings_map.cc
new file mode 100644
index 0000000..24c64bb
--- /dev/null
+++ b/chrome/browser/host_content_settings_map.cc
@@ -0,0 +1,174 @@
+// 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/host_content_settings_map.h"
+
+#include "base/utf_string_conversions.h"
+#include "chrome/browser/chrome_thread.h"
+#include "chrome/browser/profile.h"
+#include "chrome/common/pref_names.h"
+#include "chrome/common/pref_service.h"
+
+HostContentSettingsMap::HostContentSettingsMap(Profile* profile)
+    : profile_(profile) {
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
+
+  const DictionaryValue* host_content_dictionary =
+      profile_->GetPrefs()->GetDictionary(prefs::kPerHostContentSettings);
+  // Careful: The returned value could be NULL if the pref has never been set.
+  if (host_content_dictionary != NULL) {
+    for (DictionaryValue::key_iterator i(host_content_dictionary->begin_keys());
+         i != host_content_dictionary->end_keys(); ++i) {
+      std::wstring wide_host(*i);
+      int content_settings = 0;
+      bool success = host_content_dictionary->GetIntegerWithoutPathExpansion(
+          wide_host, &content_settings);
+      DCHECK(success);
+      host_content_settings_[WideToUTF8(wide_host)] =
+        ContentPermissions::FromInteger(content_settings);
+    }
+  }
+  default_content_settings_ = ContentPermissions::FromInteger(
+      profile_->GetPrefs()->GetInteger(prefs::kDefaultContentSettings));
+}
+
+// static
+void HostContentSettingsMap::RegisterUserPrefs(PrefService* prefs) {
+  prefs->RegisterDictionaryPref(prefs::kPerHostContentSettings);
+  prefs->RegisterIntegerPref(prefs::kDefaultContentSettings,
+                             ContentPermissions::ToInteger(
+                             ContentPermissions()));
+}
+
+void HostContentSettingsMap::ResetToDefaults() {
+  default_content_settings_ = ContentPermissions();
+  host_content_settings_.clear();
+  profile_->GetPrefs()->ClearPref(prefs::kDefaultContentSettings);
+  profile_->GetPrefs()->ClearPref(prefs::kPerHostContentSettings);
+}
+
+HostContentSettingsMap::HostContentPermissions
+    HostContentSettingsMap::GetAllPerHostContentPermissions(
+    ContentSettingsType content_type) const {
+  HostContentPermissions result;
+  for (HostContentSettings::const_iterator i(host_content_settings_.begin());
+       i != host_content_settings_.end(); ++i)
+    if (i->second.permissions[content_type] !=
+        CONTENT_PERMISSION_TYPE_DEFAULT)
+      result[i->first] = i->second.permissions[content_type];
+  return result;
+}
+
+ContentPermissions HostContentSettingsMap::GetPerHostContentSettings(
+    const std::string& host) const {
+  AutoLock auto_lock(lock_);
+  HostContentSettings::const_iterator i(host_content_settings_.find(host));
+  ContentPermissions result = default_content_settings_;
+  if (i != host_content_settings_.end()) {
+    for (int j = 0; j < CONTENT_SETTINGS_NUM_TYPES; ++j)
+      if (i->second.permissions[j] != CONTENT_PERMISSION_TYPE_DEFAULT)
+        result.permissions[j] = i->second.permissions[j];
+  }
+  return result;
+}
+
+bool HostContentSettingsMap::SetDefaultContentPermission(
+    ContentSettingsType type, ContentPermissionType permission) {
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
+
+  if (permission == CONTENT_PERMISSION_TYPE_DEFAULT)
+    return false;
+
+  {
+    AutoLock auto_lock(lock_);
+    default_content_settings_.permissions[type] = permission;
+  }
+
+  // Persist new content settings if we're not off the record.
+  if (!profile_->IsOffTheRecord()) {
+    profile_->GetPrefs()->SetInteger(prefs::kDefaultContentSettings,
+        ContentPermissions::ToInteger(default_content_settings_));
+  }
+  return true;
+}
+
+void HostContentSettingsMap::SetPerHostContentPermission(
+    const std::string& host, ContentSettingsType type,
+    ContentPermissionType permission) {
+
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
+  if (host.empty())
+    return;
+
+  bool erase_entry = true;
+  ContentPermissions permissions;
+
+  {
+    AutoLock auto_lock(lock_);
+    HostContentSettings::const_iterator i(host_content_settings_.find(host));
+    if (i == host_content_settings_.end()) {
+      for (int j = 0; j < CONTENT_SETTINGS_NUM_TYPES; ++j)
+        permissions.permissions[j] = CONTENT_PERMISSION_TYPE_DEFAULT;
+    } else {
+      permissions = i->second;
+    }
+    permissions.permissions[type] = permission;
+    for (int j = 0; j < CONTENT_SETTINGS_NUM_TYPES; ++j)
+      if (permissions.permissions[j] != CONTENT_PERMISSION_TYPE_DEFAULT)
+        erase_entry = false;
+    if (erase_entry)
+      host_content_settings_.erase(host);
+    else
+      host_content_settings_[host] = permissions;
+  }
+
+  // Persist new content settings if we're not off the record.
+  if (!profile_->IsOffTheRecord()) {
+    DictionaryValue* host_content_dictionary =
+        profile_->GetPrefs()->GetMutableDictionary(
+            prefs::kPerHostContentSettings);
+    std::wstring wide_host(UTF8ToWide(host));
+    if (erase_entry) {
+      host_content_dictionary->RemoveWithoutPathExpansion(wide_host, NULL);
+    } else {
+      host_content_dictionary->SetWithoutPathExpansion(wide_host,
+        Value::CreateIntegerValue(ContentPermissions::ToInteger(permissions)));
+    }
+  }
+}
+
+void HostContentSettingsMap::SetPerHostContentSettings(const std::string& host,
+    const ContentPermissions& permissions) {
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
+  if (host.empty())
+    return;
+
+  bool erase_entry = true;
+
+  for (int i = 0; i < CONTENT_SETTINGS_NUM_TYPES; ++i)
+    if (permissions.permissions[i] != CONTENT_PERMISSION_TYPE_DEFAULT)
+      erase_entry = false;
+
+  {
+    AutoLock auto_lock(lock_);
+    if (erase_entry)
+      host_content_settings_.erase(host);
+    else
+      host_content_settings_[host] = permissions;
+  }
+
+  // Persist new content settings if we're not off the record.
+  if (!profile_->IsOffTheRecord()) {
+    DictionaryValue* host_content_dictionary =
+        profile_->GetPrefs()->GetMutableDictionary(
+            prefs::kPerHostContentSettings);
+    std::wstring wide_host(UTF8ToWide(host));
+    if (erase_entry) {
+      host_content_dictionary->RemoveWithoutPathExpansion(wide_host, NULL);
+    } else {
+      host_content_dictionary->SetWithoutPathExpansion(wide_host,
+        Value::CreateIntegerValue(ContentPermissions::ToInteger(permissions)));
+    }
+  }
+}