Support for process-wide incidents in the safe browsing incident reporting service.

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>
@@ skipping 52 matching lines @@
   // The key for a specific instance of an incident.
   std::string key;
 
   // A hash digest representing a specific instance of an incident.
   uint32_t digest;
 };
 
 // The amount of time the service will wait to collate incidents.
 const int64 kDefaultUploadDelayMs = 1000 * 60;  // one minute
 
+// The amount of time between running delayed analysis callbacks.
+const int64 kDefaultCallbackMs = 1000 * 20;
+
 // Returns the number of incidents contained in |incident|. The result is
 // expected to be 1. Used in DCHECKs.
 size_t CountIncidents(const ClientIncidentReport_IncidentData& incident) {
   size_t result = 0;
   if (incident.has_tracked_preference())
     ++result;
   // Add detection for new incident types here.
   return result;
 }
 
@@ skipping 135 matching lines @@
       environment_collection_task_runner_(
           content::BrowserThread::GetBlockingPool()
               ->GetTaskRunnerWithShutdownBehavior(
                   base::SequencedWorkerPool::SKIP_ON_SHUTDOWN)),
       environment_collection_pending_(),
       collection_timeout_pending_(),
       upload_timer_(FROM_HERE,
                     base::TimeDelta::FromMilliseconds(kDefaultUploadDelayMs),
                     this,
                     &IncidentReportingService::OnCollectionTimeout),
+      delayed_analysis_callbacks_(
+          base::TimeDelta::FromMilliseconds(kDefaultCallbackMs),
+          content::BrowserThread::GetBlockingPool()),
       receiver_weak_ptr_factory_(this),
       weak_ptr_factory_(this) {
   notification_registrar_.Add(this,
                               chrome::NOTIFICATION_PROFILE_ADDED,
                               content::NotificationService::AllSources());
   notification_registrar_.Add(this,
                               chrome::NOTIFICATION_PROFILE_DESTROYED,
                               content::NotificationService::AllSources());
 }
 
@@ skipping 25 matching lines @@
 scoped_ptr<TrackedPreferenceValidationDelegate>
 IncidentReportingService::CreatePreferenceValidationDelegate(Profile* profile) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (profile->IsOffTheRecord())
     return scoped_ptr<TrackedPreferenceValidationDelegate>();
   return scoped_ptr<TrackedPreferenceValidationDelegate>(
       new PreferenceValidationDelegate(GetAddIncidentCallback(profile)));
 }
 
+void IncidentReportingService::RegisterDelayedAnalysisCallback(
+    const DelayedAnalysisCallback& callback) {
+  delayed_analysis_callbacks_.RegisterCallback(
+      base::Bind(callback, GetAddIncidentCallback(NULL)));
+
+  // Start running the callbacks if any profiles are participating in safe
+  // browsing.
+  if (FindEligibleProfile())
+    delayed_analysis_callbacks_.Start();
+}
+
 void IncidentReportingService::SetCollectEnvironmentHook(
     CollectEnvironmentDataFn collect_environment_data_hook,
     const scoped_refptr<base::TaskRunner>& task_runner) {
   if (collect_environment_data_hook) {
     collect_environment_data_fn_ = collect_environment_data_hook;
     environment_collection_task_runner_ = task_runner;
   } else {
     collect_environment_data_fn_ = &CollectEnvironmentData;
     environment_collection_task_runner_ =
         content::BrowserThread::GetBlockingPool()
             ->GetTaskRunnerWithShutdownBehavior(
                 base::SequencedWorkerPool::SKIP_ON_SHUTDOWN);
   }
 }
 
 void IncidentReportingService::OnProfileAdded(Profile* profile) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Track the addition of all profiles even when no report is being assembled
   // so that the service can determine whether or not it can evaluate a
   // profile's preferences at the time of incident addition.
   ProfileContext* context = GetOrCreateProfileContext(profile);
   context->added = true;
 
+  const bool safe_browsing_enabled =
+      profile->GetPrefs()->GetBoolean(prefs::kSafeBrowsingEnabled);
+
+  // Start processing delayed analysis callbacks if this new profile
+  // participates in safe browsing.
+  if (safe_browsing_enabled)
+    delayed_analysis_callbacks_.Start();
+
   // Nothing else to do if a report is not being assembled.
   if (!report_)
     return;
 
-  // Drop all incidents received prior to creation if the profile is not
-  // participating in safe browsing.
-  if (!context->incidents.empty() &&
-      !profile->GetPrefs()->GetBoolean(prefs::kSafeBrowsingEnabled)) {
-    for (size_t i = 0; i < context->incidents.size(); ++i) {
+  // Drop all incidents associated with this profile that were received prior to
+  // its addition if the profile is not participating in safe browsing.
+  if (!context->incidents.empty() && !safe_browsing_enabled) {
+    for (size_t i = 0; i < context->incidents.size(); ++i)
       LogIncidentDataType(DROPPED, *context->incidents[i]);
-    }
     context->incidents.clear();
   }
 
   // Take another stab at finding the most recent download if a report is being
   // assembled and one hasn't been found yet (the LastDownloadFinder operates
   // only on profiles that have been added to the ProfileManager).
   BeginDownloadCollection();
 }
 
 scoped_ptr<LastDownloadFinder> IncidentReportingService::CreateDownloadFinder(
@@ skipping 37 matching lines @@
   // 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 all pending uploads.
   for (size_t i = 0; i < uploads_.size(); ++i)
     uploads_[i]->profiles_to_state.erase(profile);
 }
 
+Profile* IncidentReportingService::FindEligibleProfile() const {
+  Profile* candidate = NULL;
+  for (ProfileContextCollection::const_iterator scan = profiles_.begin();
+       scan != profiles_.end();
+       ++scan) {
+    // Skip over profiles that have yet to be added to the profile manager.
+    // This will also skip over the NULL-profile context used to hold
+    // process-wide incidents.
+    if (!scan->second->added)
+      continue;
+    PrefService* prefs = scan->first->GetPrefs();
+    if (prefs->GetBoolean(prefs::kSafeBrowsingExtendedReportingEnabled)) {
+      candidate = scan->first;
+      break;
+    }
+    if (!candidate && prefs->GetBoolean(prefs::kSafeBrowsingEnabled))
+      candidate = scan->first;
+  }
+  return candidate;
+}
+
 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);
   DCHECK_EQ(1U, CountIncidents(*incident_data));
 
   ProfileContext* context = GetProfileContext(profile);
   // It is forbidden to call this function with a destroyed profile.
   DCHECK(context);
+  // If this is a process-wide incident, the context must not indicate that the
+  // profile (which is NULL) has been added to the profile manager.
+  DCHECK(profile || !context->added);
 
   // Drop the incident immediately if profile creation has completed and the
   // profile is not participating in safe browsing. Preference evaluation is
   // deferred until OnProfileAdded() if profile creation has not yet
   // completed.
   if (context->added &&
       !profile->GetPrefs()->GetBoolean(prefs::kSafeBrowsingEnabled)) {
     LogIncidentDataType(DROPPED, *incident_data);
     return;
   }
@@ skipping 97 matching lines @@
   report_.reset();
 }
 
 void IncidentReportingService::OnCollectionTimeout() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Exit early if collection was cancelled.
   if (!collection_timeout_pending_)
     return;
 
-  // Wait another round if incidents have come in from a profile that has yet to
-  // complete creation.
+  // Wait another round if profile-bound incidents have come in from a profile
+  // that has yet to complete creation.
   for (ProfileContextCollection::iterator scan = profiles_.begin();
        scan != profiles_.end();
        ++scan) {
-    if (!scan->second->added && !scan->second->incidents.empty()) {
+    if (scan->first &&
+        !scan->second->added &&
+        !scan->second->incidents.empty()) {
       upload_timer_.Reset();
       return;
     }
   }
 
   collection_timeout_pending_ = false;
 
   UploadIfCollectionComplete();
 }
 
@@ skipping 85 matching lines @@
   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);
+  // Find a profile suitable for tracking process-wide incidents.
+  Profile* analyses_profile = FindEligibleProfile();
+  process->set_extended_consent(
+      analyses_profile ? analyses_profile->GetPrefs()->GetBoolean(
+          prefs::kSafeBrowsingExtendedReportingEnabled) :
+      false);
+
+  // Associate process-wide incidents with the analyses profile.
+  ProfileContext* null_context = GetProfileContext(NULL);
+  if (null_context && analyses_profile) {
+    DCHECK(!null_context->incidents.empty());
+    ProfileContext* analyses_context = GetProfileContext(analyses_profile);
+    // Move the incidents to the target context.
+    analyses_context->incidents.insert(analyses_context->incidents.end(),
+                                       null_context->incidents.begin(),
+                                       null_context->incidents.end());
+    null_context->incidents.weak_clear();
+    // Delete the process-wide context.
+    delete null_context;
+    profiles_.erase(NULL);
+  }
+
   // Collect incidents across all profiles participating in safe browsing. Drop
   // incidents if the profile stopped participating before collection completed.
   // Prune previously submitted incidents.
   // Associate the profiles and their incident data with the upload.
   size_t prune_count = 0;
   UploadContext::PersistentIncidentStateCollection profiles_to_state;
   for (ProfileContextCollection::iterator scan = profiles_.begin();
        scan != profiles_.end();
        ++scan) {
+    // Bypass process-wide incidents that have not yet been associated with a
+    // profile.
+    if (!scan->first)
+      continue;
     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)) {
       for (size_t i = 0; i < context->incidents.size(); ++i) {
         LogIncidentDataType(DROPPED, *context->incidents[i]);
       }
       context->incidents.clear();
       continue;
     }
@@ skipping 162 matching lines @@
       if (!profile->IsOffTheRecord())
         OnProfileDestroyed(profile);
       break;
     }
     default:
       break;
   }
 }
 
 }  // namespace safe_browsing