Add a global on/off switch for content settings and expose a toggle on the Website Settings options…

chrome/browser/content_settings/content_settings_override_provider.cc

Index: chrome/browser/content_settings/content_settings_override_provider.cc
diff --git a/chrome/browser/content_settings/content_settings_override_provider.cc b/chrome/browser/content_settings/content_settings_override_provider.cc
new file mode 100644
index 0000000000000000000000000000000000000000..dd61c010b9170546c109bb673be02721a143597f
--- /dev/null
+++ b/chrome/browser/content_settings/content_settings_override_provider.cc
@@ -0,0 +1,94 @@
+// Copyright (c) 2012 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/content_settings/content_settings_override_provider.h"
+
+#include <string>
+
+#include "base/auto_reset.h"
+#include "base/prefs/pref_service.h"
+#include "base/prefs/scoped_user_pref_update.h"
+#include "base/values.h"
+#include "chrome/browser/content_settings/content_settings_utils.h"
+#include "chrome/common/content_settings.h"
+#include "chrome/common/pref_names.h"
+#include "components/pref_registry/pref_registry_syncable.h"
+#include "content/public/browser/browser_thread.h"
+
+using content::BrowserThread;
+
+namespace content_settings {
+
+// static
+void OverrideProvider::RegisterProfilePrefs(
+    user_prefs::PrefRegistrySyncable* registry) {
+  base::DictionaryValue* override_content_settings =

[Bernhard Bauer, 2014/09/10 09:07:17]

Inline this?

Actually, there is a version of RegisterDictionaryPref that uses an empty
dictionary as default.

[Daniel Nishi, 2014/09/10 16:38:28]

Using the empty dictionary version.

+      new base::DictionaryValue();
+  registry->RegisterDictionaryPref(
+      prefs::kOverrideContentSettings,
+      override_content_settings,
+      user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
+}
+
+OverrideProvider::OverrideProvider(PrefService* prefs, bool incognito)
+    : prefs_(prefs), is_incognito_(incognito) {
+  DCHECK(prefs_);
+
+  // Read global overrides.
+  ReadOverrideSettings();
+}
+
+OverrideProvider::~OverrideProvider() {
+}
+
+void OverrideProvider::SetContentSetting(ContentSettingsType content_type,
+                                         bool is_enabled) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(prefs_);
+
+  if (is_incognito_)

[Bernhard Bauer, 2014/09/10 09:07:17]

So, in incognito, settings are silently immutable? That's a bit strange.

[Daniel Nishi, 2014/09/10 16:38:28]

The only way to modify it right now would be through the chrome://settings page,
which couldn't be run in incognito as far as I know. It seemed like adding in
the ability to change it in incognito would be better suited to a patch where it
was surfaced when that was possible.

[Bernhard Bauer, 2014/09/10 17:44:53]

Right... I think I'm okay with not having the ability to change these settings
in incognito, but then we shouldn't silently ignore changes, but rather DCHECK.

(If we were to have that ability, we would only remove the call to change the
pref dictionary if we're in incognito. That way you should get a non-persistent
copy of the regular settings).

[Daniel Nishi, 2014/09/10 23:30:20]

Done.

+    return;
+
+  DictionaryPrefUpdate update(prefs_, prefs::kOverrideContentSettings);
+  base::DictionaryValue* default_settings_dictionary = update.Get();
+  base::AutoLock lock(lock_);
+  override_settings_[content_type] = is_enabled;
+  default_settings_dictionary->SetWithoutPathExpansion(
+      GetTypeName(content_type), new base::FundamentalValue(is_enabled));
+}
+
+bool OverrideProvider::IsEnabled(ContentSettingsType content_type) const {

[Bernhard Bauer, 2014/09/10 09:07:17]

There is of course another way: You could make this an actual
ContentSettingProvider, and insert it just above regular user prefs. That would
also allow e.g. enterprise policies to override it (admittedly I can't see a
huge use case for forcing some content type *on*, but hey, if The Admin wants
that, The Admin gets that).

[Daniel Nishi, 2014/09/10 16:38:28]

Would taking this path with some special cases for handling provider->first ==
OVERRIDE_PROVIDER during provider iterations be preferable to it not being a
ContentSettingsProvider?

[Bernhard Bauer, 2014/09/10 17:44:53]

I think so... if there aren't too many special cases. Where would we need those?

Also, there's still the question of whether we want to override content setting
providers that are higher precedence than user settings (enterprise policies and
extensions). Specifically, for enterprise that could be problematic.

[Daniel Nishi, 2014/09/10 17:55:52]

It mainly comes from the distinction of trying to figure out a content setting
exception versus the effective content setting. If I'm trying to display what
the website's exception is, like in the Website Settings dialog, saying it is
blocked due to the global on/off would hide the information about the
user-defined exception.

[Bernhard Bauer, 2014/09/11 16:49:56]

Hm... I think in the content settings UI we get around that by getting a list of
all the content setting  rules, together with their source.

+  std::map<ContentSettingsType, bool>::const_iterator it =
+      override_settings_.find(content_type);
+  if (it == override_settings_.end())
+    return true;
+
+  return it->second;
+}
+
+void OverrideProvider::ReadOverrideSettings() {
+  base::AutoLock lock(lock_);

[Bernhard Bauer, 2014/09/10 09:07:17]

If this method is only called during construction, you don't need the lock.

[Daniel Nishi, 2014/09/10 16:38:28]

Done.

+  const base::DictionaryValue* override_settings_dictionary =
+      prefs_->GetDictionary(prefs::kOverrideContentSettings);
+
+  override_settings_.clear();
+
+  if (override_settings_dictionary) {
+    for (base::DictionaryValue::Iterator i(*override_settings_dictionary);
+         !i.IsAtEnd();
+         i.Advance()) {
+      const std::string& content_type(i.key());
+      for (size_t type = 0; type < CONTENT_SETTINGS_NUM_TYPES; ++type) {
+        if (content_type == GetTypeName(ContentSettingsType(type))) {
+          bool bool_value = true;
+          bool rv = i.value().GetAsBoolean(&bool_value);
+          DCHECK(rv);
+          override_settings_[ContentSettingsType(type)] = bool_value;
+          break;
+        }
+      }
+    }
+  }
+}
+}  // namespace content_settings