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

chrome/browser/safe_browsing/incident_reporting/last_download_finder_unittest.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/last_download_finder.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 43 matching lines @@
   if (history_service->Init(profile->GetPath()))
     return history_service;
 
   ADD_FAILURE() << "failed to initialize history service";
   delete history_service;
   return NULL;
 }
 
 }  // namespace
 
+namespace safe_browsing {
+
 class LastDownloadFinderTest : public testing::Test {
  public:
-  void NeverCalled(scoped_ptr<
-      safe_browsing::ClientIncidentReport_DownloadDetails> download) {
+  void NeverCalled(scoped_ptr<ClientIncidentReport_DownloadDetails> download) {
     FAIL();
   }
 
   // Creates a new profile that participates in safe browsing and adds a
   // download to its history.
   void CreateProfileWithDownload() {
     TestingProfile* profile = CreateProfile(SAFE_BROWSING_OPT_IN);
     HistoryService* history_service =
         HistoryServiceFactory::GetForProfile(profile, Profile::EXPLICIT_ACCESS);
     history_service->CreateDownload(
         CreateTestDownloadRow(),
         base::Bind(&LastDownloadFinderTest::OnDownloadCreated,
                    base::Unretained(this)));
   }
 
-  // safe_browsing::LastDownloadFinder::LastDownloadCallback implementation that
+  // LastDownloadFinder::LastDownloadCallback implementation that
   // passes the found download to |result| and then runs a closure.
   void OnLastDownload(
-      scoped_ptr<safe_browsing::ClientIncidentReport_DownloadDetails>* result,
+      scoped_ptr<ClientIncidentReport_DownloadDetails>* result,
       const base::Closure& quit_closure,
-      scoped_ptr<safe_browsing::ClientIncidentReport_DownloadDetails>
-          download) {
+      scoped_ptr<ClientIncidentReport_DownloadDetails> download) {
     *result = download.Pass();
     quit_closure.Run();
   }
 
  protected:
   // A type for specifying whether or not a profile created by CreateProfile
   // participates in safe browsing.
   enum SafeBrowsingDisposition {
     SAFE_BROWSING_OPT_OUT,
     SAFE_BROWSING_OPT_IN,
@@ skipping 46 matching lines @@
         profile_name,
         prefs.Pass(),
         base::UTF8ToUTF16(profile_name),  // user_name
         0,                                // avatar_id
         std::string(),                    // supervised_user_id
         factories);
 
     return profile;
   }
 
+  LastDownloadFinder::DownloadDetailsGetter GetDownloadDetailsGetter() {
+    return base::Bind(&LastDownloadFinderTest::GetDownloadDetails,
+                      base::Unretained(this));
+  }
+
   void AddDownload(Profile* profile, const history::DownloadRow& download) {
     base::RunLoop run_loop;
 
     HistoryService* history_service =
         HistoryServiceFactory::GetForProfile(profile, Profile::EXPLICIT_ACCESS);
     history_service->CreateDownload(
         download,
         base::Bind(&LastDownloadFinderTest::ContinueOnDownloadCreated,
                    base::Unretained(this),
                    run_loop.QuitClosure()));
@@ skipping 13 matching lines @@
     base::RunLoop run_loop;
     HistoryServiceFactory::GetForProfile(profile, Profile::EXPLICIT_ACCESS)
         ->FlushForTest(run_loop.QuitClosure());
     run_loop.Run();
     // Then make sure anything bounced back to the main thread has been handled.
     base::RunLoop().RunUntilIdle();
   }
 
   // Runs the last download finder on all loaded profiles, returning the found
   // download or an empty pointer if none was found.
-  scoped_ptr<safe_browsing::ClientIncidentReport_DownloadDetails>
-  RunLastDownloadFinder() {
+  scoped_ptr<ClientIncidentReport_DownloadDetails> RunLastDownloadFinder() {
     base::RunLoop run_loop;
 
-    scoped_ptr<safe_browsing::ClientIncidentReport_DownloadDetails>
-        last_download;
+    scoped_ptr<ClientIncidentReport_DownloadDetails> last_download;
 
-    scoped_ptr<safe_browsing::LastDownloadFinder> finder(
-        safe_browsing::LastDownloadFinder::Create(
-            base::Bind(&LastDownloadFinderTest::OnLastDownload,
-                       base::Unretained(this),
-                       &last_download,
-                       run_loop.QuitClosure())));
+    scoped_ptr<LastDownloadFinder> finder(LastDownloadFinder::Create(
+        GetDownloadDetailsGetter(),
+        base::Bind(&LastDownloadFinderTest::OnLastDownload,
+                   base::Unretained(this),
+                   &last_download,
+                   run_loop.QuitClosure())));
 
     if (finder)
       run_loop.Run();
 
     return last_download.Pass();
   }
 
   history::DownloadRow CreateTestDownloadRow() {
     base::Time now(base::Time::Now());
     return history::DownloadRow(
@@ skipping 11 matching lines @@
         47LL,                                         // total
         content::DownloadItem::COMPLETE,              // download_state
         content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,  // danger_type
         content::DOWNLOAD_INTERRUPT_REASON_NONE,      // interrupt_reason,
         1,                                            // id
         false,                                        // download_opened
         std::string(),                                // ext_id
         std::string());                               // ext_name
   }
 
-  void ExpectNoDownloadFound(scoped_ptr<
-      safe_browsing::ClientIncidentReport_DownloadDetails> download) {
+  void ExpectNoDownloadFound(
+      scoped_ptr<ClientIncidentReport_DownloadDetails> download) {
     EXPECT_FALSE(download);
   }
 
-  void ExpectFoundTestDownload(scoped_ptr<
-      safe_browsing::ClientIncidentReport_DownloadDetails> download) {
+  void ExpectFoundTestDownload(
+      scoped_ptr<ClientIncidentReport_DownloadDetails> download) {
     ASSERT_TRUE(download);
   }
 
   content::TestBrowserThreadBundle browser_thread_bundle_;
   scoped_ptr<TestingProfileManager> profile_manager_;
 
  private:
   // A HistoryService::DownloadCreateCallback that asserts that the download was
   // created and runs |closure|.
   void ContinueOnDownloadCreated(const base::Closure& closure, bool created) {
     ASSERT_TRUE(created);
     closure.Run();
   }
 
   // A HistoryService::DownloadCreateCallback that asserts that the download was
   // created.
   void OnDownloadCreated(bool created) { ASSERT_TRUE(created); }
 
+  void GetDownloadDetails(
+      content::BrowserContext* context,
+      const DownloadMetadataManager::GetDownloadDetailsCallback& callback) {
+    callback.Run(scoped_ptr<ClientIncidentReport_DownloadDetails>());
+  }
+
   int profile_number_;
 };
 
 // Tests that nothing happens if there are no profiles at all.
 TEST_F(LastDownloadFinderTest, NoProfiles) {
   ExpectNoDownloadFound(RunLastDownloadFinder());
 }
 
 // Tests that nothing happens other than the callback being invoked if there are
 // no profiles participating in safe browsing.
@@ skipping 20 matching lines @@
 
 // Tests that there is no crash if the finder is deleted before results arrive.
 TEST_F(LastDownloadFinderTest, DeleteBeforeResults) {
   // Create a profile with a history service that is opted-in.
   TestingProfile* profile = CreateProfile(SAFE_BROWSING_OPT_IN);
 
   // Add a download.
   AddDownload(profile, CreateTestDownloadRow());
 
   // Start a finder and kill it before the search completes.
-  safe_browsing::LastDownloadFinder::Create(
-      base::Bind(&LastDownloadFinderTest::NeverCalled, base::Unretained(this)))
-      .reset();
+  LastDownloadFinder::Create(GetDownloadDetailsGetter(),
+                             base::Bind(&LastDownloadFinderTest::NeverCalled,
+                                        base::Unretained(this))).reset();
 
   // Flush tasks on the history backend thread.
   FlushHistoryBackend(profile);
 }
 
 // Tests that a download in profile added after the search is begun is found.
 TEST_F(LastDownloadFinderTest, AddProfileAfterStarting) {
   // Create a profile with a history service that is opted-in.
   CreateProfile(SAFE_BROWSING_OPT_IN);
 
-  scoped_ptr<safe_browsing::ClientIncidentReport_DownloadDetails> last_download;
+  scoped_ptr<ClientIncidentReport_DownloadDetails> last_download;
   base::RunLoop run_loop;
 
   // Post a task that will create a second profile once the main loop is run.
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&LastDownloadFinderTest::CreateProfileWithDownload,
                  base::Unretained(this)));
 
   // Create a finder that we expect will find a download in the second profile.
-  scoped_ptr<safe_browsing::LastDownloadFinder> finder(
-      safe_browsing::LastDownloadFinder::Create(
-          base::Bind(&LastDownloadFinderTest::OnLastDownload,
-                     base::Unretained(this),
-                     &last_download,
-                     run_loop.QuitClosure())));
+  scoped_ptr<LastDownloadFinder> finder(LastDownloadFinder::Create(
+      GetDownloadDetailsGetter(),
+      base::Bind(&LastDownloadFinderTest::OnLastDownload,
+                 base::Unretained(this),
+                 &last_download,
+                 run_loop.QuitClosure())));
 
   run_loop.Run();
 
   ExpectFoundTestDownload(last_download.Pass());
 }
+
+}  // namespace safe_browsing