Adding a DownloadRestrictions group policy.

chrome/browser/download/chrome_download_manager_delegate_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 <stddef.h>
 #include <stdint.h>
 
 #include <string>
 
 #include "base/files/file_path.h"
@@ skipping 221 matching lines @@
   // Invokes ChromeDownloadManagerDelegate::CheckForFileExistence and waits for
   // the asynchronous callback. The result passed into
   // content::CheckForFileExistenceCallback is the return value from this
   // method.
   bool CheckForFileExistence(DownloadItem* download);
 
   const base::FilePath& default_download_path() const;
   TestChromeDownloadManagerDelegate* delegate();
   content::MockDownloadManager* download_manager();
   DownloadPrefs* download_prefs();
+  PrefService* pref_service();
 
  private:
   sync_preferences::TestingPrefServiceSyncable* pref_service_;
   base::ScopedTempDir test_download_dir_;
   std::unique_ptr<content::MockDownloadManager> download_manager_;
   std::unique_ptr<TestChromeDownloadManagerDelegate> delegate_;
   MockWebContentsDelegate web_contents_delegate_;
 };
 
 ChromeDownloadManagerDelegateTest::ChromeDownloadManagerDelegateTest()
@@ skipping 133 matching lines @@
 
 content::MockDownloadManager*
     ChromeDownloadManagerDelegateTest::download_manager() {
   return download_manager_.get();
 }
 
 DownloadPrefs* ChromeDownloadManagerDelegateTest::download_prefs() {
   return delegate_->download_prefs();
 }
 
+PrefService* ChromeDownloadManagerDelegateTest::pref_service() {
+  return pref_service_;
+}
+
 }  // namespace
 
 TEST_F(ChromeDownloadManagerDelegateTest, LastSavePath) {
   GURL download_url("http://example.com/foo.txt");
 
   std::unique_ptr<content::MockDownloadItem> save_as_download =
       CreateActiveDownloadItem(0);
   EXPECT_CALL(*save_as_download, GetURL())
       .Times(AnyNumber())
       .WillRepeatedly(ReturnRef(download_url));
@@ skipping 162 matching lines @@
   EXPECT_CALL(*download_item, GetTargetFilePath())
       .WillRepeatedly(ReturnRef(existing_path));
   EXPECT_TRUE(CheckForFileExistence(download_item.get()));
 
   download_item = CreateActiveDownloadItem(1);
   EXPECT_CALL(*download_item, GetTargetFilePath())
       .WillRepeatedly(ReturnRef(non_existent_path));
   EXPECT_FALSE(CheckForFileExistence(download_item.get()));
 }
 
+TEST_F(ChromeDownloadManagerDelegateTest, BlockedByPolicy) {
+  const GURL kUrl("http://example.com/foo");
+  const std::string kTargetDisposition("attachment; filename=\"foo.txt\"");
+
+  std::unique_ptr<content::MockDownloadItem> download_item =
+      CreateActiveDownloadItem(0);
+  EXPECT_CALL(*download_item, GetURL()).WillRepeatedly(ReturnRef(kUrl));
+  EXPECT_CALL(*download_item, GetContentDisposition())
+      .WillRepeatedly(Return(kTargetDisposition));
+
+  base::FilePath kExpectedPath = GetPathInDownloadDir("bar.txt");
+
+  DetermineDownloadTargetResult result;
+
+  EXPECT_CALL(*delegate(), MockReserveVirtualPath(_, _, _, _, _))
+      .WillOnce(DoAll(SetArgPointee<4>(PathValidationResult::CONFLICT),
+                      ReturnArg<1>()));
+  EXPECT_CALL(
+      *delegate(),
+      RequestConfirmation(_, _, DownloadConfirmationReason::TARGET_CONFLICT, _))
+      .WillOnce(WithArg<3>(ScheduleCallback2(
+          DownloadConfirmationResult::CONFIRMED, kExpectedPath)));
+
+  pref_service()->SetInteger(
+      prefs::kDownloadRestrictions,
+      static_cast<int>(DownloadPrefs::DOWNLOAD_RESTRICTION_ALL_FILES));
+
+  DetermineDownloadTarget(download_item.get(), &result);
+  EXPECT_EQ(content::DOWNLOAD_INTERRUPT_REASON_FILE_BLOCKED,
+            result.interrupt_reason);
+
+  VerifyAndClearExpectations();
+}
+
 #if defined(FULL_SAFE_BROWSING)
 namespace {
 
 struct SafeBrowsingTestParameters {
   content::DownloadDangerType initial_danger_type;
   DownloadFileType::DangerLevel initial_danger_level;
   safe_browsing::DownloadProtectionService::DownloadCheckResult verdict;
+  DownloadPrefs::DOWNLOAD_RESTRICTION download_restriction;
 
   content::DownloadDangerType expected_danger_type;
+  bool blocked;
 };
 
 class TestDownloadProtectionService
     : public safe_browsing::DownloadProtectionService {
  public:
   TestDownloadProtectionService() : DownloadProtectionService(nullptr) {}
 
   void CheckClientDownload(DownloadItem* download_item,
                            const CheckDownloadCallback& callback) override {
     callback.Run(MockCheckClientDownload());
@@ skipping 28 matching lines @@
 void ChromeDownloadManagerDelegateTestWithSafeBrowsing::TearDown() {
   test_download_protection_service_.reset();
   ChromeDownloadManagerDelegateTest::TearDown();
 }
 
 const SafeBrowsingTestParameters kSafeBrowsingTestCases[] = {
     // SAFE verdict for a safe file.
     {content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
      DownloadFileType::NOT_DANGEROUS,
      safe_browsing::DownloadProtectionService::SAFE,
+     DownloadPrefs::DOWNLOAD_RESTRICTION_NONE,
 
-     content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS},
+     content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
+     /*blocked=*/false},
 
     // UNKNOWN verdict for a safe file.
     {content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
      DownloadFileType::NOT_DANGEROUS,
      safe_browsing::DownloadProtectionService::UNKNOWN,
+     DownloadPrefs::DOWNLOAD_RESTRICTION_NONE,
 
-     content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS},
+     content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
+     /*blocked=*/false},
 
     // DANGEROUS verdict for a safe file.
     {content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
      DownloadFileType::NOT_DANGEROUS,
      safe_browsing::DownloadProtectionService::DANGEROUS,
+     DownloadPrefs::DOWNLOAD_RESTRICTION_NONE,
 
-     content::DOWNLOAD_DANGER_TYPE_DANGEROUS_CONTENT},
+     content::DOWNLOAD_DANGER_TYPE_DANGEROUS_CONTENT,
+     /*blocked=*/false},
 
     // UNCOMMON verdict for a safe file.
     {content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
      DownloadFileType::NOT_DANGEROUS,
      safe_browsing::DownloadProtectionService::UNCOMMON,
+     DownloadPrefs::DOWNLOAD_RESTRICTION_NONE,
 
-     content::DOWNLOAD_DANGER_TYPE_UNCOMMON_CONTENT},
+     content::DOWNLOAD_DANGER_TYPE_UNCOMMON_CONTENT,
+     /*blocked=*/false},
 
     // POTENTIALLY_UNWANTED verdict for a safe file.
     {content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
      DownloadFileType::NOT_DANGEROUS,
      safe_browsing::DownloadProtectionService::POTENTIALLY_UNWANTED,
+     DownloadPrefs::DOWNLOAD_RESTRICTION_NONE,
 
-     content::DOWNLOAD_DANGER_TYPE_POTENTIALLY_UNWANTED},
+     content::DOWNLOAD_DANGER_TYPE_POTENTIALLY_UNWANTED,
+     /*blocked=*/false},
 
     // SAFE verdict for a potentially dangerous file.
     {content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT,
      DownloadFileType::ALLOW_ON_USER_GESTURE,
      safe_browsing::DownloadProtectionService::SAFE,
+     DownloadPrefs::DOWNLOAD_RESTRICTION_NONE,
 
-     content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS},
+     content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
+     /*blocked=*/false},
 
     // UNKNOWN verdict for a potentially dangerous file.
     {content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT,
      DownloadFileType::ALLOW_ON_USER_GESTURE,
      safe_browsing::DownloadProtectionService::UNKNOWN,
+     DownloadPrefs::DOWNLOAD_RESTRICTION_NONE,
 
-     content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE},
+     content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE,
+     /*blocked=*/false},
+
+    // UNKNOWN verdict for a potentially dangerous file blocked by policy.
+    {content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT,
+     DownloadFileType::ALLOW_ON_USER_GESTURE,
+     safe_browsing::DownloadProtectionService::UNKNOWN,
+     DownloadPrefs::DOWNLOAD_RESTRICTION_DANGEROUS_FILES,
+
+     content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE,
+     /*blocked=*/true},
 
     // DANGEROUS verdict for a potentially dangerous file.
     {content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT,
      DownloadFileType::ALLOW_ON_USER_GESTURE,
      safe_browsing::DownloadProtectionService::DANGEROUS,
+     DownloadPrefs::DOWNLOAD_RESTRICTION_NONE,
 
-     content::DOWNLOAD_DANGER_TYPE_DANGEROUS_CONTENT},
+     content::DOWNLOAD_DANGER_TYPE_DANGEROUS_CONTENT,
+     /*blocked=*/false},
 
     // UNCOMMON verdict for a potentially dangerous file.
     {content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT,
      DownloadFileType::ALLOW_ON_USER_GESTURE,
      safe_browsing::DownloadProtectionService::UNCOMMON,
+     DownloadPrefs::DOWNLOAD_RESTRICTION_NONE,
 
-     content::DOWNLOAD_DANGER_TYPE_UNCOMMON_CONTENT},
+     content::DOWNLOAD_DANGER_TYPE_UNCOMMON_CONTENT,
+     /*blocked=*/false},
 
     // POTENTIALLY_UNWANTED verdict for a potentially dangerous file.
     {content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT,
      DownloadFileType::ALLOW_ON_USER_GESTURE,
      safe_browsing::DownloadProtectionService::POTENTIALLY_UNWANTED,
+     DownloadPrefs::DOWNLOAD_RESTRICTION_NONE,
 
-     content::DOWNLOAD_DANGER_TYPE_POTENTIALLY_UNWANTED},
+     content::DOWNLOAD_DANGER_TYPE_POTENTIALLY_UNWANTED,
+     /*blocked=*/false},
+
+    // POTENTIALLY_UNWANTED verdict for a potentially dangerous file, blocked by
+    // policy.
+    {content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT,
+     DownloadFileType::ALLOW_ON_USER_GESTURE,
+     safe_browsing::DownloadProtectionService::POTENTIALLY_UNWANTED,
+     DownloadPrefs::DOWNLOAD_RESTRICTION_POTENTIALLY_DANGEROUS_FILES,
+
+     content::DOWNLOAD_DANGER_TYPE_POTENTIALLY_UNWANTED,
+     /*blocked=*/true},
+
+    // POTENTIALLY_UNWANTED verdict for a potentially dangerous file, not
+    // blocked by policy.
+    {content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT,
+     DownloadFileType::ALLOW_ON_USER_GESTURE,
+     safe_browsing::DownloadProtectionService::POTENTIALLY_UNWANTED,
+     DownloadPrefs::DOWNLOAD_RESTRICTION_DANGEROUS_FILES,
+
+     content::DOWNLOAD_DANGER_TYPE_POTENTIALLY_UNWANTED,
+     /*blocked=*/false},
 
     // SAFE verdict for a dangerous file.
     {content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT,
      DownloadFileType::DANGEROUS,
      safe_browsing::DownloadProtectionService::SAFE,
+     DownloadPrefs::DOWNLOAD_RESTRICTION_NONE,
 
-     content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE},
+     content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE,
+     /*blocked=*/false},
 
     // UNKNOWN verdict for a dangerous file.
     {content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT,
      DownloadFileType::DANGEROUS,
      safe_browsing::DownloadProtectionService::UNKNOWN,
+     DownloadPrefs::DOWNLOAD_RESTRICTION_NONE,
 
-     content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE},
+     content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE,
+     /*blocked=*/false},
 
     // DANGEROUS verdict for a dangerous file.
     {content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT,
      DownloadFileType::DANGEROUS,
      safe_browsing::DownloadProtectionService::DANGEROUS,
+     DownloadPrefs::DOWNLOAD_RESTRICTION_NONE,
 
-     content::DOWNLOAD_DANGER_TYPE_DANGEROUS_CONTENT},
+     content::DOWNLOAD_DANGER_TYPE_DANGEROUS_CONTENT,
+     /*blocked=*/false},
 
     // UNCOMMON verdict for a dangerous file.
     {content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT,
      DownloadFileType::DANGEROUS,
      safe_browsing::DownloadProtectionService::UNCOMMON,
+     DownloadPrefs::DOWNLOAD_RESTRICTION_NONE,
 
-     content::DOWNLOAD_DANGER_TYPE_UNCOMMON_CONTENT},
+     content::DOWNLOAD_DANGER_TYPE_UNCOMMON_CONTENT,
+     /*blocked=*/false},
 
     // POTENTIALLY_UNWANTED verdict for a dangerous file.
     {content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT,
      DownloadFileType::DANGEROUS,
      safe_browsing::DownloadProtectionService::POTENTIALLY_UNWANTED,
+     DownloadPrefs::DOWNLOAD_RESTRICTION_NONE,
 
-     content::DOWNLOAD_DANGER_TYPE_POTENTIALLY_UNWANTED},
+     content::DOWNLOAD_DANGER_TYPE_POTENTIALLY_UNWANTED,
+     /*blocked=*/false},
 };
 
 INSTANTIATE_TEST_CASE_P(_,
                         ChromeDownloadManagerDelegateTestWithSafeBrowsing,
                         ::testing::ValuesIn(kSafeBrowsingTestCases));
 
 }  // namespace
 
 TEST_P(ChromeDownloadManagerDelegateTestWithSafeBrowsing, CheckClientDownload) {
   const SafeBrowsingTestParameters& kParameters = GetParam();
 
   std::unique_ptr<content::MockDownloadItem> download_item =
       CreateActiveDownloadItem(0);
   EXPECT_CALL(*delegate(), GetDownloadProtectionService());
   EXPECT_CALL(*download_protection_service(), MockCheckClientDownload())
       .WillOnce(Return(kParameters.verdict));
   EXPECT_CALL(*download_item, GetDangerType())
       .WillRepeatedly(Return(kParameters.initial_danger_type));
 
   if (kParameters.initial_danger_level != DownloadFileType::NOT_DANGEROUS) {
     DownloadItemModel(download_item.get())
         .SetDangerLevel(kParameters.initial_danger_level);
   }
 
   if (kParameters.expected_danger_type !=
       content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS) {
-    EXPECT_CALL(*download_item,
-                OnContentCheckCompleted(kParameters.expected_danger_type));
+    if (kParameters.blocked) {
+      EXPECT_CALL(*download_item,
+                  OnContentCheckCompleted(
+                      // Specifying a dangerous type here would take precendence
+                      // over the blocking of the file.
+                      content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
+                      content::DOWNLOAD_INTERRUPT_REASON_FILE_BLOCKED));
+    } else {
+      EXPECT_CALL(*download_item, OnContentCheckCompleted(
+                                      kParameters.expected_danger_type,
+                                      content::DOWNLOAD_INTERRUPT_REASON_NONE));
+    }
   } else {
-    EXPECT_CALL(*download_item, OnContentCheckCompleted(_)).Times(0);
+    EXPECT_CALL(*download_item, OnContentCheckCompleted(_, _)).Times(0);
   }
 
+  pref_service()->SetInteger(
+      prefs::kDownloadRestrictions,
+      static_cast<int>(kParameters.download_restriction));
+
   base::RunLoop run_loop;
   ASSERT_FALSE(delegate()->ShouldCompleteDownload(download_item.get(),
                                                   run_loop.QuitClosure()));
   run_loop.Run();
 }
 
 #endif  // FULL_SAFE_BROWSING
 
 #if defined(OS_ANDROID)
 
@@ skipping 115 matching lines @@
         test_case.path == ExpectPath::FULL ? fake_path : base::FilePath());
     delegate()->RequestConfirmation(download_item.get(), fake_path,
                                     test_case.confirmation_reason, callback);
     loop.Run();
 
     EXPECT_EQ(test_case.info_bar == ExpectInfoBar::YES ? 1 : 0,
               infobar_counter.CheckAndResetInfobarCount());
   }
 }
 #endif  // OS_ANDROID