[Do not commit] Track revocations in content_settings::Observer

components/content_settings/core/browser/content_settings_pref.cc

 // Copyright 2015 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 "components/content_settings/core/browser/content_settings_pref.h"
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram_macros.h"
@@ skipping 89 matching lines @@
   DCHECK(!in_value || IsValueAllowedForType(in_value, content_type_));
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(prefs_);
   DCHECK(primary_pattern != ContentSettingsPattern::Wildcard() ||
          secondary_pattern != ContentSettingsPattern::Wildcard() ||
          !resource_identifier.empty());
 
   // At this point take the ownership of the |in_value|.
   scoped_ptr<base::Value> value(in_value);
 
+  ContentSetting previous_value = CONTENT_SETTING_DEFAULT;
+
   // Update in memory value map.
   OriginIdentifierValueMap* map_to_modify = &incognito_value_map_;
   if (!is_incognito_)
     map_to_modify = &value_map_;
 
   {
     base::AutoLock auto_lock(lock_);
     if (value.get()) {
       map_to_modify->SetValue(
           primary_pattern,
           secondary_pattern,
           content_type_,
           resource_identifier,
           value->DeepCopy());
     } else {
       map_to_modify->DeleteValue(
           primary_pattern,
           secondary_pattern,
           content_type_,
           resource_identifier);
     }
   }
   // Update the content settings preference.
   if (!is_incognito_) {
-    UpdatePref(primary_pattern,
-               secondary_pattern,
-               resource_identifier,
-               value.get());
+    previous_value = UpdatePref(primary_pattern,
+                                secondary_pattern,
+                                resource_identifier,
+                                value.get());
   }
 
-  notify_callback_.Run(
-      primary_pattern, secondary_pattern, content_type_, resource_identifier);
+  notify_callback_.Run(primary_pattern, secondary_pattern, content_type_,
+                       previous_value, resource_identifier);
 
   return true;
 }
 
 void ContentSettingsPref::ClearPref() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(prefs_);
 
   {
     base::AutoLock auto_lock(lock_);
@@ skipping 15 matching lines @@
   if (is_incognito_) {
     base::AutoLock auto_lock(lock_);
     incognito_value_map_.clear();
   } else {
     ClearPref();
   }
 
   notify_callback_.Run(ContentSettingsPattern(),
                        ContentSettingsPattern(),
                        content_type_,
+                       CONTENT_SETTING_DEFAULT,
                        ResourceIdentifier());
 }
 
 void ContentSettingsPref::UpdateLastUsage(
     const ContentSettingsPattern& primary_pattern,
     const ContentSettingsPattern& secondary_pattern,
     base::Clock* clock) {
   // Don't write if in incognito.
   if (is_incognito_) {
     return;
@@ skipping 182 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (updating_preferences_)
     return;
 
   ReadContentSettingsFromPref();
 
   notify_callback_.Run(ContentSettingsPattern(),
                        ContentSettingsPattern(),
                        content_type_,
+                       CONTENT_SETTING_DEFAULT,
                        ResourceIdentifier());
 }
 
-void ContentSettingsPref::UpdatePref(
+ContentSetting ContentSettingsPref::UpdatePref(
     const ContentSettingsPattern& primary_pattern,
     const ContentSettingsPattern& secondary_pattern,
     const ResourceIdentifier& resource_identifier,
     const base::Value* value) {
   // Ensure that |lock_| is not held by this thread, since this function will
   // send out notifications (by |~DictionaryPrefUpdate|).
   AssertLockNotHeld();
 
+  ContentSetting old_content_setting = CONTENT_SETTING_DEFAULT;
+
   base::AutoReset<bool> auto_reset(&updating_preferences_, true);
   {
     DictionaryPrefUpdate update(prefs_, pref_name_);
     base::DictionaryValue* pattern_pairs_settings = update.Get();
 
     // Get settings dictionary for the given patterns.
     std::string pattern_str(CreatePatternString(primary_pattern,
                                                 secondary_pattern));
     base::DictionaryValue* settings_dictionary = NULL;
     bool found = pattern_pairs_settings->GetDictionaryWithoutPathExpansion(
         pattern_str, &settings_dictionary);
 
     if (!found && value) {
       settings_dictionary = new base::DictionaryValue;
       pattern_pairs_settings->SetWithoutPathExpansion(
           pattern_str, settings_dictionary);
     }
 
     if (settings_dictionary) {
+      int old_setting = CONTENT_SETTING_DEFAULT;
+      settings_dictionary->GetIntegerWithoutPathExpansion(kSettingPath,
+                                                          &old_setting);
+      old_content_setting = static_cast<ContentSetting>(old_setting);
+
       if (SupportsResourceIdentifiers(content_type_) &&
           !resource_identifier.empty()) {
         base::DictionaryValue* resource_dictionary = NULL;
         found = settings_dictionary->GetDictionary(
             kPerResourceIdentifierPrefName, &resource_dictionary);
         if (!found) {
           if (value == NULL)
-            return;  // Nothing to remove. Exit early.
+            return old_content_setting;  // Nothing to remove. Exit early.
           resource_dictionary = new base::DictionaryValue;
           settings_dictionary->Set(
               kPerResourceIdentifierPrefName, resource_dictionary);
         }
         // Update resource dictionary.
         if (value == NULL) {
           resource_dictionary->RemoveWithoutPathExpansion(resource_identifier,
                                                           NULL);
           if (resource_dictionary->empty()) {
             settings_dictionary->RemoveWithoutPathExpansion(
@@ skipping 13 matching lines @@
               kSettingPath, value->DeepCopy());
         }
       }
       // Remove the settings dictionary if it is empty.
       if (settings_dictionary->empty()) {
         pattern_pairs_settings->RemoveWithoutPathExpansion(
             pattern_str, NULL);
       }
     }
   }
+
+  return old_content_setting;
 }
 
 // static
 void ContentSettingsPref::CanonicalizeContentSettingsExceptions(
     base::DictionaryValue* all_settings_dictionary) {
   DCHECK(all_settings_dictionary);
 
   std::vector<std::string> remove_items;
   base::StringPairs move_items;
   for (base::DictionaryValue::Iterator i(*all_settings_dictionary);
@@ skipping 47 matching lines @@
 
 void ContentSettingsPref::AssertLockNotHeld() const {
 #if !defined(NDEBUG)
   // |Lock::Acquire()| will assert if the lock is held by this thread.
   lock_.Acquire();
   lock_.Release();
 #endif
 }
 
 }  // namespace content_settings