Allow Safe Browsing backend to select downloads to upload.

chrome/browser/safe_browsing/download_feedback_service_unittest.cc

Index: chrome/browser/safe_browsing/download_feedback_service_unittest.cc
diff --git a/chrome/browser/safe_browsing/download_feedback_service_unittest.cc b/chrome/browser/safe_browsing/download_feedback_service_unittest.cc
index c4cdd8247865841e5211ef6bab8b47b39b0f6b6b..680f51153d97fdd28869d324695126c688c25c45 100644
--- a/chrome/browser/safe_browsing/download_feedback_service_unittest.cc
+++ b/chrome/browser/safe_browsing/download_feedback_service_unittest.cc
@@ -113,12 +113,14 @@ class FakeDownloadFeedbackFactory : public DownloadFeedbackFactory {
 };
 
 bool WillStorePings(DownloadProtectionService::DownloadCheckResult result,
+                    bool upload_requested,
                     int64_t size) {
   content::MockDownloadItem item;
   EXPECT_CALL(item, GetReceivedBytes()).WillRepeatedly(Return(size));
 
   EXPECT_FALSE(DownloadFeedbackService::IsEnabledForDownload(item));
-  DownloadFeedbackService::MaybeStorePingsForDownload(result, &item, "a", "b");
+  DownloadFeedbackService::MaybeStorePingsForDownload(result, upload_requested,
+                                                      &item, "a", "b");
   return DownloadFeedbackService::IsEnabledForDownload(item);
 }
 
@@ -172,21 +174,34 @@ TEST_F(DownloadFeedbackServiceTest, MaybeStorePingsForDownload) {
   const int64_t ok_size = DownloadFeedback::kMaxUploadSize;
   const int64_t bad_size = DownloadFeedback::kMaxUploadSize + 1;
 
-  EXPECT_FALSE(WillStorePings(DownloadProtectionService::SAFE, ok_size));
-  EXPECT_FALSE(WillStorePings(DownloadProtectionService::DANGEROUS, ok_size));
-  EXPECT_TRUE(WillStorePings(DownloadProtectionService::UNCOMMON, ok_size));
-  EXPECT_TRUE(
-      WillStorePings(DownloadProtectionService::DANGEROUS_HOST, ok_size));
-  EXPECT_TRUE(
-      WillStorePings(DownloadProtectionService::POTENTIALLY_UNWANTED, ok_size));
-
-  EXPECT_FALSE(WillStorePings(DownloadProtectionService::SAFE, bad_size));
-  EXPECT_FALSE(WillStorePings(DownloadProtectionService::DANGEROUS, bad_size));
-  EXPECT_FALSE(WillStorePings(DownloadProtectionService::UNCOMMON, bad_size));
-  EXPECT_FALSE(
-      WillStorePings(DownloadProtectionService::DANGEROUS_HOST, bad_size));
-  EXPECT_FALSE(WillStorePings(DownloadProtectionService::POTENTIALLY_UNWANTED,
-                              bad_size));
+  std::vector<bool> upload_requests = {false, true};
+  for (bool request_upload : upload_requests) {
+    // SAFE and DANGEROUS will only upload if |request_upload|
+    EXPECT_EQ(request_upload, WillStorePings(DownloadProtectionService::SAFE,
+                                             request_upload, ok_size));
+    EXPECT_EQ(request_upload,
+              WillStorePings(DownloadProtectionService::DANGEROUS,
+                             request_upload, ok_size));
+
+    EXPECT_TRUE(WillStorePings(DownloadProtectionService::UNCOMMON,
+                               request_upload, ok_size));
+    EXPECT_TRUE(WillStorePings(DownloadProtectionService::DANGEROUS_HOST,
+                               request_upload, ok_size));
+    EXPECT_TRUE(WillStorePings(DownloadProtectionService::POTENTIALLY_UNWANTED,
+                               request_upload, ok_size));
+
+    // Bad sizes never upload
+    EXPECT_FALSE(WillStorePings(DownloadProtectionService::SAFE, request_upload,
+                                bad_size));
+    EXPECT_FALSE(WillStorePings(DownloadProtectionService::DANGEROUS,
+                                request_upload, bad_size));
+    EXPECT_FALSE(WillStorePings(DownloadProtectionService::UNCOMMON,
+                                request_upload, bad_size));
+    EXPECT_FALSE(WillStorePings(DownloadProtectionService::DANGEROUS_HOST,
+                                request_upload, bad_size));
+    EXPECT_FALSE(WillStorePings(DownloadProtectionService::POTENTIALLY_UNWANTED,
+                                request_upload, bad_size));
+  }
 }
 
 TEST_F(DownloadFeedbackServiceTest, SingleFeedbackCompleteAndDiscardDownload) {
@@ -206,8 +221,9 @@ TEST_F(DownloadFeedbackServiceTest, SingleFeedbackCompleteAndDiscardDownload) {
 
   DownloadFeedbackService service(request_context_getter_.get(),
                                   file_task_runner_.get());
-  service.MaybeStorePingsForDownload(
-      DownloadProtectionService::UNCOMMON, &item, ping_request, ping_response);
+  service.MaybeStorePingsForDownload(DownloadProtectionService::UNCOMMON,
+                                     false /* upload_requested */, &item,
+                                     ping_request, ping_response);
   ASSERT_TRUE(DownloadFeedbackService::IsEnabledForDownload(item));
   service.BeginFeedbackForDownload(&item, DownloadCommands::DISCARD);
   ASSERT_FALSE(download_discarded_callback.is_null());
@@ -247,7 +263,8 @@ TEST_F(DownloadFeedbackServiceTest, SingleFeedbackCompleteAndKeepDownload) {
 
   DownloadFeedbackService service(request_context_getter_.get(),
                                   file_task_runner_.get());
-  service.MaybeStorePingsForDownload(DownloadProtectionService::UNCOMMON, &item,
+  service.MaybeStorePingsForDownload(DownloadProtectionService::UNCOMMON,
+                                     false /* upload_requested */, &item,
                                      ping_request, ping_response);
   ASSERT_TRUE(DownloadFeedbackService::IsEnabledForDownload(item));
   service.BeginFeedbackForDownload(&item, DownloadCommands::KEEP);
@@ -286,8 +303,8 @@ TEST_F(DownloadFeedbackServiceTest, MultiplePendingFeedbackComplete) {
     EXPECT_CALL(item[i], StealDangerousDownload(true, _))
         .WillOnce(SaveArg<1>(&download_discarded_callback[i]));
     DownloadFeedbackService::MaybeStorePingsForDownload(
-        DownloadProtectionService::UNCOMMON, &item[i], ping_request,
-        ping_response);
+        DownloadProtectionService::UNCOMMON, false /* upload_requested */,
+        &item[i], ping_request, ping_response);
     ASSERT_TRUE(DownloadFeedbackService::IsEnabledForDownload(item[i]));
   }
 
@@ -355,8 +372,8 @@ TEST_F(DownloadFeedbackServiceTest, MultiFeedbackWithIncomplete) {
     EXPECT_CALL(item[i], StealDangerousDownload(true, _))
         .WillOnce(SaveArg<1>(&download_discarded_callback[i]));
     DownloadFeedbackService::MaybeStorePingsForDownload(
-        DownloadProtectionService::UNCOMMON, &item[i], ping_request,
-        ping_response);
+        DownloadProtectionService::UNCOMMON, false /* upload_requested */,
+        &item[i], ping_request, ping_response);
     ASSERT_TRUE(DownloadFeedbackService::IsEnabledForDownload(item[i]));
   }