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_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::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);
 }
 
-void PrefMemberBase::VerifyValuePrefName() const {
-  DCHECK(!pref_name_.empty());
-}
-
 void PrefMemberBase::UpdateValueFromPref() const {
   VerifyValuePrefName();
   const PrefService::Preference* pref =
       prefs_->FindPreference(pref_name_.c_str());
   DCHECK(pref);
   if (!internal())
     CreateInternal();
   internal()->UpdateValue(pref->GetValue()->DeepCopy(), pref->IsManaged());
 }
 
+void PrefMemberBase::VerifyPref() const {
+  VerifyValuePrefName();
+  if (!internal())
+    UpdateValueFromPref();
+}
+
 PrefMemberBase::Internal::Internal() : thread_id_(BrowserThread::UI) { }
 PrefMemberBase::Internal::~Internal() { }
 
 bool PrefMemberBase::Internal::IsOnCorrectThread() const {
   // In unit tests, there may not be a UI thread.
   return (BrowserThread::CurrentlyOn(thread_id_) ||
           (thread_id_ == BrowserThread::UI &&
            !BrowserThread::IsMessageLoopValid(BrowserThread::UI)));
 }
 
@@ skipping 66 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_);
 }