Platform-specific prune state storage.

chrome/browser/safe_browsing/incident_reporting/state_store.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 "chrome/browser/safe_browsing/incident_reporting/state_store.h"
 
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/safe_browsing/incident_reporting/incident.h"
+#include "chrome/browser/safe_browsing/incident_reporting/platform_state_store.h"
 #include "chrome/common/pref_names.h"
 
 namespace safe_browsing {
 
 // StateStore::Transaction -----------------------------------------------------
 
 StateStore::Transaction::Transaction(StateStore* store) : store_(store) {
 #if DCHECK_IS_ON()
   DCHECK(!store_->has_transaction_);
   store_->has_transaction_ = true;
 #endif
 }
 
 StateStore::Transaction::~Transaction() {
 #if DCHECK_IS_ON()
   store_->has_transaction_ = false;
 #endif
+  if (pref_update_)
+    platform_state_store::Store(store_->profile_, store_->incidents_sent_);
 }
 
 void StateStore::Transaction::MarkAsReported(IncidentType type,
                                              const std::string& key,
                                              IncidentDigest digest) {
   std::string type_string(base::IntToString(static_cast<int32_t>(type)));
   base::DictionaryValue* incidents_sent = GetPrefDict();
   base::DictionaryValue* type_dict = nullptr;
   if (!incidents_sent->GetDictionaryWithoutPathExpansion(type_string,
                                                          &type_dict)) {
@@ skipping 13 matching lines @@
   // will result in a full serialize-and-write operation on the preferences
   // store.
   std::string type_string(base::IntToString(static_cast<int32_t>(type)));
   const base::DictionaryValue* type_dict = nullptr;
   if (store_->incidents_sent_->GetDictionaryWithoutPathExpansion(type_string,
                                                                  &type_dict)) {
     GetPrefDict()->RemoveWithoutPathExpansion(type_string, nullptr);
   }
 }
 
+void StateStore::Transaction::ClearAll() {
+  if (pref_update_)
+    pref_update_.reset();
+  if (store_->incidents_sent_) {
+    store_->incidents_sent_ = nullptr;
+    store_->profile_->GetPrefs()->ClearPref(prefs::kSafeBrowsingIncidentsSent);
+  }
+}
+
 base::DictionaryValue* StateStore::Transaction::GetPrefDict() {
   if (!pref_update_) {
     pref_update_.reset(new DictionaryPrefUpdate(
         store_->profile_->GetPrefs(), prefs::kSafeBrowsingIncidentsSent));
     // Getting the dict will cause it to be created if it doesn't exist.
     // Unconditionally refresh the store's read-only view on the preference so
     // that it will always be correct.
     store_->incidents_sent_ = pref_update_->Get();
   }
   return pref_update_->Get();
 }
 
+void StateStore::Transaction::ReplacePrefDict(
+    scoped_ptr<base::DictionaryValue> pref_dict) {
+  GetPrefDict()->Swap(pref_dict.get());
+}
+
 
 // StateStore ------------------------------------------------------------------
 
 StateStore::StateStore(Profile* profile)
     : profile_(profile),
       incidents_sent_(nullptr)
 #if DCHECK_IS_ON()
       ,
       has_transaction_(false)
 #endif
 {
   // Cache a read-only view of the preference.
   const base::Value* value =
       profile_->GetPrefs()->GetUserPrefValue(prefs::kSafeBrowsingIncidentsSent);
   if (value)
     value->GetAsDictionary(&incidents_sent_);
 
+  // Apply the platform data.
   Transaction transaction(this);
-  CleanLegacyValues(&transaction);
+  scoped_ptr<base::DictionaryValue> value_dict(
+      platform_state_store::Load(profile_));
+  if (value_dict) {
+    if (value_dict->empty())
+      transaction.ClearAll();
+    else if (!incidents_sent_ || !incidents_sent_->Equals(value_dict.get()))
+      transaction.ReplacePrefDict(value_dict.Pass());
+  }
+
+  if (incidents_sent_)
+    CleanLegacyValues(&transaction);
 }
 
 StateStore::~StateStore() {
 #if DCHECK_IS_ON()
   DCHECK(!has_transaction_);
 #endif
 }
 
 bool StateStore::HasBeenReported(IncidentType type,
                                  const std::string& key,
@@ skipping 11 matching lines @@
   static const IncidentType kLegacyTypes[] = {
       // TODO(grt): remove in M44 (crbug.com/451173).
       IncidentType::OMNIBOX_INTERACTION,
   };
 
   for (IncidentType type : kLegacyTypes)
     transaction->ClearForType(type);
 }
 
 }  // namespace safe_browsing