Prune all safe browsing incidents when already reported.

chrome/browser/safe_browsing/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_service.h"
 
 #include <math.h>
 
+#include <algorithm>
+#include <vector>
+
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/process/process_info.h"
 #include "base/stl_util.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/prefs/tracked/tracked_preference_validation_delegate.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/safe_browsing/database_manager.h"
@@ skipping 21 matching lines @@
 enum IncidentDisposition {
   DROPPED,
   ACCEPTED,
 };
 
 const int64 kDefaultUploadDelayMs = 1000 * 60;  // one minute
 
 void LogIncidentDataType(
     IncidentDisposition disposition,
     const ClientIncidentReport_IncidentData& incident_data) {
-  static const char kAcceptedMetric[] = "SBIRS.Incident";
-  static const char kDroppedMetric[] = "SBIRS.DroppedIncident";
-
   IncidentType type = TRACKED_PREFERENCE;
 
   // Add a switch statement once other types are supported.
   DCHECK(incident_data.has_tracked_preference());
 
   if (disposition == ACCEPTED) {
-    UMA_HISTOGRAM_ENUMERATION(kAcceptedMetric, type, NUM_INCIDENT_TYPES);
+    UMA_HISTOGRAM_ENUMERATION("SBIRS.Incident", type, NUM_INCIDENT_TYPES);
   } else {
     DCHECK_EQ(disposition, DROPPED);
-    UMA_HISTOGRAM_ENUMERATION(kDroppedMetric, type, NUM_INCIDENT_TYPES);
+    UMA_HISTOGRAM_ENUMERATION("SBIRS.DroppedIncident", type,
+                              NUM_INCIDENT_TYPES);
   }
 }
 
 }  // namespace
 
 struct IncidentReportingService::ProfileContext {
   ProfileContext();
   ~ProfileContext();
 
   // The incidents collected for this profile pending creation and/or upload.
   ScopedVector<ClientIncidentReport_IncidentData> incidents;
 
   // False until PROFILE_CREATED notification is received.
   bool created;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ProfileContext);
 };
 
 class IncidentReportingService::UploadContext {
  public:
   explicit UploadContext(scoped_ptr<ClientIncidentReport> report);
   ~UploadContext();
 
+  // The report being uploaded.
   scoped_ptr<ClientIncidentReport> report;
+
+  // The uploader in use. This is NULL until the CSD killswitch is checked.
   scoped_ptr<IncidentReportUploader> uploader;
 
+  // The set of profiles from which incidents in |report| originated.
+  std::vector<Profile*> profiles;
+
  private:
   DISALLOW_COPY_AND_ASSIGN(UploadContext);
 };
 
 IncidentReportingService::ProfileContext::ProfileContext() : created() {
 }
 
 IncidentReportingService::ProfileContext::~ProfileContext() {
 }
 
@@ skipping 132 matching lines @@
   ProfileContextCollection::iterator it = profiles_.find(profile);
   if (it == profiles_.end())
     return;
 
   // TODO(grt): Persist incidents for upload on future profile load.
 
   // Forget about this profile. Incidents not yet sent for upload are lost.
   // No new incidents will be accepted for it.
   delete it->second;
   profiles_.erase(it);
+
+  // Remove the association with this profile from any pending uploads.
+  for (size_t i = 0; i < uploads_.size(); ++i) {
+    UploadContext* upload = uploads_[i];
+    std::vector<Profile*>::iterator it =
+        std::find(upload->profiles.begin(), upload->profiles.end(), profile);
+    if (it != upload->profiles.end()) {
+      *it = upload->profiles.back();
+      upload->profiles.resize(upload->profiles.size() - 1);
+      break;
+    }
+  }
 }
 
 void IncidentReportingService::AddIncident(
     Profile* profile,
     scoped_ptr<ClientIncidentReport_IncidentData> incident_data) {
   DCHECK(thread_checker_.CalledOnValidThread());
   // Incidents outside the context of a profile are not supported at the moment.
   DCHECK(profile);
 
   ProfileContext* context = GetProfileContext(profile);
@@ skipping 118 matching lines @@
 
   UploadIfCollectionComplete();
 }
 
 void IncidentReportingService::CollectDownloadDetails(
     ClientIncidentReport_DownloadDetails* download_details) {
   DCHECK(thread_checker_.CalledOnValidThread());
   // TODO(grt): collect download info; http://crbug.com/383042.
 }
 
-void IncidentReportingService::RecordReportedIncidents() {
-  // TODO(grt): store state about reported incidents.
-}
-
-void IncidentReportingService::PruneReportedIncidents(
-    ClientIncidentReport* report) {
-  // TODO(grt): remove previously reported incidents; http://crbug.com/383043.
-}
-
 void IncidentReportingService::UploadIfCollectionComplete() {
   DCHECK(report_);
   // Bail out if there are still outstanding collection tasks.
   if (environment_collection_pending_ || collection_timeout_pending_)
     return;
 
   // Take ownership of the report and clear things for future reports.
   scoped_ptr<ClientIncidentReport> report(report_.Pass());
   last_incident_time_ = base::TimeTicks();
 
   ClientIncidentReport_EnvironmentData_Process* process =
       report->mutable_environment()->mutable_process();
 
   // Not all platforms have a metrics reporting preference.
   if (g_browser_process->local_state()->FindPreference(
           prefs::kMetricsReportingEnabled)) {
     process->set_metrics_consent(g_browser_process->local_state()->GetBoolean(
         prefs::kMetricsReportingEnabled));
   }
+
   // Check for extended consent in any profile while collecting incidents.
   process->set_extended_consent(false);
   // Collect incidents across all profiles participating in safe browsing. Drop
   // incidents if the profile stopped participating before collection completed.
+  // Prune incidents if the profile has already submitted any incidents.
+  // Associate the participating profiles with the upload.
+  size_t prune_count = 0;
+  std::vector<Profile*> profiles;
   for (ProfileContextCollection::iterator scan = profiles_.begin();
        scan != profiles_.end();
        ++scan) {
     PrefService* prefs = scan->first->GetPrefs();
     if (process &&
         prefs->GetBoolean(prefs::kSafeBrowsingExtendedReportingEnabled)) {
       process->set_extended_consent(true);
       process = NULL;  // Don't check any more once one is found.
     }
     ProfileContext* context = scan->second;
     if (context->incidents.empty())
       continue;
-    if (prefs->GetBoolean(prefs::kSafeBrowsingEnabled)) {
+    if (!prefs->GetBoolean(prefs::kSafeBrowsingEnabled)) {
+      for (size_t i = 0; i < context->incidents.size(); ++i) {
+        LogIncidentDataType(DROPPED, *context->incidents[i]);
+      }
+      context->incidents.clear();
+    } else if (prefs->GetBoolean(prefs::kSafeBrowsingIncidentReportSent)) {
+      // Prune all incidents.
+      // TODO(grt): Only prune previously submitted incidents;
+      // http://crbug.com/383043.
+      prune_count += context->incidents.size();
+      context->incidents.clear();
+    } else {
       for (size_t i = 0; i < context->incidents.size(); ++i) {
         ClientIncidentReport_IncidentData* incident = context->incidents[i];
         LogIncidentDataType(ACCEPTED, *incident);
         // Ownership of the incident is passed to the report.
         report->mutable_incident()->AddAllocated(incident);
       }
       context->incidents.weak_clear();
-    } else {
-      for (size_t i = 0; i < context->incidents.size(); ++i) {
-        LogIncidentDataType(DROPPED, *context->incidents[i]);
-      }
-      context->incidents.clear();
+      profiles.push_back(scan->first);
     }
   }
 
-  const int original_count = report->incident_size();
-  // Abandon the request if all incidents were dropped.
-  if (!original_count)
+  const int count = report->incident_size();
+  // Abandon the request if all incidents were dropped with none pruned.
+  if (!count && !prune_count)
     return;
 
-  UMA_HISTOGRAM_COUNTS_100("SBIRS.IncidentCount", original_count);
+  UMA_HISTOGRAM_COUNTS_100("SBIRS.IncidentCount", count + prune_count);
 
-  PruneReportedIncidents(report.get());
-
-  int final_count = report->incident_size();
   {
-    double prune_pct = static_cast<double>(original_count - final_count);
-    prune_pct = prune_pct * 100.0 / original_count;
+    double prune_pct = static_cast<double>(prune_count);
+    prune_pct = prune_pct * 100.0 / (count + prune_count);
     prune_pct = round(prune_pct);
     UMA_HISTOGRAM_PERCENTAGE("SBIRS.PruneRatio", static_cast<int>(prune_pct));
   }
   // Abandon the report if all incidents were pruned.
-  if (!final_count)
+  if (!count)
     return;
 
   scoped_ptr<UploadContext> context(new UploadContext(report.Pass()));
+  context->profiles.swap(profiles);
   if (!database_manager_) {
     // No database manager during testing. Take ownership of the context and
     // continue processing.
     UploadContext* temp_context = context.get();
     uploads_.push_back(context.release());
     IncidentReportingService::OnKillSwitchResult(temp_context, false);
   } else {
     if (content::BrowserThread::PostTaskAndReplyWithResult(
             content::BrowserThread::IO,
             FROM_HERE,
@@ skipping 33 matching lines @@
                            IncidentReportUploader::UPLOAD_INVALID_REQUEST,
                            scoped_ptr<ClientIncidentResponse>());
     }
   } else {
     OnReportUploadResult(context,
                          IncidentReportUploader::UPLOAD_SUPPRESSED,
                          scoped_ptr<ClientIncidentResponse>());
   }
 }
 
-void IncidentReportingService::HandleResponse(
-    scoped_ptr<ClientIncidentReport> report,
-    scoped_ptr<ClientIncidentResponse> response) {
-  RecordReportedIncidents();
+void IncidentReportingService::HandleResponse(const UploadContext& context) {
+  for (size_t i = 0; i < context.profiles.size(); ++i) {
+    context.profiles[i]->GetPrefs()->SetBoolean(
+        prefs::kSafeBrowsingIncidentReportSent, true);
+  }
 }
 
 void IncidentReportingService::OnReportUploadResult(
     UploadContext* context,
     IncidentReportUploader::Result result,
     scoped_ptr<ClientIncidentResponse> response) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   UMA_HISTOGRAM_ENUMERATION(
       "SBIRS.UploadResult", result, IncidentReportUploader::NUM_UPLOAD_RESULTS);
 
   // The upload is no longer outstanding, so take ownership of the context (from
   // the collection of outstanding uploads) in this scope.
   ScopedVector<UploadContext>::iterator it(
       std::find(uploads_.begin(), uploads_.end(), context));
   DCHECK(it != uploads_.end());
   scoped_ptr<UploadContext> upload(context);  // == *it
   *it = uploads_.back();
   uploads_.weak_erase(uploads_.end() - 1);
 
   if (result == IncidentReportUploader::UPLOAD_SUCCESS)
-    HandleResponse(upload->report.Pass(), response.Pass());
+    HandleResponse(*upload);
   // else retry?
 }
 
 void IncidentReportingService::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   switch (type) {
     case chrome::NOTIFICATION_PROFILE_CREATED: {
       Profile* profile = content::Source<Profile>(source).ptr();
       if (!profile->IsOffTheRecord())
         OnProfileCreated(profile);
       break;
     }
     case chrome::NOTIFICATION_PROFILE_DESTROYED: {
       Profile* profile = content::Source<Profile>(source).ptr();
       if (!profile->IsOffTheRecord())
         OnProfileDestroyed(profile);
       break;
     }
     default:
       break;
   }
 }
 
 }  // namespace safe_browsing