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;
 }
 
@@ skipping 17 matching lines @@
 }  // 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;
 }
 
 void ContentSettingsPref::ClearPref() {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 86 matching lines @@
       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;
     bool is_dictionary = i.value().GetAsDictionary(&settings_dictionary);
     DCHECK(is_dictionary);
 
+    // Get last modified timestamp.

[msramek, 2017/04/19 10:49:16]

We're using one last modified timestamp per pattern pair, regardless of resource
identifiers. As discussed offline, I'm fine with that to avoid complexity, since
the only downside is that deletion of content settings would reset all plugins
on a page where you recently changed the setting for one of them.

...if that even works after all the Flash changes. I have a vague memory that
Raymes was about to remove those.

However, please comment on that :)

[dullweber, 2017/04/19 15:02:45]

I just changed it to store a timestamp per resource but if the whole
per-resource settings can be removed anyway that would be much better.

[raymes, 2017/04/20 00:10:13]

I think we'd like to remove the per-resource identifiers. I think they're not
really used by anything anymore. We just need to get around to doing it.

+    std::string time_stamp_str;
+    settings_dictionary->GetStringWithoutPathExpansion(kLastModifiedPath,
+                                                       &time_stamp_str);
+    int64_t time_stamp = 0;
+    base::StringToInt64(time_stamp_str, &time_stamp);
+    base::Time last_modified = base::Time::FromInternalValue(time_stamp);
+
     if (SupportsResourceIdentifiers(content_type_)) {
       const base::DictionaryValue* resource_dictionary = NULL;
       if (settings_dictionary->GetDictionary(
               kPerResourceIdentifierPrefName, &resource_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,
+          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) {
       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();
 
@@ skipping 23 matching lines @@
           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(
                 kPerResourceIdentifierPrefName, NULL);
+            settings_dictionary->RemoveWithoutPathExpansion(kLastModifiedPath,
+                                                            NULL);
           }
         } 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);
+          settings_dictionary->RemoveWithoutPathExpansion(kLastModifiedPath,
+                                                          NULL);
         } 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);
       }
     }
   }
 }
@@ skipping 56 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