Clean up pref state in the wake of removing the omnibox watcher.

chrome/browser/safe_browsing/incident_reporting/incident_reporting_service.cc

 // Copyright 2014 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/incident_reporting_service.h"
 
 #include <math.h>
 
 #include <algorithm>
 #include <vector>
@@ skipping 114 matching lines @@
     if (!incidents_sent->GetDictionaryWithoutPathExpansion(data.type,
                                                            &type_dict)) {
       type_dict = new base::DictionaryValue();
       incidents_sent->SetWithoutPathExpansion(data.type, type_dict);
     }
     type_dict->SetStringWithoutPathExpansion(data.key,
                                              base::UintToString(data.digest));
   }
 }
 
+// Removes a profile's prune state for legacy incident types.
+void CleanLegacyPruneState(Profile* profile) {
+  static const IncidentType kLegacyTypes[] = {
+    // TODO(grt): remove in M44 (crbug.com/451173).
+    IncidentType::OMNIBOX_INTERACTION,
+  };
+
+  // Figure out if there are any values to remove before committing to making
+  // any changes since any use of DictionaryPrefUpdate will result in a full
+  // serialize-and-write operation on the preferences store.
+  const base::Value* value =
+      profile->GetPrefs()->GetUserPrefValue(prefs::kSafeBrowsingIncidentsSent);
+  const base::DictionaryValue* incidents_sent = NULL;
+  if (!value || !value->GetAsDictionary(&incidents_sent))
+    return;
+  std::vector<std::string> types_to_remove;
+  for (size_t i = 0; i < arraysize(kLegacyTypes); ++i) {
+    const std::string incident_type(
+        base::IntToString(static_cast<int32_t>(kLegacyTypes[i])));
+    const base::DictionaryValue* type_dict = NULL;
+    if (incidents_sent->GetDictionaryWithoutPathExpansion(incident_type,
+                                                          &type_dict)) {
+      types_to_remove.push_back(incident_type);
+    }
+  }
+  if (types_to_remove.empty())
+    return;
+
+  DictionaryPrefUpdate pref_update(profile->GetPrefs(),
+                                   prefs::kSafeBrowsingIncidentsSent);
+  for (const auto& incident_type : types_to_remove)
+    pref_update.Get()->RemoveWithoutPathExpansion(incident_type, NULL);
+}
+
 // Runs |callback| on the thread to which |thread_runner| belongs. The callback
 // is run immediately if this function is called on |thread_runner|'s thread.
 void AddIncidentOnOriginThread(
     const AddIncidentCallback& callback,
     scoped_refptr<base::SingleThreadTaskRunner> thread_runner,
     scoped_ptr<Incident> incident) {
   if (thread_runner->BelongsToCurrentThread())
     callback.Run(incident.Pass());
   else
     thread_runner->PostTask(FROM_HERE,
@@ skipping 226 matching lines @@
   if (safe_browsing_enabled)
     delayed_analysis_callbacks_.Start();
 
   // Start a new report if this profile participates in safe browsing and there
   // are process-wide incidents.
   if (safe_browsing_enabled && GetProfileContext(NULL) &&
       GetProfileContext(NULL)->incidents.size()) {
     BeginReportProcessing();
   }
 
+  CleanLegacyPruneState(profile);
+
   // TODO(grt): register for pref change notifications to start delayed analysis
   // and/or report processing if sb is currently disabled but subsequently
   // enabled.
 
   // Nothing else to do if a report is not being assembled.
   if (!report_)
     return;
 
   // Drop all incidents associated with this profile that were received prior to
   // its addition if the profile is not participating in safe browsing.
@@ skipping 531 matching lines @@
       if (!profile->IsOffTheRecord())
         OnProfileDestroyed(profile);
       break;
     }
     default:
       break;
   }
 }
 
 }  // namespace safe_browsing