Sample 1% url whitelisted PPAPI downloads to ping safe browsing server

chrome/browser/safe_browsing/download_protection_service_unittest.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/download_protection_service.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
@@ skipping 536 matching lines @@
 
 
 void DownloadProtectionServiceTest::CheckClientDownloadReportCorruptZip(
     bool is_extended_reporting,
     bool is_incognito) {
   net::FakeURLFetcherFactory factory(NULL);
   PrepareResponse(
       &factory, ClientDownloadResponse::SAFE, net::HTTP_OK,
       net::URLRequestStatus::SUCCESS);
 
-  profile_->GetPrefs()->SetBoolean(prefs::kSafeBrowsingExtendedReportingEnabled,
-                                   is_extended_reporting);
+  SetExtendedReportingPreference(is_extended_reporting);
   content::MockDownloadItem item;
   PrepareBasicDownloadItem(
     &item,
     {"http://www.evil.com/a.zip"},  // url_chain
     "http://www.google.com/",       // referrer
     FILE_PATH_LITERAL("a.tmp"),     // tmp_path
     FILE_PATH_LITERAL("a.zip"));    // final_path
 
   if (is_incognito) {
     EXPECT_CALL(item, GetBrowserContext())
@@ skipping 1402 matching lines @@
   EXPECT_EQ(token, DownloadProtectionService::GetDownloadPingToken(&item));
 
   DownloadProtectionService::SetDownloadPingToken(&item, std::string());
   EXPECT_TRUE(DownloadProtectionService::GetDownloadPingToken(&item).empty());
 }
 
 TEST_F(DownloadProtectionServiceTest, PPAPIDownloadRequest_Unsupported) {
   base::FilePath default_file_path(FILE_PATH_LITERAL("/foo/bar/test.txt"));
   std::vector<base::FilePath::StringType> alternate_extensions{
       FILE_PATH_LITERAL(".tmp"), FILE_PATH_LITERAL(".asdfasdf")};
+  SetExtendedReportingPreference(false);
   download_service_->CheckPPAPIDownloadRequest(
       GURL("http://example.com/foo"), default_file_path, alternate_extensions,
+      profile_.get(),
       base::Bind(&DownloadProtectionServiceTest::SyncCheckDoneCallback,
                  base::Unretained(this)));
   ASSERT_TRUE(IsResult(DownloadProtectionService::SAFE));
 }
 
 TEST_F(DownloadProtectionServiceTest, PPAPIDownloadRequest_SupportedDefault) {
   net::FakeURLFetcherFactory factory(nullptr);
   base::FilePath default_file_path(FILE_PATH_LITERAL("/foo/bar/test.crx"));
   std::vector<base::FilePath::StringType> alternate_extensions;
   EXPECT_CALL(*sb_service_->mock_database_manager(),
               MatchDownloadWhitelistUrl(_))
       .WillRepeatedly(Return(false));
   struct {
     ClientDownloadResponse::Verdict verdict;
     DownloadProtectionService::DownloadCheckResult expected_result;
   } kExpectedResults[] = {
       {ClientDownloadResponse::SAFE, DownloadProtectionService::SAFE},
       {ClientDownloadResponse::DANGEROUS, DownloadProtectionService::DANGEROUS},
       {ClientDownloadResponse::UNCOMMON, DownloadProtectionService::UNCOMMON},
       {ClientDownloadResponse::DANGEROUS_HOST,
        DownloadProtectionService::DANGEROUS_HOST},
       {ClientDownloadResponse::POTENTIALLY_UNWANTED,
        DownloadProtectionService::POTENTIALLY_UNWANTED},
   };
 
   for (const auto& test_case : kExpectedResults) {
     factory.ClearFakeResponses();
     PrepareResponse(&factory, test_case.verdict, net::HTTP_OK,
                     net::URLRequestStatus::SUCCESS);
+    SetExtendedReportingPreference(false);
     download_service_->CheckPPAPIDownloadRequest(
         GURL("http://example.com/foo"), default_file_path, alternate_extensions,
+        profile_.get(),
         base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                    base::Unretained(this)));
     MessageLoop::current()->Run();
     ASSERT_TRUE(IsResult(test_case.expected_result));
   }
 }
 
 TEST_F(DownloadProtectionServiceTest, PPAPIDownloadRequest_SupportedAlternate) {
   net::FakeURLFetcherFactory factory(nullptr);
   base::FilePath default_file_path(FILE_PATH_LITERAL("/foo/bar/test.txt"));
   std::vector<base::FilePath::StringType> alternate_extensions{
       FILE_PATH_LITERAL(".tmp"), FILE_PATH_LITERAL(".crx")};
   PrepareResponse(&factory, ClientDownloadResponse::DANGEROUS, net::HTTP_OK,
                   net::URLRequestStatus::SUCCESS);
   EXPECT_CALL(*sb_service_->mock_database_manager(),
               MatchDownloadWhitelistUrl(_))
       .WillRepeatedly(Return(false));
+  SetExtendedReportingPreference(false);
   download_service_->CheckPPAPIDownloadRequest(
       GURL("http://example.com/foo"), default_file_path, alternate_extensions,
+      profile_.get(),
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
   MessageLoop::current()->Run();
 
   ASSERT_TRUE(IsResult(DownloadProtectionService::DANGEROUS));
 }
 
-TEST_F(DownloadProtectionServiceTest, PPAPIDownloadRequest_WhitelistedURL) {
+TEST_F(DownloadProtectionServiceTest,
+       PPAPIDownloadRequest_WhitelistedURLNotExtendedReporting) {
   net::FakeURLFetcherFactory factory(nullptr);
   base::FilePath default_file_path(FILE_PATH_LITERAL("/foo/bar/test.crx"));
   std::vector<base::FilePath::StringType> alternate_extensions;
+  // Configs "server" side response to DANGEROUS, in case a request is send out.
+  PrepareResponse(&factory, ClientDownloadResponse::DANGEROUS, net::HTTP_OK,
+                  net::URLRequestStatus::SUCCESS);
   EXPECT_CALL(*sb_service_->mock_database_manager(),
               MatchDownloadWhitelistUrl(_))
       .WillRepeatedly(Return(true));
+  SetExtendedReportingPreference(false);
+  // Sets the sample rate to 1.00.
+  SetWhitelistedDownloadSampleRate(1.00);
   download_service_->CheckPPAPIDownloadRequest(
       GURL("http://example.com/foo"), default_file_path, alternate_extensions,
+      profile_.get(),
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
   MessageLoop::current()->Run();
 
+  // Result should be SAFE, since download matches whitelist but user is not in
+  // extended reporting group (a.k.a no request sents out).
   ASSERT_TRUE(IsResult(DownloadProtectionService::SAFE));
 }
 
+TEST_F(DownloadProtectionServiceTest,
+       PPAPIDownloadRequest_WhitelistedURLIncognito) {
+  net::FakeURLFetcherFactory factory(nullptr);
+  base::FilePath default_file_path(FILE_PATH_LITERAL("/foo/bar/test.crx"));
+  std::vector<base::FilePath::StringType> alternate_extensions;
+  // Configs "server" side response to DANGEROUS, in case a request is send out.
+  PrepareResponse(&factory, ClientDownloadResponse::DANGEROUS, net::HTTP_OK,
+                  net::URLRequestStatus::SUCCESS);
+  EXPECT_CALL(*sb_service_->mock_database_manager(),
+              MatchDownloadWhitelistUrl(_))
+      .WillRepeatedly(Return(true));
+  SetExtendedReportingPreference(true);
+  download_service_->CheckPPAPIDownloadRequest(
+      GURL("http://example.com/foo"), default_file_path, alternate_extensions,
+      profile_->GetOffTheRecordProfile(),
+      base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
+                 base::Unretained(this)));
+  MessageLoop::current()->Run();
+
+  // Result should still be SAFE, since download matches whitelist and user is
+  // in incognito mode.
+  ASSERT_TRUE(IsResult(DownloadProtectionService::SAFE));
+}
+
+TEST_F(DownloadProtectionServiceTest,
+       PPAPIDownloadRequest_SampleWhitelistedURL) {
+  net::FakeURLFetcherFactory factory(nullptr);
+  base::FilePath default_file_path(FILE_PATH_LITERAL("/foo/bar/test.crx"));
+  std::vector<base::FilePath::StringType> alternate_extensions;
+  // Configs "server" side response to DANGEROUS.
+  PrepareResponse(&factory, ClientDownloadResponse::DANGEROUS, net::HTTP_OK,
+                  net::URLRequestStatus::SUCCESS);
+  EXPECT_CALL(*sb_service_->mock_database_manager(),
+              MatchDownloadWhitelistUrl(_))
+      .WillRepeatedly(Return(true));
+  // Sets the sample rate to 1.00 to trigger ClientDownloadRequest.
+  SetWhitelistedDownloadSampleRate(1.00);
+  SetExtendedReportingPreference(true);
+  download_service_->CheckPPAPIDownloadRequest(
+      GURL("http://example.com/foo"), default_file_path, alternate_extensions,
+      profile_.get(),
+      base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
+                 base::Unretained(this)));
+  MessageLoop::current()->Run();

[Lei Zhang, 2016/07/14 23:56:11]

This is deprecated. Use a base::RunLoop instead. See the MessageLoop::Run()
header / impl.

[Jialiu Lin, 2016/07/15 01:20:06]

Done.

+
+  // Result should be Dangerous, since we will sample this download and ping SB
+  // Server (server returns DANGEROUS verdict).
+  ASSERT_TRUE(IsResult(DownloadProtectionService::DANGEROUS));
+}
+
 TEST_F(DownloadProtectionServiceTest, PPAPIDownloadRequest_FetchFailed) {
   net::FakeURLFetcherFactory factory(nullptr);
   base::FilePath default_file_path(FILE_PATH_LITERAL("/foo/bar/test.crx"));
   std::vector<base::FilePath::StringType> alternate_extensions;
   PrepareResponse(&factory, ClientDownloadResponse::DANGEROUS, net::HTTP_OK,
                   net::URLRequestStatus::FAILED);
   EXPECT_CALL(*sb_service_->mock_database_manager(),
               MatchDownloadWhitelistUrl(_))
       .WillRepeatedly(Return(false));
+  SetExtendedReportingPreference(false);
   download_service_->CheckPPAPIDownloadRequest(
       GURL("http://example.com/foo"), default_file_path, alternate_extensions,
+      profile_.get(),
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
   MessageLoop::current()->Run();
 
   ASSERT_TRUE(IsResult(DownloadProtectionService::UNKNOWN));
 }
 
 TEST_F(DownloadProtectionServiceTest, PPAPIDownloadRequest_InvalidResponse) {
   net::FakeURLFetcherFactory factory(nullptr);
   base::FilePath default_file_path(FILE_PATH_LITERAL("/foo/bar/test.crx"));
   std::vector<base::FilePath::StringType> alternate_extensions;
   factory.SetFakeResponse(DownloadProtectionService::GetDownloadRequestUrl(),
                           "Hello world!", net::HTTP_OK,
                           net::URLRequestStatus::SUCCESS);
   EXPECT_CALL(*sb_service_->mock_database_manager(),
               MatchDownloadWhitelistUrl(_))
       .WillRepeatedly(Return(false));
+  SetExtendedReportingPreference(false);
   download_service_->CheckPPAPIDownloadRequest(
       GURL("http://example.com/foo"), default_file_path, alternate_extensions,
+      profile_.get(),
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
   MessageLoop::current()->Run();
 
   ASSERT_TRUE(IsResult(DownloadProtectionService::UNKNOWN));
 }
 
 TEST_F(DownloadProtectionServiceTest, PPAPIDownloadRequest_Timeout) {
   net::FakeURLFetcherFactory factory(nullptr);
   base::FilePath default_file_path(FILE_PATH_LITERAL("/foo/bar/test.crx"));
   std::vector<base::FilePath::StringType> alternate_extensions;
   EXPECT_CALL(*sb_service_->mock_database_manager(),
               MatchDownloadWhitelistUrl(_))
       .WillRepeatedly(Return(false));
   PrepareResponse(&factory, ClientDownloadResponse::SAFE, net::HTTP_OK,
                   net::URLRequestStatus::SUCCESS);
   download_service_->download_request_timeout_ms_ = 0;
+  SetExtendedReportingPreference(false);
   download_service_->CheckPPAPIDownloadRequest(
       GURL("http://example.com/foo"), default_file_path, alternate_extensions,
+      profile_.get(),
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
   MessageLoop::current()->Run();
 
   ASSERT_TRUE(IsResult(DownloadProtectionService::UNKNOWN));
 }
 
 namespace {
 
 std::unique_ptr<net::FakeURLFetcher> FakeURLFetcherCreatorFunc(
@@ skipping 38 matching lines @@
   base::FilePath default_file_path(FILE_PATH_LITERAL("/foo/bar/test.crx"));
   std::vector<base::FilePath::StringType> alternate_extensions{
       FILE_PATH_LITERAL(".txt"), FILE_PATH_LITERAL(".abc"),
       FILE_PATH_LITERAL(""), FILE_PATH_LITERAL(".sdF")};
   EXPECT_CALL(*sb_service_->mock_database_manager(),
               MatchDownloadWhitelistUrl(_))
       .WillRepeatedly(Return(false));
   PrepareResponse(&factory, ClientDownloadResponse::SAFE, net::HTTP_OK,
                   net::URLRequestStatus::SUCCESS);
   const GURL kRequestorUrl("http://example.com/foo");
+  SetExtendedReportingPreference(false);
   download_service_->CheckPPAPIDownloadRequest(
-      kRequestorUrl, default_file_path, alternate_extensions,
+      kRequestorUrl, default_file_path, alternate_extensions, profile_.get(),
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
   MessageLoop::current()->Run();
 
   ASSERT_FALSE(upload_data.empty());
 
   ClientDownloadRequest request;
   ASSERT_TRUE(request.ParseFromString(upload_data));
 
   EXPECT_EQ(ClientDownloadRequest::PPAPI_SAVE_REQUEST, request.download_type());
@@ skipping 80 matching lines @@
       &item, base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                         base::Unretained(this)));
   MessageLoop::current()->Run();
 
   EXPECT_FALSE(HasClientDownloadRequest());
   // Overriden by flag:
   EXPECT_TRUE(IsResult(DownloadProtectionService::DANGEROUS));
 }
 
 }  // namespace safe_browsing