Allow Safe Browsing backend to select downloads to upload.

chrome/browser/safe_browsing/download_feedback_service_unittest.cc

 // Copyright 2013 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_feedback_service.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <vector>
@@ skipping 95 matching lines @@
 
   size_t num_feedbacks() const {
     return feedbacks_.size();
   }
 
  private:
   std::vector<FakeDownloadFeedback*> feedbacks_;
 };
 
 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);
 }
 
 }  // namespace
 
 class DownloadFeedbackServiceTest : public testing::Test {
  public:
   DownloadFeedbackServiceTest()
       : file_task_runner_(content::BrowserThread::GetTaskRunnerForThread(
             content::BrowserThread::FILE)),
@@ skipping 33 matching lines @@
   scoped_refptr<base::SingleThreadTaskRunner> file_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
   scoped_refptr<net::TestURLRequestContextGetter> request_context_getter_;
   FakeDownloadFeedbackFactory download_feedback_factory_;
 };
 
 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));
+  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_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));
+    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) {
   const base::FilePath file_path(CreateTestFile(0));
   const std::string ping_request = "ping";
   const std::string ping_response = "resp";
 
   content::DownloadItem::AcquireFileCallback download_discarded_callback;
 
   content::MockDownloadItem item;
   EXPECT_CALL(item, GetDangerType())
       .WillRepeatedly(Return(content::DOWNLOAD_DANGER_TYPE_UNCOMMON_CONTENT));
   EXPECT_CALL(item, GetReceivedBytes()).WillRepeatedly(Return(1000));
   EXPECT_CALL(item,
               StealDangerousDownload(true /*delete_file_after_feedback*/, _))
       .WillOnce(SaveArg<1>(&download_discarded_callback));
 
   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());
   EXPECT_EQ(0U, num_feedbacks());
 
   download_discarded_callback.Run(file_path);
   ASSERT_EQ(1U, num_feedbacks());
   ASSERT_TRUE(feedback(0));
   EXPECT_TRUE(feedback(0)->start_called());
   EXPECT_EQ(ping_request, feedback(0)->GetPingRequestForTesting());
@@ skipping 19 matching lines @@
   EXPECT_CALL(item, GetReceivedBytes()).WillRepeatedly(Return(1000));
   EXPECT_CALL(item,
               StealDangerousDownload(false /*delete_file_after_feedback*/, _))
       .WillOnce(SaveArg<1>(&download_discarded_callback));
   EXPECT_CALL(item, ValidateDangerousDownload()).Times(1);
   GURL empty_url;
   EXPECT_CALL(item, GetURL()).WillOnce(ReturnRef(empty_url));
 
   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);
   ASSERT_FALSE(download_discarded_callback.is_null());
   EXPECT_EQ(0U, num_feedbacks());
 
   download_discarded_callback.Run(file_path);
   ASSERT_EQ(1U, num_feedbacks());
   ASSERT_TRUE(feedback(0));
   EXPECT_TRUE(feedback(0)->start_called());
@@ skipping 18 matching lines @@
   base::FilePath file_path[kNumDownloads];
   content::MockDownloadItem item[kNumDownloads];
   for (size_t i = 0; i < kNumDownloads; ++i) {
     file_path[i] = CreateTestFile(i);
     EXPECT_CALL(item[i], GetDangerType())
         .WillRepeatedly(Return(content::DOWNLOAD_DANGER_TYPE_UNCOMMON_CONTENT));
     EXPECT_CALL(item[i], GetReceivedBytes()).WillRepeatedly(Return(1000));
     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]));
   }
 
   {
     DownloadFeedbackService service(request_context_getter_.get(),
                                     file_task_runner_.get());
     for (size_t i = 0; i < kNumDownloads; ++i) {
       SCOPED_TRACE(i);
       service.BeginFeedbackForDownload(&item[i], DownloadCommands::DISCARD);
       ASSERT_FALSE(download_discarded_callback[i].is_null());
@@ skipping 47 matching lines @@
   base::FilePath file_path[kNumDownloads];
   content::MockDownloadItem item[kNumDownloads];
   for (size_t i = 0; i < kNumDownloads; ++i) {
     file_path[i] = CreateTestFile(i);
     EXPECT_CALL(item[i], GetDangerType())
         .WillRepeatedly(Return(content::DOWNLOAD_DANGER_TYPE_UNCOMMON_CONTENT));
     EXPECT_CALL(item[i], GetReceivedBytes()).WillRepeatedly(Return(1000));
     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]));
   }
 
   {
     DownloadFeedbackService service(request_context_getter_.get(),
                                     file_task_runner_.get());
     for (size_t i = 0; i < kNumDownloads; ++i) {
       SCOPED_TRACE(i);
       service.BeginFeedbackForDownload(&item[i], DownloadCommands::DISCARD);
       ASSERT_FALSE(download_discarded_callback[i].is_null());
@@ skipping 34 matching lines @@
   // was deleted.
   EXPECT_FALSE(base::PathExists(file_path[2]));
 
   // These files should still exist since the FakeDownloadFeedback does not
   // delete them.
   EXPECT_TRUE(base::PathExists(file_path[0]));
   EXPECT_TRUE(base::PathExists(file_path[1]));
 }
 
 }  // namespace safe_browsing