Add enableReferrers and enableHyperlinkAuditing to contentSettings.misc API.

chrome/browser/prefs/pref_member.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/prefs/pref_member.h"
 
 #include "base/logging.h"
 #include "base/value_conversions.h"
 #include "chrome/browser/prefs/pref_service.h"
+#include "content/common/notification_source.h"
 #include "content/common/notification_type.h"
 
 namespace subtle {
 
 PrefMemberBase::PrefMemberBase()
     : observer_(NULL),
       prefs_(NULL),
       setting_value_(false) {
 }
 
 PrefMemberBase::~PrefMemberBase() {
-  if (prefs_ && !pref_name_.empty())
-    prefs_->RemovePrefObserver(pref_name_.c_str(), this);
+  Destroy();
 }
 
 
 void PrefMemberBase::Init(const char* pref_name, PrefService* prefs,
                           NotificationObserver* observer) {
   DCHECK(pref_name);
   DCHECK(prefs);
   DCHECK(pref_name_.empty());  // Check that Init is only called once.
   observer_ = observer;
   prefs_ = prefs;
   pref_name_ = pref_name;
   DCHECK(!pref_name_.empty());
 
   // Add ourselves as a pref observer so we can keep our local value in sync.
   prefs_->AddPrefObserver(pref_name, this);
 }
 
+void PrefMemberBase::ObserveProfileDestruction(Profile* profile) {
+  DCHECK(registrar_.IsEmpty());
+  registrar_.Add(this,
+                 NotificationType::PROFILE_DESTROYED,
+                 Source<Profile>(profile));
+}
+
 void PrefMemberBase::Destroy() {
-  if (prefs_) {
+  if (prefs_ && !pref_name_.empty()) {
     prefs_->RemovePrefObserver(pref_name_.c_str(), this);
     prefs_ = NULL;
   }
 }
 
 void PrefMemberBase::MoveToThread(BrowserThread::ID thread_id) {
   VerifyValuePrefName();
   // Load the value from preferences if it hasn't been loaded so far.
   if (!internal())
     UpdateValueFromPref();
   internal()->MoveToThread(thread_id);
 }
 
 void PrefMemberBase::Observe(NotificationType type,
                              const NotificationSource& source,
                              const NotificationDetails& details) {
-  VerifyValuePrefName();
-  DCHECK(NotificationType::PREF_CHANGED == type);
-  UpdateValueFromPref();
-  if (!setting_value_ && observer_)
-    observer_->Observe(type, source, details);
+  switch (type.value) {
+    case NotificationType::PREF_CHANGED: {
+      VerifyValuePrefName();
+      UpdateValueFromPref();
+      if (!setting_value_ && observer_)
+        observer_->Observe(type, source, details);
+      break;
+    }
+    case NotificationType::PROFILE_DESTROYED: {
+      Destroy();
+      registrar_.RemoveAll();
+      break;
+    }

[Mattias Nissler (ping if slow), 2011/04/05 08:48:27]

No need for curlies (or make it consistent with the NOTREACHED below?)

[Bernhard Bauer, 2011/04/05 10:48:34]

Done.

+    default:
+      NOTREACHED();
+  }
 }
 
 void PrefMemberBase::VerifyValuePrefName() const {
   DCHECK(!pref_name_.empty());
 }
 
 void PrefMemberBase::UpdateValueFromPref() const {
   VerifyValuePrefName();
   const PrefService::Preference* pref =
       prefs_->FindPreference(pref_name_.c_str());
@@ skipping 82 matching lines @@
 void PrefMember<FilePath>::UpdatePref(const FilePath& value) {
   prefs()->SetFilePath(pref_name().c_str(), value);
 }
 
 template <>
 bool PrefMember<FilePath>::Internal::UpdateValueInternal(const Value& value)
     const {
   return base::GetValueAsFilePath(value, &value_);
 }