c/browser, c/common, components S-W: Change ScopedTempDir::path() to GetPath()

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 260 matching lines @@
     ASSERT_TRUE(PathService::Get(base::DIR_SOURCE_ROOT, &source_path));
     testdata_path_ = source_path
         .AppendASCII("chrome")
         .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()));
+    profile_.reset(new TestingProfile(profile_dir_.GetPath()));
     ASSERT_TRUE(profile_->CreateHistoryService(true /* delete_file */,
                                                false /* no_db */));
 
     // Setup a directory to place test files in.
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
 
     // Turn off binary sampling by default.
     SetBinarySamplingProbability(0.0);
   }
 
@@ skipping 111 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);
+    base::FilePath tmp_path = temp_dir_.GetPath().Append(tmp_path_literal);
+    base::FilePath final_path = temp_dir_.GetPath().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,
@@ skipping 893 matching lines @@
     FILE_PATH_LITERAL("a.tmp"),     // tmp_path
     FILE_PATH_LITERAL("a.zip"));    // final_path
 
   // Write out a zip archive to the temporary file.
   base::ScopedTempDir zip_source_dir;
   ASSERT_TRUE(zip_source_dir.CreateUniqueTempDir());
   std::string file_contents = "dummy file";
   {
     // In this case, it only contains a text file.
     ASSERT_EQ(static_cast<int>(file_contents.size()),
-              base::WriteFile(
-                  zip_source_dir.path().Append(FILE_PATH_LITERAL("file.txt")),
-                  file_contents.data(), file_contents.size()));
-    ASSERT_TRUE(zip::Zip(zip_source_dir.path(), tmp_path_, false));
+              base::WriteFile(zip_source_dir.GetPath().Append(
+                                  FILE_PATH_LITERAL("file.txt")),
+                              file_contents.data(), file_contents.size()));
+    ASSERT_TRUE(zip::Zip(zip_source_dir.GetPath(), tmp_path_, false));
     RunLoop run_loop;
     download_service_->CheckClientDownload(
         &item, base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                           base::Unretained(this), run_loop.QuitClosure()));
     run_loop.Run();
     EXPECT_TRUE(IsResult(DownloadProtectionService::UNKNOWN));
     EXPECT_FALSE(HasClientDownloadRequest());
     Mock::VerifyAndClearExpectations(sb_service_.get());
     Mock::VerifyAndClearExpectations(binary_feature_extractor_.get());
   }
   {
     // Now check with an executable in the zip file as well.
     ASSERT_EQ(static_cast<int>(file_contents.size()),
-              base::WriteFile(
-                  zip_source_dir.path().Append(FILE_PATH_LITERAL("file.exe")),
-                  file_contents.data(), file_contents.size()));
-    ASSERT_TRUE(zip::Zip(zip_source_dir.path(), tmp_path_, false));
+              base::WriteFile(zip_source_dir.GetPath().Append(
+                                  FILE_PATH_LITERAL("file.exe")),
+                              file_contents.data(), file_contents.size()));
+    ASSERT_TRUE(zip::Zip(zip_source_dir.GetPath(), tmp_path_, false));
     EXPECT_CALL(*sb_service_->mock_database_manager(),
                 MatchDownloadWhitelistUrl(_))
         .WillRepeatedly(Return(false));
     RunLoop run_loop;
     download_service_->CheckClientDownload(
         &item, base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                           base::Unretained(this), run_loop.QuitClosure()));
     run_loop.Run();
     EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
     ASSERT_TRUE(HasClientDownloadRequest());
@@ skipping 24 matching lines @@
     run_loop.Run();
     EXPECT_TRUE(IsResult(DownloadProtectionService::DANGEROUS));
     EXPECT_TRUE(HasClientDownloadRequest());
     ClearClientDownloadRequest();
     Mock::VerifyAndClearExpectations(binary_feature_extractor_.get());
   }
   {
     // Repeat the test with an archive inside the zip file in addition to the
     // executable.
     ASSERT_EQ(static_cast<int>(file_contents.size()),
-              base::WriteFile(
-                  zip_source_dir.path().Append(FILE_PATH_LITERAL("file.rar")),
-                  file_contents.data(), file_contents.size()));
-    ASSERT_TRUE(zip::Zip(zip_source_dir.path(), tmp_path_, false));
+              base::WriteFile(zip_source_dir.GetPath().Append(
+                                  FILE_PATH_LITERAL("file.rar")),
+                              file_contents.data(), file_contents.size()));
+    ASSERT_TRUE(zip::Zip(zip_source_dir.GetPath(), tmp_path_, false));
     RunLoop run_loop;
     download_service_->CheckClientDownload(
         &item, base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                           base::Unretained(this), run_loop.QuitClosure()));
     run_loop.Run();
     ASSERT_TRUE(HasClientDownloadRequest());
     EXPECT_EQ(1, GetClientDownloadRequest()->archived_binary_size());
     EXPECT_TRUE(GetClientDownloadRequest()->has_download_type());
     EXPECT_EQ(ClientDownloadRequest_DownloadType_ZIPPED_EXECUTABLE,
               GetClientDownloadRequest()->download_type());
     ClearClientDownloadRequest();
     Mock::VerifyAndClearExpectations(binary_feature_extractor_.get());
   }
   {
     // Repeat the test with just the archive inside the zip file.
-    ASSERT_TRUE(
-        base::DeleteFile(zip_source_dir.path().AppendASCII("file.exe"), false));
-    ASSERT_TRUE(zip::Zip(zip_source_dir.path(), tmp_path_, false));
+    ASSERT_TRUE(base::DeleteFile(
+        zip_source_dir.GetPath().AppendASCII("file.exe"), false));
+    ASSERT_TRUE(zip::Zip(zip_source_dir.GetPath(), tmp_path_, false));
     RunLoop run_loop;
     download_service_->CheckClientDownload(
         &item, base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                           base::Unretained(this), run_loop.QuitClosure()));
     run_loop.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());
@@ skipping 920 matching lines @@
 // 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;
 
   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
+          "zipfile_one_unsigned_binary.zip"),                   // tmp_path
+      temp_dir_.GetPath().Append(FILE_PATH_LITERAL("a.zip")));  // final_path
 
   EXPECT_CALL(*sb_service_->mock_database_manager(),
               MatchDownloadWhitelistUrl(_))
       .WillRepeatedly(Return(false));
 
   RunLoop run_loop;
   download_service_->CheckClientDownload(
       &item, base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                         base::Unretained(this), run_loop.QuitClosure()));
   run_loop.Run();
 
   EXPECT_FALSE(HasClientDownloadRequest());
   // Overriden by flag:
   EXPECT_TRUE(IsResult(DownloadProtectionService::DANGEROUS));
 }
 
 }  // namespace safe_browsing