Move test_url_fetcher_factory.* from content/ to net/url_request

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/file_path.h"
 #include "base/file_util.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/scoped_temp_dir.h"
 #include "base/string_number_conversions.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "chrome/browser/safe_browsing/signature_util.h"
 #include "chrome/common/safe_browsing/csd.pb.h"
 #include "chrome/common/zip.h"
 #include "content/public/browser/download_item.h"
 #include "content/public/test/test_browser_thread.h"
-#include "content/public/test/test_url_fetcher_factory.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/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"
 
 using ::testing::ContainerEq;
 using ::testing::DoAll;
 using ::testing::ElementsAre;
 using ::testing::Mock;
 using ::testing::NotNull;
 using ::testing::Return;
@@ skipping 202 matching lines @@
     msg_loop_.Run();
   }
 
  public:
   void CheckDoneCallback(
       DownloadProtectionService::DownloadCheckResult result) {
     result_.reset(new DownloadProtectionService::DownloadCheckResult(result));
     msg_loop_.Quit();
   }
 
-  void SendURLFetchComplete(TestURLFetcher* fetcher) {
+  void SendURLFetchComplete(net::TestURLFetcher* fetcher) {
     fetcher->delegate()->OnURLFetchComplete(fetcher);
   }
 
   void ExpectResult(DownloadProtectionService::DownloadCheckResult expected) {
     ASSERT_TRUE(result_.get());
     EXPECT_EQ(expected, *result_);
   }
 
  protected:
   scoped_refptr<MockSafeBrowsingService> sb_service_;
@@ skipping 53 matching lines @@
   info.referrer_url = GURL("http://www.google.com/a.exe");
   download_service_->CheckClientDownload(
       info,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
   msg_loop_.Run();
   ExpectResult(DownloadProtectionService::SAFE);
 }
 
 TEST_F(DownloadProtectionServiceTest, CheckClientDownloadFetchFailed) {
-  FakeURLFetcherFactory factory;
+  net::FakeURLFetcherFactory factory;
   // HTTP request will fail.
   factory.SetFakeResponse(
       DownloadProtectionService::kDownloadRequestUrl, "", false);
 
   DownloadProtectionService::DownloadInfo info;
   info.local_file = FilePath(FILE_PATH_LITERAL("a.tmp"));
   info.target_file = FilePath(FILE_PATH_LITERAL("a.exe"));
   info.download_url_chain.push_back(GURL("http://www.evil.com/a.exe"));
   info.referrer_url = GURL("http://www.google.com/");
 
   EXPECT_CALL(*sb_service_, MatchDownloadWhitelistUrl(_))
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*signature_util_, CheckSignature(info.local_file, _));
 
   download_service_->CheckClientDownload(
       info,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
   msg_loop_.Run();
   ExpectResult(DownloadProtectionService::SAFE);
 }
 
 TEST_F(DownloadProtectionServiceTest, CheckClientDownloadSuccess) {
   ClientDownloadResponse response;
   response.set_verdict(ClientDownloadResponse::SAFE);
-  FakeURLFetcherFactory factory;
+  net::FakeURLFetcherFactory factory;
   // Empty response means SAFE.
   factory.SetFakeResponse(
       DownloadProtectionService::kDownloadRequestUrl,
       response.SerializeAsString(),
       true);
 
   DownloadProtectionService::DownloadInfo info;
   info.local_file = FilePath(FILE_PATH_LITERAL("a.tmp"));
   info.target_file = FilePath(FILE_PATH_LITERAL("a.exe"));
   info.download_url_chain.push_back(GURL("http://www.evil.com/a.exe"));
@@ skipping 57 matching lines @@
 #if defined(OS_WIN)
   ExpectResult(DownloadProtectionService::UNCOMMON);
 #else
   ExpectResult(DownloadProtectionService::SAFE);
 #endif
 }
 
 TEST_F(DownloadProtectionServiceTest, CheckClientDownloadHTTPS) {
   ClientDownloadResponse response;
   response.set_verdict(ClientDownloadResponse::DANGEROUS);
-  FakeURLFetcherFactory factory;
+  net::FakeURLFetcherFactory factory;
   factory.SetFakeResponse(
       DownloadProtectionService::kDownloadRequestUrl,
       response.SerializeAsString(),
       true);
 
   DownloadProtectionService::DownloadInfo info;
   info.local_file = FilePath(FILE_PATH_LITERAL("a.tmp"));
   info.target_file = FilePath(FILE_PATH_LITERAL("a.exe"));
   info.download_url_chain.push_back(GURL("https://www.evil.com/a.exe"));
   info.referrer_url = GURL("http://www.google.com/");
@@ skipping 10 matching lines @@
 #if defined(OS_WIN)
   ExpectResult(DownloadProtectionService::DANGEROUS);
 #else
   ExpectResult(DownloadProtectionService::SAFE);
 #endif
 }
 
 TEST_F(DownloadProtectionServiceTest, CheckClientDownloadZip) {
   ClientDownloadResponse response;
   response.set_verdict(ClientDownloadResponse::SAFE);
-  FakeURLFetcherFactory factory;
+  net::FakeURLFetcherFactory factory;
   // Empty response means SAFE.
   factory.SetFakeResponse(
       DownloadProtectionService::kDownloadRequestUrl,
       response.SerializeAsString(),
       true);
 
   ScopedTempDir download_dir;
   ASSERT_TRUE(download_dir.CreateUniqueTempDir());
 
   DownloadProtectionService::DownloadInfo info;
@@ skipping 83 matching lines @@
   Mock::VerifyAndClearExpectations(sb_service_);
   Mock::VerifyAndClearExpectations(signature_util_);
 }
 
 TEST_F(DownloadProtectionServiceTest, CheckClientCrxDownloadSuccess) {
   ClientDownloadResponse response;
   // Even if the server verdict is dangerous we should return SAFE because
   // DownloadProtectionService::IsSupportedDownload() will return false
   // for crx downloads.
   response.set_verdict(ClientDownloadResponse::DANGEROUS);
-  FakeURLFetcherFactory factory;
+  net::FakeURLFetcherFactory factory;
   // Empty response means SAFE.
   factory.SetFakeResponse(
       DownloadProtectionService::kDownloadRequestUrl,
       response.SerializeAsString(),
       true);
 
   DownloadProtectionService::DownloadInfo info;
   info.local_file = FilePath(FILE_PATH_LITERAL("a.tmp"));
   info.target_file = FilePath(FILE_PATH_LITERAL("a.crx"));
   info.download_url_chain.push_back(GURL("http://www.evil.com/a.crx"));
   info.referrer_url = GURL("http://www.google.com/");
 
   EXPECT_CALL(*sb_service_, MatchDownloadWhitelistUrl(_))
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*signature_util_, CheckSignature(info.local_file, _)).Times(1);
 
   EXPECT_FALSE(download_service_->IsSupportedDownload(info));
   download_service_->CheckClientDownload(
       info,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
   msg_loop_.Run();
   ExpectResult(DownloadProtectionService::SAFE);
 }
 
 TEST_F(DownloadProtectionServiceTest, CheckClientDownloadValidateRequest) {
-  TestURLFetcherFactory factory;
+  net::TestURLFetcherFactory factory;
 
   DownloadProtectionService::DownloadInfo info;
   info.local_file = FilePath(FILE_PATH_LITERAL("bla.tmp"));
   info.target_file = FilePath(FILE_PATH_LITERAL("bla.exe"));
   info.download_url_chain.push_back(GURL("http://www.google.com/"));
   info.download_url_chain.push_back(GURL("http://www.google.com/bla.exe"));
   info.referrer_url = GURL("http://www.google.com/");
   info.sha256_hash = "hash";
   info.total_bytes = 100;
   info.user_initiated = true;
   info.remote_address = "10.11.12.13";
 
   EXPECT_CALL(*sb_service_, MatchDownloadWhitelistUrl(_))
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*signature_util_, CheckSignature(info.local_file, _))
       .WillOnce(SetCertificateContents("dummy cert data"));
   download_service_->CheckClientDownload(
       info,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
 
 #if !defined(OS_WIN)
   // SendRequest is not called.  Wait for FinishRequest to call our callback.
   msg_loop_.Run();
-  TestURLFetcher* fetcher = factory.GetFetcherByID(0);
+  net::TestURLFetcher* fetcher = factory.GetFetcherByID(0);
   EXPECT_EQ(NULL, fetcher);
 #else
   // Run the message loop(s) until SendRequest is called.
   FlushThreadMessageLoops();
-  TestURLFetcher* fetcher = factory.GetFetcherByID(0);
+  net::TestURLFetcher* fetcher = factory.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
   ClientDownloadRequest request;
   EXPECT_TRUE(request.ParseFromString(fetcher->upload_data()));
   EXPECT_EQ("http://www.google.com/bla.exe", request.url());
   EXPECT_EQ(info.sha256_hash, request.digests().sha256());
   EXPECT_EQ(info.total_bytes, request.length());
   EXPECT_EQ(info.user_initiated, request.user_initiated());
   EXPECT_TRUE(RequestContainsServerIp(request, info.remote_address));
   EXPECT_EQ(2, request.resources_size());
   EXPECT_TRUE(RequestContainsResource(request,
@@ skipping 15 matching lines @@
       FROM_HERE,
       base::Bind(&DownloadProtectionServiceTest::SendURLFetchComplete,
                  base::Unretained(this), fetcher));
   msg_loop_.Run();
 #endif
 }
 
 // Similar to above, but with an unsigned binary.
 TEST_F(DownloadProtectionServiceTest,
        CheckClientDownloadValidateRequestNoSignature) {
-  TestURLFetcherFactory factory;
+  net::TestURLFetcherFactory factory;
 
   DownloadProtectionService::DownloadInfo info;
   info.local_file = FilePath(FILE_PATH_LITERAL("bla.tmp"));
   info.target_file = FilePath(FILE_PATH_LITERAL("bla.exe"));
   info.download_url_chain.push_back(GURL("http://www.google.com/"));
   info.download_url_chain.push_back(GURL("ftp://www.google.com/bla.exe"));
   info.referrer_url = GURL("http://www.google.com/");
   info.sha256_hash = "hash";
   info.total_bytes = 100;
   info.user_initiated = false;
 
   EXPECT_CALL(*sb_service_, MatchDownloadWhitelistUrl(_))
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*signature_util_, CheckSignature(info.local_file, _));
   download_service_->CheckClientDownload(
       info,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
 
 #if !defined(OS_WIN)
   // SendRequest is not called.  Wait for FinishRequest to call our callback.
   msg_loop_.Run();
-  TestURLFetcher* fetcher = factory.GetFetcherByID(0);
+  net::TestURLFetcher* fetcher = factory.GetFetcherByID(0);
   EXPECT_EQ(NULL, fetcher);
 #else
   // Run the message loop(s) until SendRequest is called.
   FlushThreadMessageLoops();
-  TestURLFetcher* fetcher = factory.GetFetcherByID(0);
+  net::TestURLFetcher* fetcher = factory.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
   ClientDownloadRequest request;
   EXPECT_TRUE(request.ParseFromString(fetcher->upload_data()));
   EXPECT_EQ("ftp://www.google.com/bla.exe", request.url());
   EXPECT_EQ(info.sha256_hash, request.digests().sha256());
   EXPECT_EQ(info.total_bytes, request.length());
   EXPECT_EQ(info.user_initiated, request.user_initiated());
   EXPECT_EQ(2, request.resources_size());
   EXPECT_TRUE(RequestContainsResource(request,
                                       ClientDownloadRequest::DOWNLOAD_REDIRECT,
@@ skipping 70 matching lines @@
           Return(false)));
   download_service_->CheckDownloadUrl(
       info,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
   msg_loop_.Run();
   ExpectResult(DownloadProtectionService::DANGEROUS);
 }
 
 TEST_F(DownloadProtectionServiceTest, TestDownloadRequestTimeout) {
-  TestURLFetcherFactory factory;
+  net::TestURLFetcherFactory factory;
 
   DownloadProtectionService::DownloadInfo info;
   info.download_url_chain.push_back(GURL("http://www.evil.com/bla.exe"));
   info.referrer_url = GURL("http://www.google.com/");
   info.local_file = FilePath(FILE_PATH_LITERAL("a.tmp"));
   info.target_file = FilePath(FILE_PATH_LITERAL("a.exe"));
 
   EXPECT_CALL(*sb_service_, MatchDownloadWhitelistUrl(_))
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*signature_util_, CheckSignature(info.local_file, _));
@@ skipping 81 matching lines @@
   GetCertificateWhitelistStrings(*cert, *issuer_cert, &whitelist_strings);
   EXPECT_THAT(whitelist_strings, ElementsAre(cert_base + "/OU=unit"));
 
   cert = ReadTestCertificate("test_c.pem");
   ASSERT_TRUE(cert.get());
   whitelist_strings.clear();
   GetCertificateWhitelistStrings(*cert, *issuer_cert, &whitelist_strings);
   EXPECT_THAT(whitelist_strings, ElementsAre());
 }
 }  // namespace safe_browsing