Removing 'off the record' references. Contributed by vipul.bhasin@gmail.com

chrome/browser/content_settings/content_settings_pref_provider.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/content_settings/content_settings_pref_provider.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 59 matching lines @@
 };
 COMPILE_ASSERT(arraysize(kTypeNames) == CONTENT_SETTINGS_NUM_TYPES,
                type_names_incorrect_size);
 
 }  // namespace
 
 namespace content_settings {
 
 PrefDefaultProvider::PrefDefaultProvider(Profile* profile)
     : profile_(profile),
-      is_off_the_record_(profile_->IsOffTheRecord()),
+      is_incognito_(profile_->IsOffTheRecord()),
       updating_preferences_(false) {
   initializing_ = true;
   PrefService* prefs = profile->GetPrefs();
 
   MigrateObsoleteNotificationPref(prefs);
 
   // Read global defaults.
   DCHECK_EQ(arraysize(kTypeNames),
             static_cast<size_t>(CONTENT_SETTINGS_NUM_TYPES));
   ReadDefaultSettings(true);
@@ skipping 20 matching lines @@
     ContentSetting setting) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(kTypeNames[content_type] != NULL);  // Don't call this for Geolocation.
   DCHECK(content_type != CONTENT_SETTINGS_TYPE_PLUGINS ||
          setting != CONTENT_SETTING_ASK ||
          CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kEnableClickToPlay));
 
   // The default settings may not be directly modified for OTR sessions.
   // Instead, they are synced to the main profile's setting.
-  if (is_off_the_record_)
+  if (is_incognito_)
     return;
 
   PrefService* prefs = profile_->GetPrefs();
 
   DictionaryValue* default_settings_dictionary =
       prefs->GetMutableDictionary(prefs::kDefaultContentSettings);
   std::string dictionary_path(kTypeNames[content_type]);
   updating_preferences_ = true;
   {
     base::AutoLock lock(lock_);
@@ skipping 20 matching lines @@
     ContentSettingsType content_type) const {
   return false;
 }
 
 void PrefDefaultProvider::ResetToDefaults() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   base::AutoLock lock(lock_);
   default_content_settings_ = ContentSettings();
   ForceDefaultsToBeExplicit();
 
-  if (!is_off_the_record_) {
+  if (!is_incognito_) {
     PrefService* prefs = profile_->GetPrefs();
     updating_preferences_ = true;
     prefs->ClearPref(prefs::kDefaultContentSettings);
     updating_preferences_ = false;
   }
 }
 
 void PrefDefaultProvider::Observe(NotificationType type,
                                   const NotificationSource& source,
                                   const NotificationDetails& details) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (type == NotificationType::PREF_CHANGED) {
     DCHECK_EQ(profile_->GetPrefs(), Source<PrefService>(source).ptr());
     if (updating_preferences_)
       return;
 
     std::string* name = Details<std::string>(details).ptr();
     if (*name == prefs::kDefaultContentSettings) {
       ReadDefaultSettings(true);
     } else {
       NOTREACHED() << "Unexpected preference observed";
       return;
     }
 
-    if (!is_off_the_record_) {
+    if (!is_incognito_) {
       NotifyObservers(ContentSettingsDetails(
             ContentSettingsPattern(), CONTENT_SETTINGS_TYPE_DEFAULT, ""));
     }
   } else if (type == NotificationType::PROFILE_DESTROYED) {
     DCHECK_EQ(profile_, Source<Profile>(source).ptr());
     UnregisterObservers();
   } else {
     NOTREACHED() << "Unexpected notification";
   }
 }
@@ skipping 171 matching lines @@
 
   const ContentSettingsPattern pattern(
       requesting_pattern.CanonicalizePattern());
 
   bool early_exit = false;
   std::string pattern_str(pattern.AsString());
   PrefService* prefs = NULL;
   DictionaryValue* all_settings_dictionary = NULL;
 
   // Select content-settings-map to write to.
-  HostContentSettings* map_to_modify = off_the_record_settings();
-  if (!is_off_the_record()) {
+  HostContentSettings* map_to_modify = incognito_settings();
+  if (!is_incognito()) {
     prefs = profile_->GetPrefs();
     all_settings_dictionary =
         prefs->GetMutableDictionary(prefs::kContentSettingsPatterns);
 
     map_to_modify = host_content_settings();
   }
 
   // Update content-settings-map.
   {
     base::AutoLock auto_lock(lock());
@@ skipping 60 matching lines @@
         host_settings_dictionary->RemoveWithoutPathExpansion(dictionary_path,
                                                              NULL);
       } else {
         host_settings_dictionary->SetWithoutPathExpansion(
             dictionary_path, Value::CreateIntegerValue(setting));
       }
     }
   }
 
   updating_preferences_ = true;
-  if (!is_off_the_record())
+  if (!is_incognito())
     ScopedUserPrefUpdate update(prefs, prefs::kContentSettingsPatterns);
   updating_preferences_ = false;
 
   NotifyObservers(ContentSettingsDetails(pattern, content_type, ""));
 }
 
 void PrefProvider::ResetToDefaults() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   {
     base::AutoLock auto_lock(lock());
     host_content_settings()->clear();
-    off_the_record_settings()->clear();
+    incognito_settings()->clear();
   }
 
-  if (!is_off_the_record()) {
+  if (!is_incognito()) {
     PrefService* prefs = profile_->GetPrefs();
     updating_preferences_ = true;
     prefs->ClearPref(prefs::kContentSettingsPatterns);
     updating_preferences_ = false;
   }
 }
 
 void PrefProvider::ClearAllContentSettingsRules(
     ContentSettingsType content_type) {
   DCHECK(kTypeNames[content_type] != NULL);  // Don't call this for Geolocation.
 
   PrefService* prefs = NULL;
   DictionaryValue* all_settings_dictionary = NULL;
-  HostContentSettings* map_to_modify = off_the_record_settings();
+  HostContentSettings* map_to_modify = incognito_settings();
 
-  if (!is_off_the_record()) {
+  if (!is_incognito()) {
     prefs = profile_->GetPrefs();
     all_settings_dictionary =
         prefs->GetMutableDictionary(prefs::kContentSettingsPatterns);
     map_to_modify = host_content_settings();
   }
 
   {
     base::AutoLock auto_lock(lock());
     for (HostContentSettings::iterator i(map_to_modify->begin());
          i != map_to_modify->end(); ) {
@@ skipping 19 matching lines @@
               kTypeNames[content_type], NULL);
           ++i;
         }
       } else {
         ++i;
       }
     }
   }
 
   updating_preferences_ = true;
-  if (!is_off_the_record())
+  if (!is_incognito())
     ScopedUserPrefUpdate update(prefs, prefs::kContentSettingsPatterns);
   updating_preferences_ = false;
 
   NotifyObservers(
       ContentSettingsDetails(ContentSettingsPattern(), content_type, ""));
 }
 
 void PrefProvider::Observe(
     NotificationType type,
     const NotificationSource& source,
     const NotificationDetails& details) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (type == NotificationType::PREF_CHANGED) {
     DCHECK_EQ(profile_->GetPrefs(), Source<PrefService>(source).ptr());
     if (updating_preferences_)
       return;
 
     std::string* name = Details<std::string>(details).ptr();
     if (*name == prefs::kContentSettingsPatterns) {
       ReadExceptions(true);
     } else {
       NOTREACHED() << "Unexpected preference observed";
       return;
     }
 
-    if (!is_off_the_record()) {
+    if (!is_incognito()) {
       NotifyObservers(ContentSettingsDetails(ContentSettingsPattern(),
                                              CONTENT_SETTINGS_TYPE_DEFAULT,
                                              ""));
     }
   } else if (type == NotificationType::PROFILE_DESTROYED) {
     DCHECK_EQ(profile_, Source<Profile>(source).ptr());
     UnregisterObservers();
   } else {
     NOTREACHED() << "Unexpected notification";
   }
@@ skipping 14 matching lines @@
       prefs->GetDictionary(prefs::kContentSettingsPatterns);
 
   if (overwrite)
     host_content_settings()->clear();
 
   // Careful: The returned value could be NULL if the pref has never been set.
   if (all_settings_dictionary != NULL) {
     DictionaryValue* mutable_settings;
     scoped_ptr<DictionaryValue> mutable_settings_scope;
 
-    if (!is_off_the_record()) {
+    if (!is_incognito()) {
       mutable_settings =
           prefs->GetMutableDictionary(prefs::kContentSettingsPatterns);
     } else {
       // Create copy as we do not want to persist anything in OTR prefs.
       mutable_settings = all_settings_dictionary->DeepCopy();
       mutable_settings_scope.reset(mutable_settings);
     }
 
     // Convert all Unicode patterns into punycode form, then read.
     CanonicalizeContentSettingsExceptions(mutable_settings);
@@ skipping 190 matching lines @@
                         ContentSettingsPattern(host),
                         CONTENT_SETTINGS_TYPE_POPUPS,
                         "",
                         CONTENT_SETTING_ALLOW);
     }
     prefs->ClearPref(prefs::kPopupWhitelistedHosts);
   }
 }
 
 }  // namespace content_settings