Take a Profile when adding an incident to the incident reporting service.

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 153 matching lines @@
                                    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,
+    Profile* profile,
     scoped_ptr<Incident> incident) {
-  if (thread_runner->BelongsToCurrentThread())
-    callback.Run(incident.Pass());
-  else
+  if (thread_runner->BelongsToCurrentThread()) {
+    callback.Run(profile, incident.Pass());
+  } else {
+    // It is unsafe to bounce the profile from another thread.
+    DCHECK(!profile);
     thread_runner->PostTask(FROM_HERE,
-                            base::Bind(callback, base::Passed(&incident)));
+                            base::Bind(callback, nullptr,
+                                       base::Passed(&incident)));
+  }
 }
 
 }  // namespace
 
 struct IncidentReportingService::ProfileContext {
   ProfileContext();
   ~ProfileContext();
 
   // The incidents collected for this profile pending creation and/or upload.
   // Will contain null values for pruned incidents.
@@ skipping 96 matching lines @@
   // Cancel all internal asynchronous tasks.
   weak_ptr_factory_.InvalidateWeakPtrs();
 
   CancelEnvironmentCollection();
   CancelDownloadCollection();
   CancelAllReportUploads();
 
   STLDeleteValues(&profiles_);
 }
 
-AddIncidentCallback IncidentReportingService::GetAddIncidentCallback(
-    Profile* profile) {
-  // Force the context to be created so that incidents added before
-  // OnProfileAdded is called are held until the profile's preferences can be
-  // queried.
-  ignore_result(GetOrCreateProfileContext(profile));
-
+AddIncidentCallback IncidentReportingService::GetAddIncidentCallback() {
   return base::Bind(&IncidentReportingService::AddIncident,
-                    receiver_weak_ptr_factory_.GetWeakPtr(),
-                    profile);
+                    receiver_weak_ptr_factory_.GetWeakPtr());
 }
 
 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)));
+      new PreferenceValidationDelegate(profile, GetAddIncidentCallback()));
 }
 
 void IncidentReportingService::RegisterDelayedAnalysisCallback(
     const DelayedAnalysisCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // |callback| will be run on the blocking pool, so it will likely run the
   // AddIncidentCallback there as well. Bounce the run of that callback back to
   // the current thread via AddIncidentOnOriginThread.
   delayed_analysis_callbacks_.RegisterCallback(
       base::Bind(callback,
                  base::Bind(&AddIncidentOnOriginThread,
-                            GetAddIncidentCallback(NULL),
+                            GetAddIncidentCallback(),
                             base::ThreadTaskRunnerHandle::Get())));
 
   // Start running the callbacks if any profiles are participating in safe
   // browsing. If none are now, running will commence if/when a participaing
   // profile is added.
   if (FindEligibleProfile())
     delayed_analysis_callbacks_.Start();
 }
 
 void IncidentReportingService::AddDownloadManager(
@@ skipping 172 matching lines @@
       }
     }
   }
   return candidate;
 }
 
 void IncidentReportingService::AddIncident(Profile* profile,
                                            scoped_ptr<Incident> incident) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  ProfileContext* context = GetProfileContext(profile);
-  // It is forbidden to call this function with a destroyed profile.
-  DCHECK(context);
+  // Ignore incidents from off-the-record profiles.
+  if (profile && profile->IsOffTheRecord())
+    return;
+
+  ProfileContext* context = GetOrCreateProfileContext(profile);
   // 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);
 
   LogIncidentDataType(RECEIVED, *incident);
 
   // Drop the incident immediately if the profile has already been added to the
   // manager and is not participating in safe browsing. Preference evaluation is
   // deferred until OnProfileAdded() otherwise.
   if (context->added &&
@@ skipping 424 matching lines @@
       if (!profile->IsOffTheRecord())
         OnProfileDestroyed(profile);
       break;
     }
     default:
       break;
   }
 }
 
 }  // namespace safe_browsing