Audit the last usage of Geolocation and Notification permissions.

chrome/browser/content_settings/content_settings_pref_provider.cc

 // Copyright (c) 2012 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 <map>
 #include <string>
 #include <utility>
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/scoped_user_pref_update.h"
+#include "base/time/clock.h"
+#include "base/time/default_clock.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/content_settings/content_settings_rule.h"
 #include "chrome/browser/content_settings/content_settings_utils.h"
 #include "chrome/browser/content_settings/host_content_settings_map.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/content_settings.h"
 #include "chrome/common/content_settings_pattern.h"
 #include "chrome/common/pref_names.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/user_metrics.h"
 #include "url/gurl.h"
 
 using base::UserMetricsAction;
 using content::BrowserThread;
 
 namespace {
 
 typedef std::pair<std::string, std::string> StringPair;
 typedef std::map<std::string, std::string> StringMap;
 
 const char kPerPluginPrefName[] = "per_plugin";
 const char kAudioKey[] = "audio";
 const char kVideoKey[] = "video";
+const char kLastUsed[] = "last_used";
 
 ContentSetting FixObsoleteCookiePromptMode(ContentSettingsType content_type,
                                            ContentSetting setting) {
   if (content_type == CONTENT_SETTINGS_TYPE_COOKIES &&
       setting == CONTENT_SETTING_ASK) {
     return CONTENT_SETTING_BLOCK;
   }
   return setting;
 }
 
@@ skipping 23 matching lines @@
     user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterIntegerPref(
       prefs::kContentSettingsVersion,
       ContentSettingsPattern::kContentSettingsPatternVersion,
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
   registry->RegisterDictionaryPref(
       prefs::kContentSettingsPatternPairs,
       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
 }
 
-PrefProvider::PrefProvider(PrefService* prefs,
-                           bool incognito)
-  : prefs_(prefs),
-    is_incognito_(incognito),
-    updating_preferences_(false) {
+PrefProvider::PrefProvider(PrefService* prefs, bool incognito)
+    : prefs_(prefs),
+      clock_(scoped_ptr<base::Clock>(new base::DefaultClock())),

[Bernhard Bauer, 2014/07/14 10:50:32]

The scoped_ptr<>() is unnecessary (a scoped_ptr can be initialized with a raw
pointer).

[Daniel Nishi, 2014/07/14 17:12:54]

Done.

+      is_incognito_(incognito),
+      updating_preferences_(false) {
   DCHECK(prefs_);
   // Verify preferences version.
   if (!prefs_->HasPrefPath(prefs::kContentSettingsVersion)) {
     prefs_->SetInteger(prefs::kContentSettingsVersion,
                       ContentSettingsPattern::kContentSettingsPatternVersion);
   }
   if (prefs_->GetInteger(prefs::kContentSettingsVersion) >
       ContentSettingsPattern::kContentSettingsPatternVersion) {
     return;
   }
@@ skipping 182 matching lines @@
         } else {
           resource_dictionary->SetWithoutPathExpansion(
               resource_identifier, value->DeepCopy());
         }
       } else {
         // Update settings dictionary.
         std::string setting_path = GetTypeName(content_type);
         if (value == NULL) {
           settings_dictionary->RemoveWithoutPathExpansion(setting_path,
                                                           NULL);
+          settings_dictionary->RemoveWithoutPathExpansion(kLastUsed, NULL);
         } else {
           settings_dictionary->SetWithoutPathExpansion(
               setting_path, value->DeepCopy());
         }
       }
       // Remove the settings dictionary if it is empty.
       if (settings_dictionary->empty()) {
         pattern_pairs_settings->RemoveWithoutPathExpansion(
             pattern_str, NULL);
       }
@@ skipping 256 matching lines @@
 }
 
 void PrefProvider::ShutdownOnUIThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(prefs_);
   RemoveAllObservers();
   pref_change_registrar_.RemoveAll();
   prefs_ = NULL;
 }
 
+void PrefProvider::UpdateLastUsage(
+    const ContentSettingsPattern& primary_pattern,
+    const ContentSettingsPattern& secondary_pattern,
+    ContentSettingsType content_type) {
+  // Don't write if in incognito.
+  if (is_incognito_) {
+    return;
+  }
+
+  // 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_, prefs::kContentSettingsPatternPairs);
+    base::DictionaryValue* pattern_pairs_settings = update.Get();
+
+    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) {
+      settings_dictionary = new base::DictionaryValue;
+      pattern_pairs_settings->SetWithoutPathExpansion(pattern_str,
+                                                      settings_dictionary);
+    }
+
+    base::DictionaryValue* last_used_dictionary = NULL;
+    found = settings_dictionary->GetDictionaryWithoutPathExpansion(
+        kLastUsed, &last_used_dictionary);
+
+    if (!found) {
+      last_used_dictionary = new base::DictionaryValue;
+      settings_dictionary->SetWithoutPathExpansion(kLastUsed,
+                                                   last_used_dictionary);
+    }
+
+    std::string settings_path = GetTypeName(content_type);
+    last_used_dictionary->Set(
+        settings_path, new base::FundamentalValue(clock_->Now().ToDoubleT()));
+  }
+}
+
+base::Time PrefProvider::GetLastUsage(
+    const ContentSettingsPattern& primary_pattern,
+    const ContentSettingsPattern& secondary_pattern,
+    ContentSettingsType content_type) {
+  const base::DictionaryValue* pattern_pairs_settings =
+      prefs_->GetDictionary(prefs::kContentSettingsPatternPairs);
+  std::string pattern_str(
+      CreatePatternString(primary_pattern, secondary_pattern));
+
+  const base::DictionaryValue* settings_dictionary = NULL;
+  bool found = pattern_pairs_settings->GetDictionaryWithoutPathExpansion(
+      pattern_str, &settings_dictionary);
+
+  if (!found)
+    return base::Time();
+
+  const base::DictionaryValue* last_used_dictionary = NULL;
+  found = settings_dictionary->GetDictionaryWithoutPathExpansion(
+      kLastUsed, &last_used_dictionary);
+
+  if (!found)
+    return base::Time();
+
+  double last_used_time;
+  found = last_used_dictionary->GetDoubleWithoutPathExpansion(
+      GetTypeName(content_type), &last_used_time);
+
+  if (!found)
+    return base::Time();
+
+  return base::Time::FromDoubleT(last_used_time);
+}
+
 void PrefProvider::AssertLockNotHeld() const {
 #if !defined(NDEBUG)
   // |Lock::Acquire()| will assert if the lock is held by this thread.
   lock_.Acquire();
   lock_.Release();
 #endif
 }
 
+void PrefProvider::SetClockForTesting(base::Clock* clock) {
+  clock_.reset(clock);
+}
+
 }  // namespace content_settings