Renaming zip_analyzer_results to archive_analyzer_results

chrome/browser/safe_browsing/sandboxed_zip_analyzer_unittest.cc

 // Copyright 2015 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/sandboxed_zip_analyzer.h"
 
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_path.h"
 #include "base/macros.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "build/build_config.h"
 #include "chrome/common/chrome_paths.h"
-#include "chrome/common/safe_browsing/zip_analyzer_results.h"
+#include "chrome/common/safe_browsing/archive_analyzer_results.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/public/test/test_utils.h"
 #include "crypto/sha2.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace safe_browsing {
 
 class SandboxedZipAnalyzerTest : public ::testing::Test {
  protected:
   // Constants for validating the data reported by the analyzer.
   struct BinaryData {
     const char* file_basename;
     ClientDownloadRequest_DownloadType download_type;
     const uint8_t* sha256_digest;
     int64_t length;
     bool is_signed;
   };
 
   // A helper that provides a SandboxedZipAnalyzer::ResultCallback that will
   // store a copy of an analyzer's results and then run a closure.
   class ResultsGetter {
    public:
     ResultsGetter(const base::Closure& quit_closure,
-                  zip_analyzer::Results* results)
-        : quit_closure_(quit_closure),
-          results_(results) {
+                  ArchiveAnalyzerResults* results)
+        : quit_closure_(quit_closure), results_(results) {
       DCHECK(results);
       results->success = false;
     }
 
     SandboxedZipAnalyzer::ResultCallback GetCallback() {
       return base::Bind(&ResultsGetter::OnZipAnalyzerResults,
                         base::Unretained(this));
     }
 
    private:
-    void OnZipAnalyzerResults(const zip_analyzer::Results& results) {
+    void OnZipAnalyzerResults(const ArchiveAnalyzerResults& results) {
       *results_ = results;
       quit_closure_.Run();
     }
 
     base::Closure quit_closure_;
-    zip_analyzer::Results* results_;
+    ArchiveAnalyzerResults* results_;
     DISALLOW_COPY_AND_ASSIGN(ResultsGetter);
   };
 
   SandboxedZipAnalyzerTest()
       : browser_thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP) {}
 
   void SetUp() override {
     ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &dir_test_data_));
     dir_test_data_ = dir_test_data_.AppendASCII("safe_browsing");
     dir_test_data_ = dir_test_data_.AppendASCII("download_protection");
   }
 
   // Runs a sandboxed zip analyzer on |file_path|, writing its results into
   // |results|.
   void RunAnalyzer(const base::FilePath& file_path,
-                   zip_analyzer::Results* results) {
+                   ArchiveAnalyzerResults* results) {
     DCHECK(results);
     base::RunLoop run_loop;
     ResultsGetter results_getter(run_loop.QuitClosure(), results);
     scoped_refptr<SandboxedZipAnalyzer> analyzer(
         new SandboxedZipAnalyzer(file_path, results_getter.GetCallback()));
     analyzer->Start();
     run_loop.Run();
   }
 
 #if defined(OS_WIN)
@@ skipping 85 matching lines @@
 const SandboxedZipAnalyzerTest::BinaryData SandboxedZipAnalyzerTest::kJSEFile =
     {
         "hello.jse",
         ClientDownloadRequest_DownloadType_WIN_EXECUTABLE,
         &kJSEFileDigest[0],
         6,
         false,  // is_signed
 };
 
 TEST_F(SandboxedZipAnalyzerTest, NoBinaries) {
-  zip_analyzer::Results results;
+  ArchiveAnalyzerResults results;
   RunAnalyzer(dir_test_data_.AppendASCII("zipfile_no_binaries.zip"), &results);
   ASSERT_TRUE(results.success);
   EXPECT_FALSE(results.has_executable);
   EXPECT_FALSE(results.has_archive);
   EXPECT_EQ(0, results.archived_binary.size());
 }
 
 TEST_F(SandboxedZipAnalyzerTest, OneUnsignedBinary) {
-  zip_analyzer::Results results;
+  ArchiveAnalyzerResults results;
   RunAnalyzer(dir_test_data_.AppendASCII("zipfile_one_unsigned_binary.zip"),
               &results);
   ASSERT_TRUE(results.success);
   EXPECT_TRUE(results.has_executable);
   EXPECT_FALSE(results.has_archive);
   ASSERT_EQ(1, results.archived_binary.size());
   ExpectBinary(kUnsignedExe, results.archived_binary.Get(0));
 }
 
 TEST_F(SandboxedZipAnalyzerTest, TwoBinariesOneSigned) {
-  zip_analyzer::Results results;
+  ArchiveAnalyzerResults results;
   RunAnalyzer(dir_test_data_.AppendASCII("zipfile_two_binaries_one_signed.zip"),
               &results);
   ASSERT_TRUE(results.success);
   EXPECT_TRUE(results.has_executable);
   EXPECT_FALSE(results.has_archive);
   ASSERT_EQ(2, results.archived_binary.size());
   ExpectBinary(kUnsignedExe, results.archived_binary.Get(0));
   ExpectBinary(kSignedExe, results.archived_binary.Get(1));
 }
 
 TEST_F(SandboxedZipAnalyzerTest, ZippedArchiveNoBinaries) {
-  zip_analyzer::Results results;
+  ArchiveAnalyzerResults results;
   RunAnalyzer(dir_test_data_.AppendASCII("zipfile_archive_no_binaries.zip"),
               &results);
   ASSERT_TRUE(results.success);
   EXPECT_FALSE(results.has_executable);
   EXPECT_TRUE(results.has_archive);
   EXPECT_EQ(0, results.archived_binary.size());
   ASSERT_EQ(1u, results.archived_archive_filenames.size());
   EXPECT_EQ(FILE_PATH_LITERAL("hello.zip"),
             results.archived_archive_filenames[0].value());
 }
 
 TEST_F(SandboxedZipAnalyzerTest, ZippedRarArchiveNoBinaries) {
-  zip_analyzer::Results results;
+  ArchiveAnalyzerResults results;
   RunAnalyzer(dir_test_data_.AppendASCII("zipfile_rar_archive_no_binaries.zip"),
               &results);
   ASSERT_TRUE(results.success);
   EXPECT_FALSE(results.has_executable);
   EXPECT_TRUE(results.has_archive);
   EXPECT_EQ(0, results.archived_binary.size());
   ASSERT_EQ(1u, results.archived_archive_filenames.size());
   EXPECT_EQ(FILE_PATH_LITERAL("hello.rar"),
             results.archived_archive_filenames[0].value());
 }
 
 TEST_F(SandboxedZipAnalyzerTest, ZippedArchiveAndBinaries) {
-  zip_analyzer::Results results;
+  ArchiveAnalyzerResults results;
   RunAnalyzer(dir_test_data_.AppendASCII("zipfile_archive_and_binaries.zip"),
               &results);
   ASSERT_TRUE(results.success);
   EXPECT_TRUE(results.has_executable);
   EXPECT_TRUE(results.has_archive);
   ASSERT_EQ(1, results.archived_binary.size());
   ExpectBinary(kSignedExe, results.archived_binary.Get(0));
   ASSERT_EQ(1u, results.archived_archive_filenames.size());
   EXPECT_EQ(FILE_PATH_LITERAL("hello.7z"),
             results.archived_archive_filenames[0].value());
 }
 
 TEST_F(SandboxedZipAnalyzerTest,
        ZippedArchiveAndBinariesWithTrailingSpaceAndPeriodChars) {
-  zip_analyzer::Results results;
+  ArchiveAnalyzerResults results;
   RunAnalyzer(dir_test_data_.AppendASCII("zipfile_two_binaries_one_archive_"
                                          "trailing_space_and_period_chars.zip"),
               &results);
   ASSERT_TRUE(results.success);
   EXPECT_TRUE(results.has_executable);
   EXPECT_TRUE(results.has_archive);
   ASSERT_EQ(2, results.archived_binary.size());
 
   BinaryData SignedExe = kSignedExe;
   SignedExe.file_basename = "signed.exe ";
   BinaryData UnsignedExe = kUnsignedExe;
   UnsignedExe.file_basename = "unsigned.exe.";
   ExpectBinary(SignedExe, results.archived_binary.Get(0));
   ExpectBinary(UnsignedExe, results.archived_binary.Get(1));
   ASSERT_EQ(1u, results.archived_archive_filenames.size());
   EXPECT_EQ(FILE_PATH_LITERAL("zipfile_no_binaries.zip  .  . "),
             results.archived_archive_filenames[0].value());
 }
 
 TEST_F(SandboxedZipAnalyzerTest, ZippedJSEFile) {
-  zip_analyzer::Results results;
+  ArchiveAnalyzerResults results;
   RunAnalyzer(dir_test_data_.AppendASCII("zipfile_one_jse_file.zip"), &results);
   ASSERT_TRUE(results.success);
   EXPECT_TRUE(results.has_executable);
   EXPECT_FALSE(results.has_archive);
   ASSERT_EQ(1, results.archived_binary.size());
   ExpectBinary(kJSEFile, results.archived_binary.Get(0));
   EXPECT_TRUE(results.archived_archive_filenames.empty());
 }
 
 }  // namespace safe_browsing