chrome/browser/content_settings/content_settings_pref_provider.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/content_settings/content_settings_pref_provider.h"
   6
   7 #include <map>
   8 #include <string>
   9 #include <utility>
  10
  11 #include "base/auto_reset.h"
  12 #include "base/command_line.h"
  13 #include "base/memory/scoped_ptr.h"
  14 #include "base/metrics/histogram.h"
  15 #include "base/prefs/pref_service.h"
  16 #include "base/prefs/scoped_user_pref_update.h"
  17 #include "base/strings/string_split.h"
  18 #include "base/time/clock.h"
  19 #include "base/time/default_clock.h"
  20 #include "chrome/browser/content_settings/content_settings_utils.h"
  21 #include "chrome/browser/content_settings/host_content_settings_map.h"
  22 #include "chrome/common/chrome_switches.h"
  23 #include "chrome/common/pref_names.h"
  24 #include "components/content_settings/core/browser/content_settings_rule.h"
  25 #include "components/content_settings/core/common/content_settings.h"
  26 #include "components/content_settings/core/common/content_settings_pattern.h"
  27 #include "components/pref_registry/pref_registry_syncable.h"
  28 #include "content/public/browser/browser_thread.h"
  29 #include "content/public/browser/user_metrics.h"
  30 #include "url/gurl.h"
  31
  32 using base::UserMetricsAction;
  33 using content::BrowserThread;
  34
  35 namespace {
  36
  37 typedef std::pair<std::string, std::string> StringPair;
  38 typedef std::map<std::string, std::string> StringMap;
  39
  40 const char kPerPluginPrefName[] = "per_plugin";
  41 const char kAudioKey[] = "audio";
  42 const char kVideoKey[] = "video";
  43 const char kLastUsed[] = "last_used";
  44
  45 ContentSetting FixObsoleteCookiePromptMode(ContentSettingsType content_type,
  46                                            ContentSetting setting) {
  47   if (content_type == CONTENT_SETTINGS_TYPE_COOKIES &&
  48       setting == CONTENT_SETTING_ASK) {
  49     return CONTENT_SETTING_BLOCK;
  50   }
  51   return setting;
  52 }
  53
  54 // If the given content type supports resource identifiers in user preferences,
  55 // returns true and sets |pref_key| to the key in the content settings
  56 // dictionary under which per-resource content settings are stored.
  57 // Otherwise, returns false.
  58 bool GetResourceTypeName(ContentSettingsType content_type,
  59                          std::string* pref_key) {
  60   if (content_type == CONTENT_SETTINGS_TYPE_PLUGINS) {
  61     *pref_key = kPerPluginPrefName;
  62     return true;
  63   }
  64   return false;
  65 }
  66
  67 }  // namespace
  68
  69 namespace content_settings {
  70
  71 // ////////////////////////////////////////////////////////////////////////////
  72 // PrefProvider:
  73 //
  74
  75 // static
  76 void PrefProvider::RegisterProfilePrefs(
  77     user_prefs::PrefRegistrySyncable* registry) {
  78   registry->RegisterIntegerPref(
  79       prefs::kContentSettingsVersion,
  80       ContentSettingsPattern::kContentSettingsPatternVersion,
  81       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
  82   registry->RegisterDictionaryPref(
  83       prefs::kContentSettingsPatternPairs,
  84       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
  85 }
  86
  87 PrefProvider::PrefProvider(PrefService* prefs, bool incognito)
  88     : prefs_(prefs),
  89       clock_(new base::DefaultClock()),
  90       is_incognito_(incognito),
  91       updating_preferences_(false) {
  92   DCHECK(prefs_);
  93   // Verify preferences version.
  94   if (!prefs_->HasPrefPath(prefs::kContentSettingsVersion)) {
  95     prefs_->SetInteger(prefs::kContentSettingsVersion,
  96                       ContentSettingsPattern::kContentSettingsPatternVersion);
  97   }
  98   if (prefs_->GetInteger(prefs::kContentSettingsVersion) >
  99       ContentSettingsPattern::kContentSettingsPatternVersion) {
 100     return;
 101   }
 102
 103   // Read content settings exceptions.
 104   ReadContentSettingsFromPref(false);
 105
 106   if (!is_incognito_) {
 107     UMA_HISTOGRAM_COUNTS("ContentSettings.NumberOfExceptions",
 108                          value_map_.size());
 109   }
 110
 111   // Migrate the obsolete media content setting exceptions to the new settings.
 112   // This needs to be done after ReadContentSettingsFromPref().
 113   if (!is_incognito_)
 114     MigrateObsoleteMediaContentSetting();
 115
 116   pref_change_registrar_.Init(prefs_);
 117   pref_change_registrar_.Add(
 118       prefs::kContentSettingsPatternPairs,
 119       base::Bind(&PrefProvider::OnContentSettingsPatternPairsChanged,
 120                  base::Unretained(this)));
 121 }
 122
 123 bool PrefProvider::SetWebsiteSetting(
 124     const ContentSettingsPattern& primary_pattern,
 125     const ContentSettingsPattern& secondary_pattern,
 126     ContentSettingsType content_type,
 127     const ResourceIdentifier& resource_identifier,
 128     base::Value* in_value) {
 129   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 130   DCHECK(prefs_);
 131   // Default settings are set using a wildcard pattern for both
 132   // |primary_pattern| and |secondary_pattern|. Don't store default settings in
 133   // the |PrefProvider|. The |PrefProvider| handles settings for specific
 134   // sites/origins defined by the |primary_pattern| and the |secondary_pattern|.
 135   // Default settings are handled by the |DefaultProvider|.
 136   if (primary_pattern == ContentSettingsPattern::Wildcard() &&
 137       secondary_pattern == ContentSettingsPattern::Wildcard() &&
 138       resource_identifier.empty()) {
 139     return false;
 140   }
 141
 142   // At this point take the ownership of the |in_value|.
 143   scoped_ptr<base::Value> value(in_value);
 144   // Update in memory value map.
 145   OriginIdentifierValueMap* map_to_modify = &incognito_value_map_;
 146   if (!is_incognito_)
 147     map_to_modify = &value_map_;
 148
 149   {
 150     base::AutoLock auto_lock(lock_);
 151     if (value.get()) {
 152       map_to_modify->SetValue(
 153           primary_pattern,
 154           secondary_pattern,
 155           content_type,
 156           resource_identifier,
 157           value->DeepCopy());
 158     } else {
 159       map_to_modify->DeleteValue(
 160           primary_pattern,
 161           secondary_pattern,
 162           content_type,
 163           resource_identifier);
 164     }
 165   }
 166   // Update the content settings preference.
 167   if (!is_incognito_) {
 168     UpdatePref(primary_pattern,
 169                secondary_pattern,
 170                content_type,
 171                resource_identifier,
 172                value.get());
 173   }
 174
 175   NotifyObservers(
 176       primary_pattern, secondary_pattern, content_type, resource_identifier);
 177
 178   return true;
 179 }
 180
 181 void PrefProvider::ClearAllContentSettingsRules(
 182     ContentSettingsType content_type) {
 183   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 184   DCHECK(prefs_);
 185
 186   OriginIdentifierValueMap* map_to_modify = &incognito_value_map_;
 187   if (!is_incognito_)
 188     map_to_modify = &value_map_;
 189
 190   std::vector<Rule> rules_to_delete;
 191   {
 192     base::AutoLock auto_lock(lock_);
 193     scoped_ptr<RuleIterator> rule_iterator(
 194         map_to_modify->GetRuleIterator(content_type, std::string(), NULL));
 195     // Copy the rules; we cannot call |UpdatePref| while holding |lock_|.
 196     while (rule_iterator->HasNext())
 197       rules_to_delete.push_back(rule_iterator->Next());
 198
 199     map_to_modify->DeleteValues(content_type, std::string());
 200   }
 201
 202   for (std::vector<Rule>::const_iterator it = rules_to_delete.begin();
 203        it != rules_to_delete.end(); ++it) {
 204     UpdatePref(it->primary_pattern,
 205                it->secondary_pattern,
 206                content_type,
 207                std::string(),
 208                NULL);
 209   }
 210   NotifyObservers(ContentSettingsPattern(),
 211                   ContentSettingsPattern(),
 212                   content_type,
 213                   std::string());
 214 }
 215
 216 PrefProvider::~PrefProvider() {
 217   DCHECK(!prefs_);
 218 }
 219
 220 RuleIterator* PrefProvider::GetRuleIterator(
 221     ContentSettingsType content_type,
 222     const ResourceIdentifier& resource_identifier,
 223     bool incognito) const {
 224   if (incognito)
 225     return incognito_value_map_.GetRuleIterator(content_type,
 226                                                 resource_identifier,
 227                                                 &lock_);
 228   return value_map_.GetRuleIterator(content_type, resource_identifier, &lock_);
 229 }
 230
 231 // ////////////////////////////////////////////////////////////////////////////
 232 // Private
 233
 234 void PrefProvider::UpdatePref(
 235     const ContentSettingsPattern& primary_pattern,
 236     const ContentSettingsPattern& secondary_pattern,
 237     ContentSettingsType content_type,
 238     const ResourceIdentifier& resource_identifier,
 239     const base::Value* value) {
 240   // Ensure that |lock_| is not held by this thread, since this function will
 241   // send out notifications (by |~DictionaryPrefUpdate|).
 242   AssertLockNotHeld();
 243
 244   base::AutoReset<bool> auto_reset(&updating_preferences_, true);
 245   {
 246     DictionaryPrefUpdate update(prefs_,
 247                                 prefs::kContentSettingsPatternPairs);
 248     base::DictionaryValue* pattern_pairs_settings = update.Get();
 249
 250     // Get settings dictionary for the given patterns.
 251     std::string pattern_str(CreatePatternString(primary_pattern,
 252                                                 secondary_pattern));
 253     base::DictionaryValue* settings_dictionary = NULL;
 254     bool found = pattern_pairs_settings->GetDictionaryWithoutPathExpansion(
 255         pattern_str, &settings_dictionary);
 256
 257     if (!found && value) {
 258       settings_dictionary = new base::DictionaryValue;
 259       pattern_pairs_settings->SetWithoutPathExpansion(
 260           pattern_str, settings_dictionary);
 261     }
 262
 263     if (settings_dictionary) {
 264       std::string res_dictionary_path;
 265       if (GetResourceTypeName(content_type, &res_dictionary_path) &&
 266           !resource_identifier.empty()) {
 267         base::DictionaryValue* resource_dictionary = NULL;
 268         found = settings_dictionary->GetDictionary(
 269             res_dictionary_path, &resource_dictionary);
 270         if (!found) {
 271           if (value == NULL)
 272             return;  // Nothing to remove. Exit early.
 273           resource_dictionary = new base::DictionaryValue;
 274           settings_dictionary->Set(res_dictionary_path, resource_dictionary);
 275         }
 276         // Update resource dictionary.
 277         if (value == NULL) {
 278           resource_dictionary->RemoveWithoutPathExpansion(resource_identifier,
 279                                                           NULL);
 280           if (resource_dictionary->empty()) {
 281             settings_dictionary->RemoveWithoutPathExpansion(
 282                 res_dictionary_path, NULL);
 283           }
 284         } else {
 285           resource_dictionary->SetWithoutPathExpansion(
 286               resource_identifier, value->DeepCopy());
 287         }
 288       } else {
 289         // Update settings dictionary.
 290         std::string setting_path = GetTypeName(content_type);
 291         if (value == NULL) {
 292           settings_dictionary->RemoveWithoutPathExpansion(setting_path,
 293                                                           NULL);
 294           settings_dictionary->RemoveWithoutPathExpansion(kLastUsed, NULL);
 295         } else {
 296           settings_dictionary->SetWithoutPathExpansion(
 297               setting_path, value->DeepCopy());
 298         }
 299       }
 300       // Remove the settings dictionary if it is empty.
 301       if (settings_dictionary->empty()) {
 302         pattern_pairs_settings->RemoveWithoutPathExpansion(
 303             pattern_str, NULL);
 304       }
 305     }
 306   }
 307 }
 308
 309
 310 void PrefProvider::MigrateObsoleteMediaContentSetting() {
 311   std::vector<Rule> rules_to_delete;
 312   {
 313     scoped_ptr<RuleIterator> rule_iterator(GetRuleIterator(
 314         CONTENT_SETTINGS_TYPE_MEDIASTREAM, std::string(), false));
 315     while (rule_iterator->HasNext()) {
 316       // Skip default setting and rules without a value.
 317       const content_settings::Rule& rule = rule_iterator->Next();
 318       DCHECK(rule.primary_pattern != ContentSettingsPattern::Wildcard());
 319       if (!rule.value.get())
 320         continue;
 321       rules_to_delete.push_back(rule);
 322     }
 323   }
 324
 325   for (std::vector<Rule>::const_iterator it = rules_to_delete.begin();
 326        it != rules_to_delete.end(); ++it) {
 327     const base::DictionaryValue* value_dict = NULL;
 328     if (!it->value->GetAsDictionary(&value_dict) || value_dict->empty())
 329       return;
 330
 331     std::string audio_device, video_device;
 332     value_dict->GetString(kAudioKey, &audio_device);
 333     value_dict->GetString(kVideoKey, &video_device);
 334     // Add the exception to the new microphone content setting.
 335     if (!audio_device.empty()) {
 336       SetWebsiteSetting(it->primary_pattern,
 337                         it->secondary_pattern,
 338                         CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC,
 339                         std::string(),
 340                         new base::FundamentalValue(CONTENT_SETTING_ALLOW));
 341     }
 342     // Add the exception to the new camera content setting.
 343     if (!video_device.empty()) {
 344       SetWebsiteSetting(it->primary_pattern,
 345                         it->secondary_pattern,
 346                         CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA,
 347                         std::string(),
 348                         new base::FundamentalValue(CONTENT_SETTING_ALLOW));
 349     }
 350
 351     // Remove the old exception in CONTENT_SETTINGS_TYPE_MEDIASTREAM.
 352     SetWebsiteSetting(it->primary_pattern,
 353                       it->secondary_pattern,
 354                       CONTENT_SETTINGS_TYPE_MEDIASTREAM,
 355                       std::string(),
 356                       NULL);
 357   }
 358 }
 359
 360 void PrefProvider::ReadContentSettingsFromPref(bool overwrite) {
 361   // |DictionaryPrefUpdate| sends out notifications when destructed. This
 362   // construction order ensures |AutoLock| gets destroyed first and |lock_| is
 363   // not held when the notifications are sent. Also, |auto_reset| must be still
 364   // valid when the notifications are sent, so that |Observe| skips the
 365   // notification.
 366   base::AutoReset<bool> auto_reset(&updating_preferences_, true);
 367   DictionaryPrefUpdate update(prefs_, prefs::kContentSettingsPatternPairs);
 368   base::AutoLock auto_lock(lock_);
 369
 370   const base::DictionaryValue* all_settings_dictionary =
 371       prefs_->GetDictionary(prefs::kContentSettingsPatternPairs);
 372
 373   if (overwrite)
 374     value_map_.clear();
 375
 376   // Careful: The returned value could be NULL if the pref has never been set.
 377   if (!all_settings_dictionary)
 378     return;
 379
 380   base::DictionaryValue* mutable_settings;
 381   scoped_ptr<base::DictionaryValue> mutable_settings_scope;
 382
 383   if (!is_incognito_) {
 384     mutable_settings = update.Get();
 385   } else {
 386     // Create copy as we do not want to persist anything in OTR prefs.
 387     mutable_settings = all_settings_dictionary->DeepCopy();
 388     mutable_settings_scope.reset(mutable_settings);
 389   }
 390   // Convert all Unicode patterns into punycode form, then read.
 391   CanonicalizeContentSettingsExceptions(mutable_settings);
 392
 393   size_t cookies_block_exception_count = 0;
 394   size_t cookies_allow_exception_count = 0;
 395   size_t cookies_session_only_exception_count = 0;
 396   for (base::DictionaryValue::Iterator i(*mutable_settings); !i.IsAtEnd();
 397        i.Advance()) {
 398     const std::string& pattern_str(i.key());
 399     std::pair<ContentSettingsPattern, ContentSettingsPattern> pattern_pair =
 400         ParsePatternString(pattern_str);
 401     if (!pattern_pair.first.IsValid() ||
 402         !pattern_pair.second.IsValid()) {
 403       // TODO: Change this to DFATAL when crbug.com/132659 is fixed.
 404       LOG(ERROR) << "Invalid pattern strings: " << pattern_str;
 405       continue;
 406     }
 407
 408     // Get settings dictionary for the current pattern string, and read
 409     // settings from the dictionary.
 410     const base::DictionaryValue* settings_dictionary = NULL;
 411     bool is_dictionary = i.value().GetAsDictionary(&settings_dictionary);
 412     DCHECK(is_dictionary);
 413
 414     for (size_t i = 0; i < CONTENT_SETTINGS_NUM_TYPES; ++i) {
 415       ContentSettingsType content_type = static_cast<ContentSettingsType>(i);
 416
 417       std::string res_dictionary_path;
 418       if (GetResourceTypeName(content_type, &res_dictionary_path)) {
 419         const base::DictionaryValue* resource_dictionary = NULL;
 420         if (settings_dictionary->GetDictionary(
 421                 res_dictionary_path, &resource_dictionary)) {
 422           for (base::DictionaryValue::Iterator j(*resource_dictionary);
 423                !j.IsAtEnd();
 424                j.Advance()) {
 425             const std::string& resource_identifier(j.key());
 426             int setting = CONTENT_SETTING_DEFAULT;
 427             bool is_integer = j.value().GetAsInteger(&setting);
 428             DCHECK(is_integer);
 429             DCHECK_NE(CONTENT_SETTING_DEFAULT, setting);
 430             value_map_.SetValue(pattern_pair.first,
 431                                 pattern_pair.second,
 432                                 content_type,
 433                                 resource_identifier,
 434                                 new base::FundamentalValue(setting));
 435           }
 436         }
 437       }
 438       base::Value* value = NULL;
 439       if (HostContentSettingsMap::ContentTypeHasCompoundValue(content_type)) {
 440         const base::DictionaryValue* setting = NULL;
 441         // TODO(xians): Handle the non-dictionary types.
 442         if (settings_dictionary->GetDictionaryWithoutPathExpansion(
 443             GetTypeName(ContentSettingsType(i)), &setting)) {
 444           DCHECK(!setting->empty());
 445           value = setting->DeepCopy();
 446         }
 447       } else {
 448         int setting = CONTENT_SETTING_DEFAULT;
 449         if (settings_dictionary->GetIntegerWithoutPathExpansion(
 450                 GetTypeName(ContentSettingsType(i)), &setting)) {
 451           DCHECK_NE(CONTENT_SETTING_DEFAULT, setting);
 452           setting = FixObsoleteCookiePromptMode(content_type,
 453                                                 ContentSetting(setting));
 454           value = new base::FundamentalValue(setting);
 455         }
 456       }
 457
 458       // |value_map_| will take the ownership of |value|.
 459       if (value != NULL) {
 460         value_map_.SetValue(pattern_pair.first,
 461                             pattern_pair.second,
 462                             content_type,
 463                             ResourceIdentifier(),
 464                             value);
 465         if (content_type == CONTENT_SETTINGS_TYPE_COOKIES) {
 466           ContentSetting s = ValueToContentSetting(value);
 467           switch (s) {
 468             case CONTENT_SETTING_ALLOW :
 469               ++cookies_allow_exception_count;
 470               break;
 471             case CONTENT_SETTING_BLOCK :
 472               ++cookies_block_exception_count;
 473               break;
 474             case CONTENT_SETTING_SESSION_ONLY :
 475               ++cookies_session_only_exception_count;
 476               break;
 477             default:
 478               NOTREACHED();
 479               break;
 480           }
 481         }
 482       }
 483     }
 484   }
 485   UMA_HISTOGRAM_COUNTS("ContentSettings.NumberOfBlockCookiesExceptions",
 486                        cookies_block_exception_count);
 487   UMA_HISTOGRAM_COUNTS("ContentSettings.NumberOfAllowCookiesExceptions",
 488                        cookies_allow_exception_count);
 489   UMA_HISTOGRAM_COUNTS("ContentSettings.NumberOfSessionOnlyCookiesExceptions",
 490                        cookies_session_only_exception_count);
 491 }
 492
 493 void PrefProvider::OnContentSettingsPatternPairsChanged() {
 494   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 495
 496   if (updating_preferences_)
 497     return;
 498
 499   ReadContentSettingsFromPref(true);
 500
 501   NotifyObservers(ContentSettingsPattern(),
 502                   ContentSettingsPattern(),
 503                   CONTENT_SETTINGS_TYPE_DEFAULT,
 504                   std::string());
 505 }
 506
 507 // static
 508 void PrefProvider::CanonicalizeContentSettingsExceptions(
 509     base::DictionaryValue* all_settings_dictionary) {
 510   DCHECK(all_settings_dictionary);
 511
 512   std::vector<std::string> remove_items;
 513   base::StringPairs move_items;
 514   for (base::DictionaryValue::Iterator i(*all_settings_dictionary);
 515        !i.IsAtEnd();
 516        i.Advance()) {
 517     const std::string& pattern_str(i.key());
 518     std::pair<ContentSettingsPattern, ContentSettingsPattern> pattern_pair =
 519          ParsePatternString(pattern_str);
 520     if (!pattern_pair.first.IsValid() ||
 521         !pattern_pair.second.IsValid()) {
 522       LOG(ERROR) << "Invalid pattern strings: " << pattern_str;
 523       continue;
 524     }
 525
 526     const std::string canonicalized_pattern_str = CreatePatternString(
 527         pattern_pair.first, pattern_pair.second);
 528
 529     if (canonicalized_pattern_str.empty() ||
 530         canonicalized_pattern_str == pattern_str) {
 531       continue;
 532     }
 533
 534     // Clear old pattern if prefs already have canonicalized pattern.
 535     const base::DictionaryValue* new_pattern_settings_dictionary = NULL;
 536     if (all_settings_dictionary->GetDictionaryWithoutPathExpansion(
 537             canonicalized_pattern_str, &new_pattern_settings_dictionary)) {
 538       remove_items.push_back(pattern_str);
 539       continue;
 540     }
 541
 542     // Move old pattern to canonicalized pattern.
 543     const base::DictionaryValue* old_pattern_settings_dictionary = NULL;
 544     if (i.value().GetAsDictionary(&old_pattern_settings_dictionary)) {
 545       move_items.push_back(
 546           std::make_pair(pattern_str, canonicalized_pattern_str));
 547     }
 548   }
 549
 550   for (size_t i = 0; i < remove_items.size(); ++i) {
 551     all_settings_dictionary->RemoveWithoutPathExpansion(remove_items[i], NULL);
 552   }
 553
 554   for (size_t i = 0; i < move_items.size(); ++i) {
 555     scoped_ptr<base::Value> pattern_settings_dictionary;
 556     all_settings_dictionary->RemoveWithoutPathExpansion(
 557         move_items[i].first, &pattern_settings_dictionary);
 558     all_settings_dictionary->SetWithoutPathExpansion(
 559         move_items[i].second, pattern_settings_dictionary.release());
 560   }
 561 }
 562
 563 void PrefProvider::ShutdownOnUIThread() {
 564   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 565   DCHECK(prefs_);
 566   RemoveAllObservers();
 567   pref_change_registrar_.RemoveAll();
 568   prefs_ = NULL;
 569 }
 570
 571 void PrefProvider::UpdateLastUsage(
 572     const ContentSettingsPattern& primary_pattern,
 573     const ContentSettingsPattern& secondary_pattern,
 574     ContentSettingsType content_type) {
 575   // Don't write if in incognito.
 576   if (is_incognito_) {
 577     return;
 578   }
 579
 580   // Ensure that |lock_| is not held by this thread, since this function will
 581   // send out notifications (by |~DictionaryPrefUpdate|).
 582   AssertLockNotHeld();
 583
 584   base::AutoReset<bool> auto_reset(&updating_preferences_, true);
 585   {
 586     DictionaryPrefUpdate update(prefs_, prefs::kContentSettingsPatternPairs);
 587     base::DictionaryValue* pattern_pairs_settings = update.Get();
 588
 589     std::string pattern_str(
 590         CreatePatternString(primary_pattern, secondary_pattern));
 591     base::DictionaryValue* settings_dictionary = NULL;
 592     bool found = pattern_pairs_settings->GetDictionaryWithoutPathExpansion(
 593         pattern_str, &settings_dictionary);
 594
 595     if (!found) {
 596       settings_dictionary = new base::DictionaryValue;
 597       pattern_pairs_settings->SetWithoutPathExpansion(pattern_str,
 598                                                       settings_dictionary);
 599     }
 600
 601     base::DictionaryValue* last_used_dictionary = NULL;
 602     found = settings_dictionary->GetDictionaryWithoutPathExpansion(
 603         kLastUsed, &last_used_dictionary);
 604
 605     if (!found) {
 606       last_used_dictionary = new base::DictionaryValue;
 607       settings_dictionary->SetWithoutPathExpansion(kLastUsed,
 608                                                    last_used_dictionary);
 609     }
 610
 611     std::string settings_path = GetTypeName(content_type);
 612     last_used_dictionary->Set(
 613         settings_path, new base::FundamentalValue(clock_->Now().ToDoubleT()));
 614   }
 615 }
 616
 617 base::Time PrefProvider::GetLastUsage(
 618     const ContentSettingsPattern& primary_pattern,
 619     const ContentSettingsPattern& secondary_pattern,
 620     ContentSettingsType content_type) {
 621   const base::DictionaryValue* pattern_pairs_settings =
 622       prefs_->GetDictionary(prefs::kContentSettingsPatternPairs);
 623   std::string pattern_str(
 624       CreatePatternString(primary_pattern, secondary_pattern));
 625
 626   const base::DictionaryValue* settings_dictionary = NULL;
 627   bool found = pattern_pairs_settings->GetDictionaryWithoutPathExpansion(
 628       pattern_str, &settings_dictionary);
 629
 630   if (!found)
 631     return base::Time();
 632
 633   const base::DictionaryValue* last_used_dictionary = NULL;
 634   found = settings_dictionary->GetDictionaryWithoutPathExpansion(
 635       kLastUsed, &last_used_dictionary);
 636
 637   if (!found)
 638     return base::Time();
 639
 640   double last_used_time;
 641   found = last_used_dictionary->GetDoubleWithoutPathExpansion(
 642       GetTypeName(content_type), &last_used_time);
 643
 644   if (!found)
 645     return base::Time();
 646
 647   return base::Time::FromDoubleT(last_used_time);
 648 }
 649
 650 void PrefProvider::AssertLockNotHeld() const {
 651 #if !defined(NDEBUG)
 652   // |Lock::Acquire()| will assert if the lock is held by this thread.
 653   lock_.Acquire();
 654   lock_.Release();
 655 #endif
 656 }
 657
 658 void PrefProvider::SetClockForTesting(scoped_ptr<base::Clock> clock) {
 659   clock_ = clock.Pass();
 660 }
 661
 662 }  // namespace content_settings