Add a new group policy to disable safe browsing for files downloaded from trusted sources.

chrome/browser/download/download_prefs.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/download/download_prefs.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/path_service.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "chrome/browser/download/chrome_download_manager_delegate.h"
 #include "chrome/browser/download/download_target_determiner.h"
+#include "chrome/browser/download/trusted_sources_manager.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/safe_browsing/file_type_policies.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/prefs/pref_service.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/download_item.h"
 #include "content/public/browser/download_manager.h"
 #include "content/public/browser/save_page_type.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/drive/drive_integration_service.h"
 #include "chrome/browser/chromeos/drive/file_system_util.h"
 #include "chrome/browser/chromeos/file_manager/path_util.h"
 #endif
 
 #if defined(OS_WIN)
@@ skipping 105 matching lines @@
       prefs->SetFilePath(prefs::kDownloadDefaultDirectory,
                          GetDefaultDownloadDirectoryForProfile());
     }
     prefs->SetBoolean(prefs::kDownloadDirUpgraded, true);
   }
 
   prompt_for_download_.Init(prefs::kPromptForDownload, prefs);
   download_path_.Init(prefs::kDownloadDefaultDirectory, prefs);
   save_file_path_.Init(prefs::kSaveFileDefaultDirectory, prefs);
   save_file_type_.Init(prefs::kSaveFileType, prefs);
+  safebrowsing_for_trusted_sources_enabled_.Init(
+      prefs::kSafeBrowsingForTrustedSourcesEnabled, prefs);
   download_restriction_.Init(prefs::kDownloadRestrictions, prefs);
 
   // We store any file extension that should be opened automatically at
   // download completion in this pref.
   std::string extensions_to_open =
       prefs->GetString(prefs::kDownloadExtensionsToOpen);
 
   for (const auto& extension_string : base::SplitString(
            extensions_to_open, ":",
            base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
@@ skipping 12 matching lines @@
     // IsAllowedToOpenAutomatically() needs a filename.
     base::FilePath filename_with_extension = base::FilePath(
         base::FilePath::StringType(1, base::FilePath::kExtensionSeparator) +
         extension);
 
     // Note that the list of file types that are not allowed to open
     // automatically can change in the future. When the list is tightened, it is
     // expected that some entries in the users' auto open list will get dropped
     // permanently as a result.
     if (FileTypePolicies::GetInstance()->IsAllowedToOpenAutomatically(
-            filename_with_extension))
+            filename_with_extension)) {
       auto_open_.insert(extension);
+    }
   }
 }
 
 DownloadPrefs::~DownloadPrefs() {}
 
 // static
 void DownloadPrefs::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterBooleanPref(
       prefs::kPromptForDownload,
       false,
       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
   registry->RegisterStringPref(prefs::kDownloadExtensionsToOpen, std::string());
   registry->RegisterBooleanPref(prefs::kDownloadDirUpgraded, false);
   registry->RegisterIntegerPref(prefs::kSaveFileType,
                                 content::SAVE_PAGE_TYPE_AS_COMPLETE_HTML);
+  registry->RegisterIntegerPref(prefs::kDownloadRestrictions, 0);
+  registry->RegisterBooleanPref(prefs::kSafeBrowsingForTrustedSourcesEnabled,
+                                true);
 
   const base::FilePath& default_download_path = GetDefaultDownloadDirectory();
   registry->RegisterFilePathPref(prefs::kDownloadDefaultDirectory,
                                  default_download_path);
   registry->RegisterFilePathPref(prefs::kSaveFileDefaultDirectory,
                                  default_download_path);
 #if defined(OS_WIN) || defined(OS_LINUX) || defined(OS_MACOSX)
   registry->RegisterBooleanPref(prefs::kOpenPdfDownloadInSystemReader, false);
 #endif
 }
@@ skipping 19 matching lines @@
           download_manager->GetDelegate());
   return delegate->download_prefs();
 }
 
 // static
 DownloadPrefs* DownloadPrefs::FromBrowserContext(
     content::BrowserContext* context) {
   return FromDownloadManager(BrowserContext::GetDownloadManager(context));
 }
 
+bool DownloadPrefs::IsFromTrustedSource(const content::DownloadItem& item) {
+  if (!trusted_sources_manager_)
+    trusted_sources_manager_.reset(TrustedSourcesManager::Create());
+  return trusted_sources_manager_->IsFromTrustedSource(item.GetURL());
+}
+
 base::FilePath DownloadPrefs::DownloadPath() const {
 #if defined(OS_CHROMEOS)
   // If the download path is under /drive, and DriveIntegrationService isn't
   // available (which it isn't for incognito mode, for instance), use the
   // default download directory (/Downloads).
   if (drive::util::IsUnderDriveMountPoint(*download_path_)) {
     drive::DriveIntegrationService* integration_service =
         drive::DriveIntegrationServiceFactory::FindForProfile(profile_);
     if (!integration_service || !integration_service->is_enabled())
       return GetDefaultDownloadDirectoryForProfile();
@@ skipping 50 matching lines @@
     return true;
 #endif
 
   return auto_open_.find(extension) != auto_open_.end();
 }
 
 bool DownloadPrefs::EnableAutoOpenBasedOnExtension(
     const base::FilePath& file_name) {
   base::FilePath::StringType extension = file_name.Extension();
   if (!FileTypePolicies::GetInstance()->IsAllowedToOpenAutomatically(
-          file_name))
+          file_name)) {
     return false;
+  }
 
   DCHECK(extension[0] == base::FilePath::kExtensionSeparator);
   extension.erase(0, 1);
 
   auto_open_.insert(extension);
   SaveAutoOpenState();
   return true;
 }
 
 void DownloadPrefs::DisableAutoOpenBasedOnExtension(
@@ skipping 51 matching lines @@
     extensions.erase(extensions.size() - 1);
 
   profile_->GetPrefs()->SetString(prefs::kDownloadExtensionsToOpen, extensions);
 }
 
 bool DownloadPrefs::AutoOpenCompareFunctor::operator()(
     const base::FilePath::StringType& a,
     const base::FilePath::StringType& b) const {
   return base::FilePath::CompareLessIgnoreCase(a, b);
 }