Implement safebrowsing download feedback service, enabled for dev & canary only.

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 <map>
 #include <string>
 
 #include "base/base_paths.h"
 #include "base/bind.h"
 #include "base/callback.h"
+#include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "chrome/browser/safe_browsing/database_manager.h"
+#include "chrome/browser/safe_browsing/download_feedback_service.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "chrome/browser/safe_browsing/signature_util.h"
+#include "chrome/common/chrome_switches.h"
 #include "chrome/common/safe_browsing/csd.pb.h"
 #include "content/public/test/mock_download_item.h"
 #include "content/public/test/test_browser_thread.h"
 #include "googleurl/src/gurl.h"
 #include "net/cert/x509_certificate.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/zlib/google/zip.h"
@@ skipping 104 matching lines @@
     check->url_results[i] = threat_type;
   BrowserThread::PostTask(BrowserThread::IO,
                           FROM_HERE,
                           base::Bind(&OnSafeBrowsingResult,
                                      base::Owned(check)));
 }
 
 class DownloadProtectionServiceTest : public testing::Test {
  protected:
   virtual void SetUp() {
+    CommandLine::ForCurrentProcess()->AppendSwitch(
+        switches::kSbEnableDownloadFeedback);
     ui_thread_.reset(new content::TestBrowserThread(BrowserThread::UI,
                                                     &msg_loop_));
     // Start real threads for the IO and File threads so that the DCHECKs
     // to test that we're on the correct thread work.
     io_thread_.reset(new content::TestBrowserThread(BrowserThread::IO));
     ASSERT_TRUE(io_thread_->Start());
     sb_service_ = new StrictMock<FakeSafeBrowsingService>();
     sb_service_->Initialize();
     signature_util_ = new StrictMock<MockSignatureUtil>();
     download_service_ = sb_service_->download_protection_service();
@@ skipping 319 matching lines @@
       DownloadProtectionService::GetDownloadRequestUrl(),
       response.SerializePartialAsString(),
       true);
 
   download_service_->CheckClientDownload(
       &item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
   msg_loop_.Run();
   EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
+  std::string feedback_ping;
+  std::string feedback_response;
+  EXPECT_FALSE(DownloadFeedbackService::GetPingsForDownloadForTesting(
+      item, &feedback_ping, &feedback_response));
 
   // If the response is dangerous the result should also be marked as dangerous.
   response.set_verdict(ClientDownloadResponse::DANGEROUS);
   factory.SetFakeResponse(
       DownloadProtectionService::GetDownloadRequestUrl(),
       response.SerializeAsString(),
       true);
 
   download_service_->CheckClientDownload(
       &item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
   msg_loop_.Run();
+  EXPECT_FALSE(DownloadFeedbackService::GetPingsForDownloadForTesting(
+      item, &feedback_ping, &feedback_response));
 #if defined(OS_WIN)
   EXPECT_TRUE(IsResult(DownloadProtectionService::DANGEROUS));
 #else
   EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
 #endif
 
   // If the response is uncommon the result should also be marked as uncommon.
   response.set_verdict(ClientDownloadResponse::UNCOMMON);
   factory.SetFakeResponse(
       DownloadProtectionService::GetDownloadRequestUrl(),
       response.SerializeAsString(),
       true);
 
   download_service_->CheckClientDownload(
       &item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
   msg_loop_.Run();
 #if defined(OS_WIN)
   EXPECT_TRUE(IsResult(DownloadProtectionService::UNCOMMON));
+  EXPECT_TRUE(DownloadFeedbackService::GetPingsForDownloadForTesting(
+      item, &feedback_ping, &feedback_response));
+  ClientDownloadRequest decoded_request;
+  EXPECT_TRUE(decoded_request.ParseFromString(feedback_ping));
+  EXPECT_EQ(url_chain.back().spec(), decoded_request.url());
+  EXPECT_EQ(response.SerializeAsString(), feedback_response);
 #else
   EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
 #endif
 
   // If the response is dangerous_host the result should also be marked as
   // dangerous_host.
   response.set_verdict(ClientDownloadResponse::DANGEROUS_HOST);
   factory.SetFakeResponse(
       DownloadProtectionService::GetDownloadRequestUrl(),
       response.SerializeAsString(),
       true);
 
   download_service_->CheckClientDownload(
       &item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
   msg_loop_.Run();
 #if defined(OS_WIN)
   EXPECT_TRUE(IsResult(DownloadProtectionService::DANGEROUS_HOST));
+  EXPECT_TRUE(DownloadFeedbackService::GetPingsForDownloadForTesting(
+      item, &feedback_ping, &feedback_response));
+  EXPECT_EQ(response.SerializeAsString(), feedback_response);
 #else
   EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
 #endif
 }
 
 TEST_F(DownloadProtectionServiceTest, CheckClientDownloadHTTPS) {
   ClientDownloadResponse response;
   response.set_verdict(ClientDownloadResponse::DANGEROUS);
   net::FakeURLFetcherFactory factory(NULL);
   factory.SetFakeResponse(
@@ skipping 580 matching lines @@
   EXPECT_THAT(whitelist_strings, ElementsAre(cert_base + "/OU=unit"));
 
   cert = ReadTestCertificate("test_c.pem");
   ASSERT_TRUE(cert.get());
   whitelist_strings.clear();
   GetCertificateWhitelistStrings(
       *cert.get(), *issuer_cert.get(), &whitelist_strings);
   EXPECT_THAT(whitelist_strings, ElementsAre());
 }
 }  // namespace safe_browsing