Use a temp directory for the temporary files that the tests create.

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 252 matching lines @@
         .AppendASCII("test")
         .AppendASCII("data")
         .AppendASCII("safe_browsing")
         .AppendASCII("download_protection");
 
     // Setup a profile
     ASSERT_TRUE(profile_dir_.CreateUniqueTempDir());
     profile_.reset(new TestingProfile(profile_dir_.path()));
     ASSERT_TRUE(profile_->CreateHistoryService(true /* delete_file */,
                                                false /* no_db */));
+
+    // Setup a directory to place test files in.
+    ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
   }
 
   void TearDown() override {
     client_download_request_subscription_.reset();
     sb_service_->ShutDown();
     // Flush all of the thread message loops to ensure that there are no
     // tasks currently running.
     FlushThreadMessageLoops();
     sb_service_ = NULL;
   }
@@ skipping 95 matching lines @@
         response.SerializeAsString(),
         response_code, status);
   }
 
   void PrepareBasicDownloadItem(
       content::MockDownloadItem* item,
       const std::vector<std::string> url_chain_items,
       const std::string& referrer_url,
       const base::FilePath::StringType& tmp_path_literal,
       const base::FilePath::StringType& final_path_literal) {
+    base::FilePath tmp_path = temp_dir_.path().Append(tmp_path_literal);
+    base::FilePath final_path = temp_dir_.path().Append(final_path_literal);
+
+    PrepareBasicDownloadItemWithFullPaths(item, url_chain_items, referrer_url,
+      tmp_path, final_path);
+  }
+
+  void PrepareBasicDownloadItemWithFullPaths(
+      content::MockDownloadItem* item,
+      const std::vector<std::string> url_chain_items,
+      const std::string& referrer_url,
+      const base::FilePath& tmp_full_path,
+      const base::FilePath& final_full_path) {
     url_chain_.clear();
     for (std::string item: url_chain_items)
       url_chain_.push_back(GURL(item));
     referrer_ = GURL(referrer_url);
-    tmp_path_ = base::FilePath(
-        base::FilePath::StringPieceType(tmp_path_literal));
-    final_path_ = base::FilePath(
-        base::FilePath::StringPieceType(final_path_literal));
+    tmp_path_ = tmp_full_path;
+    final_path_ = final_full_path;
     hash_ = "hash";
 
     EXPECT_CALL(*item, GetFullPath()).WillRepeatedly(ReturnRef(tmp_path_));
     EXPECT_CALL(*item, GetTargetFilePath())
         .WillRepeatedly(ReturnRef(final_path_));
     EXPECT_CALL(*item, GetUrlChain()).WillRepeatedly(ReturnRef(url_chain_));
     EXPECT_CALL(*item, GetReferrerUrl()).WillRepeatedly(ReturnRef(referrer_));
     EXPECT_CALL(*item, GetTabUrl())
         .WillRepeatedly(ReturnRef(GURL::EmptyGURL()));
     EXPECT_CALL(*item, GetTabReferrerUrl())
@@ skipping 97 matching lines @@
   std::unique_ptr<ClientDownloadRequest> last_client_download_request_;
   base::ScopedTempDir profile_dir_;
   std::unique_ptr<TestingProfile> profile_;
   // The following 5 fields are used by PrepareBasicDownloadItem() function to
   // store attributes of the last download item.
   std::vector<GURL> url_chain_;
   GURL referrer_;
   base::FilePath tmp_path_;
   base::FilePath final_path_;
   std::string hash_;
+  base::ScopedTempDir temp_dir_;
 };
 
 
 void DownloadProtectionServiceTest::CheckClientDownloadReportCorruptZip(
     bool is_extended_reporting,
     bool is_incognito) {
   net::FakeURLFetcherFactory factory(NULL);
   PrepareResponse(
       &factory, ClientDownloadResponse::SAFE, net::HTTP_OK,
       net::URLRequestStatus::SUCCESS);
@@ skipping 35 matching lines @@
     EXPECT_EQ(ClientDownloadRequest_DownloadType_INVALID_ZIP,
               GetClientDownloadRequest()->download_type());
     ClearClientDownloadRequest();
   } else {
     EXPECT_TRUE(IsResult(DownloadProtectionService::UNKNOWN));
     EXPECT_FALSE(HasClientDownloadRequest());
   }
 
   Mock::VerifyAndClearExpectations(sb_service_.get());
   Mock::VerifyAndClearExpectations(binary_feature_extractor_.get());
-
-  base::DeleteFile(tmp_path_, false);
 }
 
 
 TEST_F(DownloadProtectionServiceTest, CheckClientDownloadInvalidUrl) {
   content::MockDownloadItem item;
   PrepareBasicDownloadItem(
     &item,
     std::vector<std::string>(),   // empty url_chain
     "http://www.google.com/",     // referrer
     FILE_PATH_LITERAL("a.tmp"),   // tmp_path
@@ skipping 616 matching lines @@
                         base::Unretained(this)));
   MessageLoop::current()->Run();
 
   ASSERT_TRUE(HasClientDownloadRequest());
   EXPECT_EQ(0, GetClientDownloadRequest()->archived_binary_size());
   EXPECT_TRUE(GetClientDownloadRequest()->has_download_type());
   EXPECT_EQ(ClientDownloadRequest_DownloadType_ZIPPED_ARCHIVE,
             GetClientDownloadRequest()->download_type());
   ClearClientDownloadRequest();
   Mock::VerifyAndClearExpectations(binary_feature_extractor_.get());
-
-  base::DeleteFile(tmp_path_, false);
 }
 
 TEST_F(DownloadProtectionServiceTest,
        CheckClientDownloadReportCorruptZipNormal) {
   // !is_extended_reporting && !is_incognito
   CheckClientDownloadReportCorruptZip(false, false);
 }
 
 TEST_F(DownloadProtectionServiceTest,
        CheckClientDownloadReportCorruptZipExtended) {
@@ skipping 677 matching lines @@
   // Overriden by flag:
   EXPECT_TRUE(IsResult(DownloadProtectionService::DANGEROUS));
 }
 
 // Test a real .zip with a real .exe in it, where the .exe is manually
 // blacklisted by hash.
 TEST_F(DownloadProtectionServiceFlagTest,
        CheckClientDownloadZipOverridenByFlag) {
   content::MockDownloadItem item;
 
-  PrepareBasicDownloadItem(
-    &item,
-    {"http://www.evil.com/a.exe"},                   // url_chain
-    "http://www.google.com/",                        // referrer
-    testdata_path_.AppendASCII(
-        "zipfile_one_unsigned_binary.zip").value(),  // tmp_path
-    FILE_PATH_LITERAL("a.zip"));                     // final_path
+  PrepareBasicDownloadItemWithFullPaths(
+      &item, {"http://www.evil.com/a.exe"},  // url_chain
+      "http://www.google.com/",              // referrer
+      testdata_path_.AppendASCII(
+          "zipfile_one_unsigned_binary.zip"),                // tmp_path
+      temp_dir_.path().Append(FILE_PATH_LITERAL("a.zip")));  // final_path
 
   EXPECT_CALL(*sb_service_->mock_database_manager(),
               MatchDownloadWhitelistUrl(_))
       .WillRepeatedly(Return(false));
 
   download_service_->CheckClientDownload(
       &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