Reduce generic warnings shown on dmg downloads

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 460 matching lines @@
 
   void OnClientDownloadRequest(content::DownloadItem* download,
                                const ClientDownloadRequest* request) {
     if (request)
       last_client_download_request_.reset(new ClientDownloadRequest(*request));
     else
       last_client_download_request_.reset();
   }
 
  public:
+  enum ArchiveType { ZIP, DMG };
+
   void CheckDoneCallback(
       DownloadProtectionService::DownloadCheckResult result) {
     result_ = result;
     has_result_ = true;
     MessageLoop::current()->QuitWhenIdle();
   }
 
   void SyncCheckDoneCallback(
       DownloadProtectionService::DownloadCheckResult result) {
     result_ = result;
@@ skipping 16 matching lines @@
   }
 
   void SetExtendedReportingPreference(bool is_extended_reporting) {
     profile_->GetPrefs()->SetBoolean(
         prefs::kSafeBrowsingExtendedReportingEnabled,
         is_extended_reporting);
   }
 
   // Check scenarios where we should/shouldn't send a report for
   // a corrupted zip.
-  void CheckClientDownloadReportCorruptZip(bool is_extended_reporting,
-                                           bool is_incognito);
-
+  void CheckClientDownloadReportCorruptArchive(ArchiveType type,
+                                               bool is_extended_reporting,
+                                               bool is_incognito);
 
  protected:
   // This will effectivly mask the global Singleton while this is in scope.
   FileTypePoliciesTestOverlay policies_;
 
   scoped_refptr<FakeSafeBrowsingService> sb_service_;
   scoped_refptr<MockBinaryFeatureExtractor> binary_feature_extractor_;
   DownloadProtectionService* download_service_;
   DownloadProtectionService::DownloadCheckResult result_;
   bool has_result_;
   content::TestBrowserThreadBundle test_browser_thread_bundle_;
   content::InProcessUtilityThreadHelper in_process_utility_thread_helper_;
   base::FilePath testdata_path_;
   DownloadProtectionService::ClientDownloadRequestSubscription
       client_download_request_subscription_;
   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(
+void DownloadProtectionServiceTest::CheckClientDownloadReportCorruptArchive(
+    ArchiveType type,
     bool is_extended_reporting,
     bool is_incognito) {
   net::FakeURLFetcherFactory factory(NULL);
   PrepareResponse(
       &factory, ClientDownloadResponse::SAFE, net::HTTP_OK,
       net::URLRequestStatus::SUCCESS);
 
   profile_->GetPrefs()->SetBoolean(prefs::kSafeBrowsingExtendedReportingEnabled,
                                    is_extended_reporting);
   content::MockDownloadItem item;
-  PrepareBasicDownloadItem(
-    &item,
-    {"http://www.evil.com/a.zip"},  // url_chain
-    "http://www.google.com/",       // referrer
-    FILE_PATH_LITERAL("a.tmp"),     // tmp_path
-    FILE_PATH_LITERAL("a.zip"));    // final_path
+  if (type == ZIP) {
+    PrepareBasicDownloadItem(&item, {"http://www.evil.com/a.zip"},  // url_chain
+                             "http://www.google.com/",     // referrer
+                             FILE_PATH_LITERAL("a.tmp"),   // tmp_path
+                             FILE_PATH_LITERAL("a.zip"));  // final_path
+  } else if (type == DMG) {
+    PrepareBasicDownloadItem(&item, {"http://www.evil.com/a.dmg"},  // url_chain
+                             "http://www.google.com/",     // referrer
+                             FILE_PATH_LITERAL("a.tmp"),   // tmp_path
+                             FILE_PATH_LITERAL("a.dmg"));  // final_path
+  }
 
   if (is_incognito) {
     EXPECT_CALL(item, GetBrowserContext())
         .WillRepeatedly(Return(profile_->GetOffTheRecordProfile()));
   } else {
     EXPECT_CALL(item, GetBrowserContext())
         .WillRepeatedly(Return(profile_.get()));
   }
 
-  std::string file_contents = "corrupt zip file";
+  std::string file_contents = "corrupt archive file";
   ASSERT_EQ(static_cast<int>(file_contents.size()), base::WriteFile(
       tmp_path_, file_contents.data(), file_contents.size()));
 
   download_service_->CheckClientDownload(
       &item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
   MessageLoop::current()->Run();
 
-  const bool expect_request = is_extended_reporting && !is_incognito;
+  const bool expect_request =
+      type == ZIP ? is_extended_reporting && !is_incognito : true;
 
   if (expect_request) {
     ASSERT_TRUE(HasClientDownloadRequest());
     EXPECT_EQ(0, GetClientDownloadRequest()->archived_binary_size());
     EXPECT_TRUE(GetClientDownloadRequest()->has_download_type());
-    EXPECT_EQ(ClientDownloadRequest_DownloadType_INVALID_ZIP,
-              GetClientDownloadRequest()->download_type());
+    ClientDownloadRequest::DownloadType expected_type =
+        type == ZIP ? ClientDownloadRequest_DownloadType_INVALID_ZIP
+                    : ClientDownloadRequest_DownloadType_INVALID_MAC_ARCHIVE;
+    EXPECT_EQ(expected_type, GetClientDownloadRequest()->download_type());
     ClearClientDownloadRequest();
   } else {
     EXPECT_TRUE(IsResult(DownloadProtectionService::UNKNOWN));
     EXPECT_FALSE(HasClientDownloadRequest());
   }
 
   Mock::VerifyAndClearExpectations(sb_service_.get());
   Mock::VerifyAndClearExpectations(binary_feature_extractor_.get());
 }
 
-
 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
     FILE_PATH_LITERAL("a.exe"));  // final_path
   download_service_->CheckClientDownload(
       &item,
@@ skipping 709 matching lines @@
   EXPECT_TRUE(GetClientDownloadRequest()->has_download_type());
   EXPECT_EQ(ClientDownloadRequest_DownloadType_ZIPPED_ARCHIVE,
             GetClientDownloadRequest()->download_type());
   ClearClientDownloadRequest();
   Mock::VerifyAndClearExpectations(binary_feature_extractor_.get());
 }
 
 TEST_F(DownloadProtectionServiceTest,
        CheckClientDownloadReportCorruptZipNormal) {
   // !is_extended_reporting && !is_incognito
-  CheckClientDownloadReportCorruptZip(false, false);
+  CheckClientDownloadReportCorruptArchive(ZIP, false, false);
 }
 
 TEST_F(DownloadProtectionServiceTest,
        CheckClientDownloadReportCorruptZipExtended) {
   // !is_extended_reporting && !is_incognito
-  CheckClientDownloadReportCorruptZip(true, false);
+  CheckClientDownloadReportCorruptArchive(ZIP, true, false);
 }
 
 TEST_F(DownloadProtectionServiceTest,
        CheckClientDownloadReportCorruptZipIncognito) {
   // is_extended_reporting && is_incognito
-  CheckClientDownloadReportCorruptZip(true, true);
+  CheckClientDownloadReportCorruptArchive(ZIP, true, true);
 }
 
+#if defined(OS_MACOSX)
+TEST_F(DownloadProtectionServiceTest,
+       CheckClientDownloadReportCorruptDmgNormal) {
+  // !is_extended_reporting && !is_incognito
+  CheckClientDownloadReportCorruptArchive(DMG, false, false);
+}
+
+TEST_F(DownloadProtectionServiceTest,
+       CheckClientDownloadReportCorruptDmgExtended) {
+  // !is_extended_reporting && !is_incognito
+  CheckClientDownloadReportCorruptArchive(DMG, true, false);
+}
+
+TEST_F(DownloadProtectionServiceTest,
+       CheckClientDownloadReportCorruptDmgIncognito) {
+  // is_extended_reporting && is_incognito
+  CheckClientDownloadReportCorruptArchive(DMG, true, true);
+}
+#endif
+
 TEST_F(DownloadProtectionServiceTest, CheckClientCrxDownloadSuccess) {
   // Even if the server verdict is dangerous we should return SAFE because
   // DownloadProtectionService::IsSupportedDownload() will return false
   // for crx downloads.
   net::FakeURLFetcherFactory factory(NULL);
   PrepareResponse(
       &factory, ClientDownloadResponse::DANGEROUS, net::HTTP_OK,
       net::URLRequestStatus::SUCCESS);
 
   content::MockDownloadItem item;
@@ skipping 897 matching lines @@
       &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