Safe Browsing: Add Omnibox Interaction Incident Reporter

chrome/browser/safe_browsing/safe_browsing_service.cc

 // Copyright (c) 2012 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/safe_browsing_service.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/debug/leak_tracker.h"
 #include "base/lazy_instance.h"
 #include "base/path_service.h"
 #include "base/prefs/pref_change_registrar.h"
 #include "base/prefs/pref_service.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.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/profiles/profile_manager.h"
 #include "chrome/browser/safe_browsing/client_side_detection_service.h"
 #include "chrome/browser/safe_browsing/database_manager.h"
 #include "chrome/browser/safe_browsing/download_protection_service.h"
+#include "chrome/browser/safe_browsing/incident_reporting/omnibox_watcher.h"
 #include "chrome/browser/safe_browsing/malware_details.h"
 #include "chrome/browser/safe_browsing/ping_manager.h"
 #include "chrome/browser/safe_browsing/protocol_manager.h"
 #include "chrome/browser/safe_browsing/safe_browsing_database.h"
 #include "chrome/browser/safe_browsing/ui_manager.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
@@ skipping 199 matching lines @@
   // Track the safe browsing preference of existing profiles.
   // The SafeBrowsingService will be started if any existing profile has the
   // preference enabled. It will also listen for updates to the preferences.
   ProfileManager* profile_manager = g_browser_process->profile_manager();
   if (profile_manager) {
     std::vector<Profile*> profiles = profile_manager->GetLoadedProfiles();
     for (size_t i = 0; i < profiles.size(); ++i) {
       if (profiles[i]->IsOffTheRecord())
         continue;
       AddPrefService(profiles[i]->GetPrefs());
+      AddOmniboxWatcher(profiles[i]);
     }
   }
 
   // Track profile creation and destruction.
   prefs_registrar_.Add(this, chrome::NOTIFICATION_PROFILE_CREATED,
                        content::NotificationService::AllSources());
   prefs_registrar_.Add(this, chrome::NOTIFICATION_PROFILE_DESTROYED,
                        content::NotificationService::AllSources());
 
 #if defined(FULL_SAFE_BROWSING)
@@ skipping 256 matching lines @@
       base::Bind(&SafeBrowsingService::StopOnIOThread, this, shutdown));
 }
 
 void SafeBrowsingService::Observe(int type,
                                   const content::NotificationSource& source,
                                   const content::NotificationDetails& details) {
   switch (type) {
     case chrome::NOTIFICATION_PROFILE_CREATED: {
       DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
       Profile* profile = content::Source<Profile>(source).ptr();
-      if (!profile->IsOffTheRecord())
+      if (!profile->IsOffTheRecord()) {
         AddPrefService(profile->GetPrefs());
+        AddOmniboxWatcher(profile);
+      }
       break;
     }
     case chrome::NOTIFICATION_PROFILE_DESTROYED: {
       DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
       Profile* profile = content::Source<Profile>(source).ptr();
-      if (!profile->IsOffTheRecord())
+      if (!profile->IsOffTheRecord()) {
         RemovePrefService(profile->GetPrefs());
+        RemoveOmniboxWatcher(profile);
+      }
       break;
     }
     default:
       NOTREACHED();
   }
 }
 
 void SafeBrowsingService::AddPrefService(PrefService* pref_service) {
   DCHECK(prefs_map_.find(pref_service) == prefs_map_.end());
   PrefChangeRegistrar* registrar = new PrefChangeRegistrar();
   registrar->Init(pref_service);
   registrar->Add(prefs::kSafeBrowsingEnabled,
                  base::Bind(&SafeBrowsingService::RefreshState,
                             base::Unretained(this)));
   prefs_map_[pref_service] = registrar;
   RefreshState();
 }
 
 void SafeBrowsingService::RemovePrefService(PrefService* pref_service) {
   if (prefs_map_.find(pref_service) != prefs_map_.end()) {
     delete prefs_map_[pref_service];
     prefs_map_.erase(pref_service);
     RefreshState();
   } else {
     NOTREACHED();
   }
 }
 
+void SafeBrowsingService::AddOmniboxWatcher(Profile* profile) {
+  if (!incident_service_)
+    return;
+  DCHECK(omnibox_watcher_map_.find(profile) == omnibox_watcher_map_.end());
+  omnibox_watcher_map_[profile] =
+      new safe_browsing::OmniboxWatcher::OmniboxWatcher(
+          incident_service_->GetAddIncidentCallback(profile));
+}
+
+void SafeBrowsingService::RemoveOmniboxWatcher(Profile* profile) {
+  if (!incident_service_)
+    return;
+  if (omnibox_watcher_map_.find(profile) != omnibox_watcher_map_.end()) {
+    delete omnibox_watcher_map_[profile];
+    omnibox_watcher_map_.erase(profile);
+  } else {
+    NOTREACHED();
+  }
+}
+
 void SafeBrowsingService::RefreshState() {
   // Check if any profile requires the service to be active.
   bool enable = false;
   std::map<PrefService*, PrefChangeRegistrar*>::iterator iter;
   for (iter = prefs_map_.begin(); iter != prefs_map_.end(); ++iter) {
     if (iter->first->GetBoolean(prefs::kSafeBrowsingEnabled)) {
       enable = true;
       break;
     }
   }
 
   if (enable)
     Start();
   else
     Stop(false);
 
 #if defined(FULL_SAFE_BROWSING)
   if (csd_service_)
     csd_service_->SetEnabledAndRefreshState(enable);
   if (download_service_)
     download_service_->SetEnabled(enable);
 #endif
 }