Include the latest binary download info in safe browsing incident reports.

chrome/browser/safe_browsing/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/last_download_finder.h"
+
+#include <string>
+#include <vector>
+
+#include "base/bind.h"
+#include "base/callback.h"
+#include "base/file_util.h"
+#include "base/run_loop.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/strings/utf_string_conversions.h"
+#include "chrome/browser/history/chrome_history_client.h"
+#include "chrome/browser/history/chrome_history_client_factory.h"
+#include "chrome/browser/history/download_row.h"
+#include "chrome/browser/history/history_service.h"
+#include "chrome/browser/history/history_service_factory.h"
+#include "chrome/browser/history/web_history_service_factory.h"
+#include "chrome/browser/prefs/browser_prefs.h"
+#include "chrome/browser/profiles/profile_manager.h"
+#include "chrome/common/chrome_constants.h"
+#include "chrome/common/pref_names.h"
+#include "chrome/common/safe_browsing/csd.pb.h"
+#include "chrome/test/base/testing_browser_process.h"
+#include "chrome/test/base/testing_pref_service_syncable.h"
+#include "chrome/test/base/testing_profile.h"
+#include "chrome/test/base/testing_profile_manager.h"
+#include "content/public/test/test_browser_thread_bundle.h"
+#include "content/public/test/test_utils.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace {
+
+// A BrowserContextKeyedServiceFactory::TestingFactoryFunction that creates a
+// HistoryService for a TestingProfile.
+KeyedService* BuildHistoryService(content::BrowserContext* context) {
+  TestingProfile* profile = static_cast<TestingProfile*>(context);
+
+  // Delete the file before creating the service.
+  base::FilePath history_path(
+      profile->GetPath().Append(chrome::kHistoryFilename));
+  if (!base::DeleteFile(history_path, false) ||
+      base::PathExists(history_path)) {
+    ADD_FAILURE() << "failed to delete history db file "
+                  << history_path.value();
+    return NULL;
+  }
+
+  HistoryService* history_service = new HistoryService(
+      ChromeHistoryClientFactory::GetForProfile(profile), profile);
+  if (history_service->Init(profile->GetPath()))
+    return history_service;
+
+  ADD_FAILURE() << "failed to initialize history service";
+  delete history_service;
+  return NULL;
+}
+
+}  // namespace
+
+class LastDownloadFinderTest : public testing::Test {
+ public:
+  void NeverCalled(scoped_ptr<
+      safe_browsing::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
+  // passes the found download to |result| and then runs a closure.
+  void OnLastDownload(
+      scoped_ptr<safe_browsing::ClientIncidentReport_DownloadDetails>* result,
+      const base::Closure& quit_closure,
+      scoped_ptr<safe_browsing::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,
+  };
+
+  LastDownloadFinderTest() : profile_number_() {}
+
+  virtual void SetUp() OVERRIDE {
+    testing::Test::SetUp();
+    profile_manager_.reset(
+        new TestingProfileManager(TestingBrowserProcess::GetGlobal()));
+    ASSERT_TRUE(profile_manager_->SetUp());
+  }
+
+  virtual void TearDown() OVERRIDE {
+    // Shut down the history service on all profiles.
+    std::vector<Profile*> profiles(
+        profile_manager_->profile_manager()->GetLoadedProfiles());
+    for (size_t i = 0; i < profiles.size(); ++i) {
+      profiles[0]->AsTestingProfile()->DestroyHistoryService();
+    }
+    profile_manager_.reset();
+    TestingBrowserProcess::DeleteInstance();
+    testing::Test::TearDown();
+  }
+
+  TestingProfile* CreateProfile(SafeBrowsingDisposition safe_browsing_opt_in) {
+    std::string profile_name("profile");
+    profile_name.append(base::IntToString(++profile_number_));
+
+    // Set up keyed service factories.
+    TestingProfile::TestingFactories factories;
+    // Build up a custom history service.
+    factories.push_back(std::make_pair(HistoryServiceFactory::GetInstance(),
+                                       &BuildHistoryService));
+    // Suppress WebHistoryService since it makes network requests.
+    factories.push_back(std::make_pair(
+        WebHistoryServiceFactory::GetInstance(),
+        static_cast<BrowserContextKeyedServiceFactory::TestingFactoryFunction>(
+            NULL)));
+
+    // Create prefs for the profile with safe browsing enabled or not.
+    scoped_ptr<TestingPrefServiceSyncable> prefs(
+        new TestingPrefServiceSyncable);
+    chrome::RegisterUserProfilePrefs(prefs->registry());
+    prefs->SetBoolean(prefs::kSafeBrowsingEnabled,
+                      safe_browsing_opt_in == SAFE_BROWSING_OPT_IN);
+
+    TestingProfile* profile = profile_manager_->CreateTestingProfile(
+        profile_name,
+        prefs.PassAs<PrefServiceSyncable>(),
+        base::UTF8ToUTF16(profile_name),  // user_name
+        0,                                // avatar_id
+        std::string(),                    // supervised_user_id
+        factories);
+
+    return profile;
+  }
+
+  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()));
+    run_loop.Run();
+  }
+
+  // Wait for the history backend thread to process any outstanding tasks.
+  // This is needed because HistoryService::QueryDownloads uses PostTaskAndReply
+  // to do work on the backend thread and then invoke the caller's callback on
+  // the originating thread. The PostTaskAndReplyRelay holds a reference to the
+  // backend until its RunReplyAndSelfDestruct is called on the originating
+  // thread. This reference MUST be released (on the originating thread,
+  // remember) _before_ calling DestroyHistoryService in TearDown(). See the
+  // giant comment in HistoryService::Cleanup explaining where the backend's
+  // dtor must be run.
+  void FlushHistoryBackend(Profile* profile) {
+    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() {
+    base::RunLoop run_loop;
+
+    scoped_ptr<safe_browsing::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())));
+
+    if (finder)
+      run_loop.Run();
+
+    return last_download.Pass();
+  }
+
+  history::DownloadRow CreateTestDownloadRow() {
+    base::Time now(base::Time::Now());
+    return history::DownloadRow(
+        base::FilePath(FILE_PATH_LITERAL("spam.exe")),
+        base::FilePath(FILE_PATH_LITERAL("spam.exe")),
+        std::vector<GURL>(1, GURL("http://www.google.com")),  // url_chain
+        GURL(),                                               // referrer
+        "application/octet-stream",                           // mime_type
+        "application/octet-stream",                   // original_mime_type
+        now - base::TimeDelta::FromMinutes(10),       // start
+        now - base::TimeDelta::FromMinutes(9),        // end
+        std::string(),                                // etag
+        std::string(),                                // last_modified
+        47LL,                                         // received
+        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) {
+    EXPECT_FALSE(download);
+  }
+
+  void ExpectFoundTestDownload(scoped_ptr<
+      safe_browsing::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); }
+
+  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.
+TEST_F(LastDownloadFinderTest, NoParticipatingProfiles) {
+  // Create a profile with a history service that is opted-out
+  TestingProfile* profile = CreateProfile(SAFE_BROWSING_OPT_OUT);
+
+  // Add a download.
+  AddDownload(profile, CreateTestDownloadRow());
+
+  ExpectNoDownloadFound(RunLastDownloadFinder());
+}
+
+// Tests that a download is found from a single profile.
+TEST_F(LastDownloadFinderTest, SimpleEndToEnd) {
+  // Create a profile with a history service that is opted-in.
+  TestingProfile* profile = CreateProfile(SAFE_BROWSING_OPT_IN);
+
+  // Add a download.
+  AddDownload(profile, CreateTestDownloadRow());
+
+  ExpectFoundTestDownload(RunLastDownloadFinder());
+}
+
+// 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();
+
+  // 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;
+  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())));
+
+  run_loop.Run();
+
+  ExpectFoundTestDownload(last_download.Pass());
+}