Allow default desktop content settings to be managed via policy

chrome/browser/geolocation/geolocation_content_settings_map.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.
 
 // Implementation of the geolocation content settings map. Styled on
 // HostContentSettingsMap however unlike that class, this one does not hold
 // an additional in-memory copy of the settings as it does not need to support
 // thread safe synchronous access to the settings; all geolocation permissions
 // are read and written in the UI thread. (If in future this is no longer the
 // case, refer to http://codereview.chromium.org/1525018 for a previous version
 // with caching. Note that as we must observe the prefs store for settings
 // changes, e.g. coming from the sync engine, the simplest design would be to
 // always write-through changes straight to the prefs store, and rely on the
 // notification observer to subsequently update any cached copy).
 
 #include "chrome/browser/geolocation/geolocation_content_settings_map.h"
 
 #include "base/string_piece.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browser_thread.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/prefs/scoped_pref_update.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/common/content_settings_types.h"

[jochen (gone - plz use gerrit), 2010/12/07 09:43:52]

why did you need this?

[markusheintz_, 2010/12/07 11:46:15]

removed

 #include "chrome/common/notification_service.h"
+#include "chrome/common/notification_source.h"
 #include "chrome/common/notification_type.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "net/base/dns_util.h"
 #include "net/base/static_cookie_policy.h"
 
 // static
 const ContentSetting
     GeolocationContentSettingsMap::kDefaultSetting = CONTENT_SETTING_ASK;
 
 GeolocationContentSettingsMap::GeolocationContentSettingsMap(Profile* profile)
     : profile_(profile) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  prefs_registrar_.Init(profile_->GetPrefs());
+  prefs_registrar_.Add(prefs::kGeolocationDefaultContentSetting, this);
+  prefs_registrar_.Add(prefs::kGeolocationContentSettings, this);
 }
 
 // static
 void GeolocationContentSettingsMap::RegisterUserPrefs(PrefService* prefs) {
   prefs->RegisterIntegerPref(prefs::kGeolocationDefaultContentSetting,
                              CONTENT_SETTING_ASK);
   prefs->RegisterDictionaryPref(prefs::kGeolocationContentSettings);
 }
 
 ContentSetting GeolocationContentSettingsMap::GetDefaultContentSetting() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   const PrefService* prefs = profile_->GetPrefs();
   const ContentSetting default_content_setting = IntToContentSetting(
       prefs->GetInteger(prefs::kGeolocationDefaultContentSetting));
   return default_content_setting == CONTENT_SETTING_DEFAULT ?
          kDefaultSetting : default_content_setting;
 }
 
+bool GeolocationContentSettingsMap::IsDefaultContentSettingManaged() const {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  return profile_->GetPrefs()->IsManagedPreference(

[jochen (gone - plz use gerrit), 2010/12/07 09:43:52]

you should also watch for PROFILE_DESTROYED

[markusheintz_, 2010/12/07 11:46:15]

Done.

+      prefs::kGeolocationDefaultContentSetting);
+}
+
 ContentSetting GeolocationContentSettingsMap::GetContentSetting(
     const GURL& requesting_url,
     const GURL& embedding_url) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(requesting_url.is_valid() && embedding_url.is_valid());
   GURL requesting_origin(requesting_url.GetOrigin());
   GURL embedding_origin(embedding_url.GetOrigin());
   DCHECK(requesting_origin.is_valid() && embedding_origin.is_valid());
 
   const DictionaryValue* all_settings_dictionary =
@@ skipping 94 matching lines @@
 }
 
 void GeolocationContentSettingsMap::ResetToDefault() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   PrefService* prefs = profile_->GetPrefs();
   prefs->ClearPref(prefs::kGeolocationDefaultContentSetting);
   prefs->ClearPref(prefs::kGeolocationContentSettings);
 }
 
+void GeolocationContentSettingsMap::NotifyObservers(
+    const ContentSettingsDetails& details) {
+  NotificationService::current()->Notify(
+      NotificationType::CONTENT_SETTINGS_CHANGED,
+      Source<GeolocationContentSettingsMap>(this),
+      Details<const ContentSettingsDetails>(&details));
+}
+
+void GeolocationContentSettingsMap::Observe(
+    NotificationType type,
+    const NotificationSource& source,
+    const NotificationDetails& details) {
+  if (NotificationType::PREF_CHANGED == type) {

[jochen (gone - plz use gerrit), 2010/12/07 09:43:52]

hum, why are you doing this here instead of sending the notification when
changing the setting? this looks as if it would interact badly with chrome sync

[markusheintz_, 2010/12/07 11:46:15]

Because I must listen for PREF_CHANGED events that are triggered through the
policy changes. When a managed value changes then a PREF_CHANGED notification is
sent. If I don't listen for them here I miss when policies get updated.

What's the problem her with sync?

+    const std::string& name = *Details<std::string>(details).ptr();
+    if (name == prefs::kGeolocationDefaultContentSetting) {
+      NotifyObservers(ContentSettingsDetails(
+      ContentSettingsPattern(),
+      CONTENT_SETTINGS_TYPE_DEFAULT,
+      ""));
+    }
+  } else {
+    NOTREACHED();
+  }
+}
+
 GeolocationContentSettingsMap::~GeolocationContentSettingsMap() {
 }
 
 // static
 void GeolocationContentSettingsMap::GetOneOriginSettingsFromDictionary(
     const DictionaryValue* dictionary,
     OneOriginSettings* one_origin_settings) {
   for (DictionaryValue::key_iterator i(dictionary->begin_keys());
        i != dictionary->end_keys(); ++i) {
     const std::string& target(*i);
     int setting = kDefaultSetting;
     bool found = dictionary->GetIntegerWithoutPathExpansion(target, &setting);
     DCHECK(found);
     GURL target_url(target);
     // An empty URL has a special meaning (wildcard), so only accept invalid
     // URLs if the original version was empty (avoids treating corrupted prefs
     // as the wildcard entry; see http://crbug.com/39685)
     if (target_url.is_valid() || target.empty())
       (*one_origin_settings)[target_url] = IntToContentSetting(setting);
   }
 }