Include high-fidelity metadata about a download in incident reports.

chrome/browser/safe_browsing/incident_reporting/incident_reporting_service.h

 // 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.
 
 #ifndef CHROME_BROWSER_SAFE_BROWSING_INCIDENT_REPORTING_INCIDENT_REPORTING_SERVICE_H_
 #define CHROME_BROWSER_SAFE_BROWSING_INCIDENT_REPORTING_INCIDENT_REPORTING_SERVICE_H_
 
 #include <stdint.h>
 
 #include <map>
 
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/thread_checker.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
+#include "chrome/browser/safe_browsing/download_protection_service.h"
 #include "chrome/browser/safe_browsing/incident_reporting/add_incident_callback.h"
 #include "chrome/browser/safe_browsing/incident_reporting/delayed_analysis_callback.h"
 #include "chrome/browser/safe_browsing/incident_reporting/delayed_callback_runner.h"
+#include "chrome/browser/safe_browsing/incident_reporting/download_metadata_manager.h"
 #include "chrome/browser/safe_browsing/incident_reporting/incident_report_uploader.h"
 #include "chrome/browser/safe_browsing/incident_reporting/last_download_finder.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 
 class Profile;
 class SafeBrowsingDatabaseManager;
 class SafeBrowsingService;
 class TrackedPreferenceValidationDelegate;
 
 namespace base {
 class TaskRunner;
 }
 
 namespace content {
+class DownloadManager;
 class NotificationDetails;
 class NotificationSource;
 }
 
 namespace net {
 class URLRequestContextGetter;
 }
 
 namespace safe_browsing {
 
+class ClientDownloadRequest;
 class ClientIncidentReport;
 class ClientIncidentReport_DownloadDetails;
 class ClientIncidentReport_EnvironmentData;
 class ClientIncidentReport_IncidentData;
 
 // A class that manages the collection of incidents and submission of incident
 // reports to the safe browsing client-side detection service. The service
 // begins operation when an incident is reported via the AddIncident method.
 // Incidents reported from a profile that is loading are held until the profile
 // is fully created. Incidents originating from profiles that do not participate
@@ skipping 24 matching lines @@
   // for validation failures in |profile|. The delegate may outlive the service,
   // but incidents reported by it will no longer have any effect after the
   // service is deleted. The lifetime of the delegate should not extend beyond
   // that of the profile it services.
   scoped_ptr<TrackedPreferenceValidationDelegate>
       CreatePreferenceValidationDelegate(Profile* profile);
 
   // Registers |callback| to be run after some delay following process launch.
   void RegisterDelayedAnalysisCallback(const DelayedAnalysisCallback& callback);
 
+  // Adds |download_manager| to the set monitored for client download request
+  // storage.
+  void AddDownloadManager(content::DownloadManager* download_manager);
+
  protected:
   // A pointer to a function that populates a protobuf with environment data.
   typedef void (*CollectEnvironmentDataFn)(
       ClientIncidentReport_EnvironmentData*);
 
   // For testing so that the TaskRunner used for delayed analysis callbacks can
   // be specified.
   IncidentReportingService(
       SafeBrowsingService* safe_browsing_service,
       const scoped_refptr<net::URLRequestContextGetter>& request_context_getter,
@@ skipping 122 matching lines @@
   void OnKillSwitchResult(UploadContext* context, bool is_killswitch_on);
 
   // Performs processing for a report after succesfully receiving a response.
   void HandleResponse(const UploadContext& context);
 
   // IncidentReportUploader::OnResultCallback implementation.
   void OnReportUploadResult(UploadContext* context,
                             IncidentReportUploader::Result result,
                             scoped_ptr<ClientIncidentResponse> response);
 
+  // DownloadProtectionService::ClientDownloadRequestCallback implementation.
+  void OnClientDownloadRequest(content::DownloadItem* download,
+                               const ClientDownloadRequest* request);
+
   // content::NotificationObserver methods.
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) override;
 
   base::ThreadChecker thread_checker_;
 
   // The safe browsing database manager, through which the whitelist killswitch
   // is checked.
   scoped_refptr<SafeBrowsingDatabaseManager> database_manager_;
 
   // Accessor for an URL context with which reports will be sent.
   scoped_refptr<net::URLRequestContextGetter> url_request_context_getter_;
 
   // A pointer to a function that collects environment data. The function will
   // be run by |environment_collection_task_runner_|. This is ordinarily
   // CollectEnvironmentData, but may be overridden by tests; see
   // SetCollectEnvironmentHook.
   CollectEnvironmentDataFn collect_environment_data_fn_;
 
   // The task runner on which environment collection takes place. This is
   // ordinarily a runner in the browser's blocking pool that will skip the
   // collection task at shutdown if it has not yet started.
   scoped_refptr<base::TaskRunner> environment_collection_task_runner_;
 
   // Registrar for observing profile lifecycle notifications.
   content::NotificationRegistrar notification_registrar_;
 
+  // A subscription for ClientDownloadRequests, used to persist them for later
+  // use.
+  DownloadProtectionService::ClientDownloadRequestSubscription
+      client_download_request_subscription_;
+
   // True when the asynchronous environment collection task has been fired off
   // but has not yet completed.
   bool environment_collection_pending_;
 
   // True when an incident has been received and the service is waiting for the
   // collation_timer_ to fire.
   bool collation_timeout_pending_;
 
   // A timer upon the firing of which the service will report received
   // incidents.
@@ skipping 16 matching lines @@
   // The time at which download collection was initiated.
   base::TimeTicks last_download_begin_;
 
   // Context data for all on-the-record profiles plus the process-wide (NULL)
   // context.
   ProfileContextCollection profiles_;
 
   // Callbacks registered for performing delayed analysis.
   DelayedCallbackRunner delayed_analysis_callbacks_;
 
+  DownloadMetadataManager download_metadata_manager_;
+
   // The collection of uploads in progress.
   ScopedVector<UploadContext> uploads_;
 
   // An object that asynchronously searches for the most recent binary download.
   // Non-NULL while such a search is outstanding.
   scoped_ptr<LastDownloadFinder> last_download_finder_;
 
   // A factory for handing out weak pointers for AddIncident callbacks.
   base::WeakPtrFactory<IncidentReportingService> receiver_weak_ptr_factory_;
 
   // A factory for handing out weak pointers for internal asynchronous tasks
   // that are posted during normal processing (e.g., environment collection,
   // safe browsing database checks, and report uploads).
   base::WeakPtrFactory<IncidentReportingService> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(IncidentReportingService);
 };
 
 }  // namespace safe_browsing
 
 #endif  // CHROME_BROWSER_SAFE_BROWSING_INCIDENT_REPORTING_INCIDENT_REPORTING_SERVICE_H_