Safe Browsing: Add Omnibox Interaction Incident Reporter

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 10 matching lines @@
 #include "base/values.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"
 #include "chrome/browser/safe_browsing/incident_reporting/binary_integrity_incident_handlers.h"
 #include "chrome/browser/safe_browsing/incident_reporting/blacklist_load_incident_handlers.h"
 #include "chrome/browser/safe_browsing/incident_reporting/environment_data_collection.h"
 #include "chrome/browser/safe_browsing/incident_reporting/incident_report_uploader_impl.h"
+#include "chrome/browser/safe_browsing/incident_reporting/omnibox_incident_handlers.h"
+#include "chrome/browser/safe_browsing/incident_reporting/omnibox_watcher.h"
 #include "chrome/browser/safe_browsing/incident_reporting/preference_validation_delegate.h"
 #include "chrome/browser/safe_browsing/incident_reporting/tracked_preference_incident_handlers.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/safe_browsing/csd.pb.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "net/url_request/url_request_context_getter.h"
 
 namespace safe_browsing {
 
 namespace {
 
 // The type of an incident. Used for user metrics and for pruning of
 // previously-reported incidents.
 enum IncidentType {
   // Start with 1 rather than zero; otherwise there won't be enough buckets for
   // the histogram.
   TRACKED_PREFERENCE = 1,
   BINARY_INTEGRITY = 2,
   BLACKLIST_LOAD = 3,
+  OMNIBOX_INTERACTION = 4,
   // Values for new incident types go here.
-  NUM_INCIDENT_TYPES = 4
+  NUM_INCIDENT_TYPES = 5
 };
 
 // The action taken for an incident; used for user metrics (see
 // LogIncidentDataType).
 enum IncidentDisposition {
   RECEIVED,
   DROPPED,
   ACCEPTED,
   PRUNED,
   DISCARDED,
@@ skipping 22 matching lines @@
 // 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;
   if (incident.has_binary_integrity())
     ++result;
   if (incident.has_blacklist_load())
     ++result;
+  if (incident.has_omnibox_interaction())
+    ++result;
   // Add detection for new incident types here.
   return result;
 }
 
 // Returns the type of incident contained in |incident_data|.
 IncidentType GetIncidentType(
     const ClientIncidentReport_IncidentData& incident_data) {
   if (incident_data.has_tracked_preference())
     return TRACKED_PREFERENCE;
   if (incident_data.has_binary_integrity())
     return BINARY_INTEGRITY;
   if (incident_data.has_blacklist_load())
     return BLACKLIST_LOAD;
+  if (incident_data.has_omnibox_interaction())
+    return OMNIBOX_INTERACTION;
 
   // Add detection for new incident types here.
-  COMPILE_ASSERT(BLACKLIST_LOAD + 1 == NUM_INCIDENT_TYPES,
+  COMPILE_ASSERT(OMNIBOX_INTERACTION + 1 == NUM_INCIDENT_TYPES,
                  add_support_for_new_types);
   NOTREACHED();
   return NUM_INCIDENT_TYPES;
 }
 
 // Logs the type of incident in |incident_data| to a user metrics histogram.
 void LogIncidentDataType(
     IncidentDisposition disposition,
     const ClientIncidentReport_IncidentData& incident_data) {
   static const char* const kHistogramNames[] = {
@@ skipping 26 matching lines @@
       state.digest = GetTrackedPreferenceIncidentDigest(incident);
       break;
     case BINARY_INTEGRITY:
       state.key = GetBinaryIntegrityIncidentKey(incident);
       state.digest = GetBinaryIntegrityIncidentDigest(incident);
       break;
     case BLACKLIST_LOAD:
       state.key = GetBlacklistLoadIncidentKey(incident);
       state.digest = GetBlacklistLoadIncidentDigest(incident);
       break;
+    case OMNIBOX_INTERACTION:
+      state.key = GetOmniboxIncidentKey(incident);
+      state.digest = GetOmniboxIncidentDigest(incident);
+      break;
     // Add handling for new incident types here.
     default:
-      COMPILE_ASSERT(BLACKLIST_LOAD + 1 == NUM_INCIDENT_TYPES,
+      COMPILE_ASSERT(OMNIBOX_INTERACTION + 1 == NUM_INCIDENT_TYPES,
                      add_support_for_new_types);
       NOTREACHED();
       break;
   }
   return state;
 }
 
 // Returns true if the incident described by |state| has already been reported
 // based on the bookkeeping in the |incidents_sent| preference dictionary.
 bool IncidentHasBeenReported(const base::DictionaryValue* incidents_sent,
@@ skipping 41 matching lines @@
 }  // namespace
 
 struct IncidentReportingService::ProfileContext {
   ProfileContext();
   ~ProfileContext();
 
   // The incidents collected for this profile pending creation and/or upload.
   // Will contain null values for pruned incidents.
   ScopedVector<ClientIncidentReport_IncidentData> incidents;
 
+  // Watches for suspicious omnibox interactions on this profile.
+  scoped_ptr<OmniboxWatcher> omnibox_watcher;
+
   // False until PROFILE_ADDED notification is received.
   bool added;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ProfileContext);
 };
 
 class IncidentReportingService::UploadContext {
  public:
   typedef std::map<Profile*, std::vector<PersistentIncidentState> >
@@ skipping 184 matching lines @@
   }
 }
 
 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);
+  // Start watching the profile now if necessary.
+  if (!context->omnibox_watcher) {
+    context->omnibox_watcher.reset(
+        new OmniboxWatcher(profile, GetAddIncidentCallback(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. Start is idempotent, so this is safe even if
   // they're already running.
   if (safe_browsing_enabled)
     delayed_analysis_callbacks_.Start();
@@ skipping 552 matching lines @@
       if (!profile->IsOffTheRecord())
         OnProfileDestroyed(profile);
       break;
     }
     default:
       break;
   }
 }
 
 }  // namespace safe_browsing