Write last_modified date to Content Settings in the PrefProvider

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 <memory>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/metrics/histogram_macros.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "components/content_settings/core/browser/content_settings_info.h"
 #include "components/content_settings/core/browser/content_settings_registry.h"
 #include "components/content_settings/core/browser/content_settings_rule.h"
 #include "components/content_settings/core/browser/content_settings_utils.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "components/content_settings/core/common/content_settings.h"
 #include "components/content_settings/core/common/content_settings_pattern.h"
 #include "components/content_settings/core/common/pref_names.h"
 #include "components/prefs/scoped_user_pref_update.h"
 #include "url/gurl.h"
 
 namespace {
 
 const char kSettingPath[] = "setting";
+const char kLastModifiedPath[] = "last_modified";
 const char kPerResourceIdentifierPrefName[] = "per_resource";
 
 // If the given content type supports resource identifiers in user preferences,
 // returns true and sets |pref_key| to the key in the content settings
 // dictionary under which per-resource content settings are stored.
 // Otherwise, returns false.
 bool SupportsResourceIdentifiers(ContentSettingsType content_type) {
   return content_type == CONTENT_SETTINGS_TYPE_PLUGINS;
 }
 
 bool IsValueAllowedForType(const base::Value* value, ContentSettingsType type) {
   const content_settings::ContentSettingsInfo* info =
       content_settings::ContentSettingsRegistry::GetInstance()->Get(type);
   if (info) {
     int setting;
     if (!value->GetAsInteger(&setting))
       return false;
     if (setting == CONTENT_SETTING_DEFAULT)
       return false;
     return info->IsSettingValid(IntToContentSetting(setting));
   }
 
   // TODO(raymes): We should permit different types of base::Value for
   // website settings.
   return value->GetType() == base::Value::Type::DICTIONARY;
 }
 
+// Extract a timestamp from |dictionary[kLastModifiedPath]|.
+// Will return base::Time() if no timestamp exists.
+base::Time GetTimeStamp(const base::DictionaryValue* dictionary) {
+  std::string timestamp_str;
+  dictionary->GetStringWithoutPathExpansion(kLastModifiedPath, &timestamp_str);
+  int64_t timestamp = 0;
+  base::StringToInt64(timestamp_str, &timestamp);
+  base::Time last_modified = base::Time::FromInternalValue(timestamp);
+  return last_modified;
+}
+
 }  // namespace
 
 namespace content_settings {
 
 ContentSettingsPref::ContentSettingsPref(
     ContentSettingsType content_type,
     PrefService* prefs,
     PrefChangeRegistrar* registrar,
     const std::string& pref_name,
     bool incognito,
+    bool store_last_modified,
     NotifyObserversCallback notify_callback)
     : content_type_(content_type),
       prefs_(prefs),
       registrar_(registrar),
       pref_name_(pref_name),
       is_incognito_(incognito),
+      store_last_modified_(store_last_modified),
       updating_preferences_(false),
       notify_callback_(notify_callback) {
   DCHECK(prefs_);
 
   ReadContentSettingsFromPref();
 
   registrar_->Add(
       pref_name_,
       base::Bind(&ContentSettingsPref::OnPrefChanged, base::Unretained(this)));
 }
@@ skipping 24 matching lines @@
          !resource_identifier.empty());
 
   // At this point take the ownership of the |in_value|.
   std::unique_ptr<base::Value> value(in_value);
 
   // Update in memory value map.
   OriginIdentifierValueMap* map_to_modify = &incognito_value_map_;
   if (!is_incognito_)
     map_to_modify = &value_map_;
 
+  base::Time modified_time =
+      store_last_modified_ ? base::Time::Now() : base::Time();
+
   {
     base::AutoLock auto_lock(lock_);
     if (value.get()) {
-      map_to_modify->SetValue(
-          primary_pattern,
-          secondary_pattern,
-          content_type_,
-          resource_identifier,
-          value->DeepCopy());
+      map_to_modify->SetValue(primary_pattern, secondary_pattern, content_type_,
+                              resource_identifier, modified_time,
+                              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());
+    UpdatePref(primary_pattern, secondary_pattern, resource_identifier,
+               modified_time, value.get());
   }
 
   notify_callback_.Run(
       primary_pattern, secondary_pattern, content_type_, resource_identifier);
 
   return true;
 }
 
+base::Time ContentSettingsPref::GetWebsiteSettingLastModified(
+    const ContentSettingsPattern& primary_pattern,
+    const ContentSettingsPattern& secondary_pattern,
+    const ResourceIdentifier& resource_identifier) {
+  OriginIdentifierValueMap* map_to_modify = &incognito_value_map_;
+  if (!is_incognito_)
+    map_to_modify = &value_map_;
+
+  base::Time last_modified = map_to_modify->GetLastModified(
+      primary_pattern, secondary_pattern, content_type_, resource_identifier);
+  return last_modified;
+}
+
 void ContentSettingsPref::ClearPref() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(prefs_);
 
   {
     base::AutoLock auto_lock(lock_);
     value_map_.clear();
   }
 
   {
@@ skipping 40 matching lines @@
   // notification.
   base::AutoReset<bool> auto_reset(&updating_preferences_, true);
   DictionaryPrefUpdate update(prefs_, pref_name_);
   base::AutoLock auto_lock(lock_);
 
   const base::DictionaryValue* all_settings_dictionary =
       prefs_->GetDictionary(pref_name_);
 
   value_map_.clear();
 
-  // Careful: The returned value could be NULL if the pref has never been set.
+  // Careful: The returned value could be nullptr if the pref has never been
+  // set.
   if (!all_settings_dictionary)
     return;
 
   base::DictionaryValue* mutable_settings;
   std::unique_ptr<base::DictionaryValue> mutable_settings_scope;
 
   if (!is_incognito_) {
     mutable_settings = update.Get();
   } else {
     // Create copy as we do not want to persist anything in incognito prefs.
@@ skipping 13 matching lines @@
         ParsePatternString(pattern_str);
     if (!pattern_pair.first.IsValid() ||
         !pattern_pair.second.IsValid()) {
       // TODO: Change this to DFATAL when crbug.com/132659 is fixed.
       LOG(ERROR) << "Invalid pattern strings: " << pattern_str;
       continue;
     }
 
     // Get settings dictionary for the current pattern string, and read
     // settings from the dictionary.
-    const base::DictionaryValue* settings_dictionary = NULL;
+    const base::DictionaryValue* settings_dictionary = nullptr;
     bool is_dictionary = i.value().GetAsDictionary(&settings_dictionary);
     DCHECK(is_dictionary);
 
     if (SupportsResourceIdentifiers(content_type_)) {
-      const base::DictionaryValue* resource_dictionary = NULL;
+      const base::DictionaryValue* resource_dictionary = nullptr;
       if (settings_dictionary->GetDictionary(
               kPerResourceIdentifierPrefName, &resource_dictionary)) {
+        base::Time last_modified = GetTimeStamp(settings_dictionary);
         for (base::DictionaryValue::Iterator j(*resource_dictionary);
              !j.IsAtEnd();
              j.Advance()) {
           const std::string& resource_identifier(j.key());
           int setting = CONTENT_SETTING_DEFAULT;
           bool is_integer = j.value().GetAsInteger(&setting);
           DCHECK(is_integer);
           DCHECK_NE(CONTENT_SETTING_DEFAULT, setting);
           std::unique_ptr<base::Value> setting_ptr(new base::Value(setting));
-          value_map_.SetValue(pattern_pair.first,
-                              pattern_pair.second,
-                              content_type_,
-                              resource_identifier,
+          // Per resource settings store a single timestamps for all resources.
+          value_map_.SetValue(pattern_pair.first, pattern_pair.second,
+                              content_type_, resource_identifier, last_modified,
                               setting_ptr->DeepCopy());
         }
       }
     }
 
     const base::Value* value = nullptr;
     settings_dictionary->GetWithoutPathExpansion(kSettingPath, &value);
-
     if (value) {
+      base::Time last_modified = GetTimeStamp(settings_dictionary);
       DCHECK(IsValueAllowedForType(value, content_type_));
-      value_map_.SetValue(pattern_pair.first,
-                          pattern_pair.second,
-                          content_type_,
-                          ResourceIdentifier(),
+      value_map_.SetValue(pattern_pair.first, pattern_pair.second,
+                          content_type_, ResourceIdentifier(), last_modified,
                           value->DeepCopy());
       if (content_type_ == CONTENT_SETTINGS_TYPE_COOKIES) {
         ContentSetting s = ValueToContentSetting(value);
         switch (s) {
           case CONTENT_SETTING_ALLOW :
             ++cookies_allow_exception_count;
             break;
           case CONTENT_SETTING_BLOCK :
             ++cookies_block_exception_count;
             break;
@@ skipping 30 matching lines @@
   notify_callback_.Run(ContentSettingsPattern(),
                        ContentSettingsPattern(),
                        content_type_,
                        ResourceIdentifier());
 }
 
 void ContentSettingsPref::UpdatePref(
     const ContentSettingsPattern& primary_pattern,
     const ContentSettingsPattern& secondary_pattern,
     const ResourceIdentifier& resource_identifier,
+    const base::Time last_modified,
     const base::Value* value) {
   // Ensure that |lock_| is not held by this thread, since this function will
   // send out notifications (by |~DictionaryPrefUpdate|).
   AssertLockNotHeld();
 
   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;
+    base::DictionaryValue* settings_dictionary = nullptr;
     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) {
       if (SupportsResourceIdentifiers(content_type_) &&
           !resource_identifier.empty()) {
-        base::DictionaryValue* resource_dictionary = NULL;
+        base::DictionaryValue* resource_dictionary = nullptr;
         found = settings_dictionary->GetDictionary(
             kPerResourceIdentifierPrefName, &resource_dictionary);
         if (!found) {
-          if (value == NULL)
+          if (value == nullptr)
             return;  // Nothing to remove. Exit early.
           resource_dictionary = new base::DictionaryValue;
           settings_dictionary->Set(
               kPerResourceIdentifierPrefName, resource_dictionary);
         }
         // Update resource dictionary.
-        if (value == NULL) {
+        if (value == nullptr) {
           resource_dictionary->RemoveWithoutPathExpansion(resource_identifier,
-                                                          NULL);
+                                                          nullptr);
           if (resource_dictionary->empty()) {
             settings_dictionary->RemoveWithoutPathExpansion(
-                kPerResourceIdentifierPrefName, NULL);
+                kPerResourceIdentifierPrefName, nullptr);
+            settings_dictionary->RemoveWithoutPathExpansion(kLastModifiedPath,
+                                                            nullptr);
           }
         } else {
           resource_dictionary->SetWithoutPathExpansion(
               resource_identifier, value->DeepCopy());
+          // Update timestamp for whole resource dictionary.
+          settings_dictionary->SetStringWithoutPathExpansion(
+              kLastModifiedPath,
+              base::Int64ToString(last_modified.ToInternalValue()));
         }
       } else {
         // Update settings dictionary.
-        if (value == NULL) {
-          settings_dictionary->RemoveWithoutPathExpansion(kSettingPath, NULL);
+        if (value == nullptr) {
+          settings_dictionary->RemoveWithoutPathExpansion(kSettingPath,
+                                                          nullptr);
+          settings_dictionary->RemoveWithoutPathExpansion(kLastModifiedPath,
+                                                          nullptr);
         } else {
           settings_dictionary->SetWithoutPathExpansion(
               kSettingPath, value->DeepCopy());
+          settings_dictionary->SetStringWithoutPathExpansion(
+              kLastModifiedPath,
+              base::Int64ToString(last_modified.ToInternalValue()));
         }
       }
       // Remove the settings dictionary if it is empty.
       if (settings_dictionary->empty()) {
-        pattern_pairs_settings->RemoveWithoutPathExpansion(
-            pattern_str, NULL);
+        pattern_pairs_settings->RemoveWithoutPathExpansion(pattern_str,
+                                                           nullptr);
       }
     }
   }
 }
 
 // static
 void ContentSettingsPref::CanonicalizeContentSettingsExceptions(
     base::DictionaryValue* all_settings_dictionary) {
   DCHECK(all_settings_dictionary);
 
@@ skipping 13 matching lines @@
 
     const std::string canonicalized_pattern_str = CreatePatternString(
         pattern_pair.first, pattern_pair.second);
 
     if (canonicalized_pattern_str.empty() ||
         canonicalized_pattern_str == pattern_str) {
       continue;
     }
 
     // Clear old pattern if prefs already have canonicalized pattern.
-    const base::DictionaryValue* new_pattern_settings_dictionary = NULL;
+    const base::DictionaryValue* new_pattern_settings_dictionary = nullptr;
     if (all_settings_dictionary->GetDictionaryWithoutPathExpansion(
             canonicalized_pattern_str, &new_pattern_settings_dictionary)) {
       remove_items.push_back(pattern_str);
       continue;
     }
 
     // Move old pattern to canonicalized pattern.
-    const base::DictionaryValue* old_pattern_settings_dictionary = NULL;
+    const base::DictionaryValue* old_pattern_settings_dictionary = nullptr;
     if (i.value().GetAsDictionary(&old_pattern_settings_dictionary)) {
       move_items.push_back(
           std::make_pair(pattern_str, canonicalized_pattern_str));
     }
   }
 
   for (size_t i = 0; i < remove_items.size(); ++i) {
-    all_settings_dictionary->RemoveWithoutPathExpansion(remove_items[i], NULL);
+    all_settings_dictionary->RemoveWithoutPathExpansion(remove_items[i],
+                                                        nullptr);
   }
 
   for (size_t i = 0; i < move_items.size(); ++i) {
     std::unique_ptr<base::Value> pattern_settings_dictionary;
     all_settings_dictionary->RemoveWithoutPathExpansion(
         move_items[i].first, &pattern_settings_dictionary);
     all_settings_dictionary->SetWithoutPathExpansion(
         move_items[i].second, pattern_settings_dictionary.release());
   }
 }
 
 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