Use FileTypePolicies for download danger classifications.

chrome/browser/download/download_target_determiner.cc

 // Copyright 2013 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_target_determiner.h"
 
 #include "base/location.h"
 #include "base/rand_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "chrome/browser/download/chrome_download_manager_delegate.h"
 #include "chrome/browser/download/download_crx_util.h"
-#include "chrome/browser/download/download_extensions.h"
 #include "chrome/browser/download/download_prefs.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/pref_names.h"
+#include "chrome/common/safe_browsing/file_type_policies.h"
 #include "chrome/grit/generated_resources.h"
 #include "components/history/core/browser/history_service.h"
 #include "components/mime_util/mime_util.h"
 #include "components/prefs/pref_service.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/download_interrupt_reasons.h"
 #include "extensions/common/constants.h"
 #include "net/base/filename_util.h"
 #include "ui/base/l10n/l10n_util.h"
 
 #if defined(ENABLE_EXTENSIONS)
 #include "chrome/browser/extensions/webstore_installer.h"
 #include "extensions/common/feature_switch.h"
 #endif
 
 #if defined(ENABLE_PLUGINS)
 #include "chrome/browser/plugins/plugin_prefs.h"
 #include "content/public/browser/plugin_service.h"
 #include "content/public/common/webplugininfo.h"
 #endif
 
 #if defined(OS_WIN)
 #include "chrome/browser/ui/pdf/adobe_reader_info_win.h"
 #endif
 
 using content::BrowserThread;
 using content::DownloadItem;
+using safe_browsing::DownloadFileType;
 
 namespace {
 
 const base::FilePath::CharType kCrdownloadSuffix[] =
     FILE_PATH_LITERAL(".crdownload");
 
 // Condenses the results from HistoryService::GetVisibleVisitCountToHost() to a
 // single bool. A host is considered visited before if prior visible visits were
 // found in history and the first such visit was earlier than the most recent
 // midnight.
@@ skipping 10 matching lines @@
 #if defined(OS_WIN)
 // Keeps track of whether Adobe Reader is up to date.
 bool g_is_adobe_reader_up_to_date_ = false;
 #endif
 
 }  // namespace
 
 DownloadTargetInfo::DownloadTargetInfo()
     : target_disposition(DownloadItem::TARGET_DISPOSITION_OVERWRITE),
       danger_type(content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS),
-      danger_level(download_util::NOT_DANGEROUS),
+      danger_level(DownloadFileType::NOT_DANGEROUS),
       is_filetype_handled_safely(false) {}
 
 DownloadTargetInfo::~DownloadTargetInfo() {}
 
 DownloadTargetDeterminerDelegate::~DownloadTargetDeterminerDelegate() {
 }
 
 DownloadTargetDeterminer::DownloadTargetDeterminer(
     DownloadItem* download,
     const base::FilePath& initial_virtual_path,
     DownloadPrefs* download_prefs,
     DownloadTargetDeterminerDelegate* delegate,
     const CompletionCallback& callback)
     : next_state_(STATE_GENERATE_TARGET_PATH),
       should_prompt_(false),
       should_notify_extensions_(false),
       create_target_directory_(false),
       conflict_action_(DownloadPathReservationTracker::OVERWRITE),
       danger_type_(download->GetDangerType()),
-      danger_level_(download_util::NOT_DANGEROUS),
+      danger_level_(DownloadFileType::NOT_DANGEROUS),
       virtual_path_(initial_virtual_path),
       is_filetype_handled_safely_(false),
       download_(download),
       is_resumption_(download_->GetLastReason() !=
                          content::DOWNLOAD_INTERRUPT_REASON_NONE &&
                      !initial_virtual_path.empty()),
       download_prefs_(download_prefs),
       delegate_(delegate),
       completion_callback_(callback),
       weak_ptr_factory_(this) {
@@ skipping 494 matching lines @@
   // Checking if there are prior visits to the referrer is only necessary if the
   // danger level of the download depends on the file type.
   if (danger_type_ != content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS &&
       danger_type_ != content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT)
     return CONTINUE;
 
   // First determine the danger level assuming that the user doesn't have any
   // prior visits to the referrer recoreded in history. The resulting danger
   // level would be ALLOW_ON_USER_GESTURE if the level depends on the visit
   // history. In the latter case, we can query the history DB to determine if
-  // there were prior reqeusts and determine the danger level again once the
+  // there were prior requests and determine the danger level again once the
   // result is available.
   danger_level_ = GetDangerLevel(NO_VISITS_TO_REFERRER);
 
-  if (danger_level_ == download_util::NOT_DANGEROUS)
+  if (danger_level_ == DownloadFileType::NOT_DANGEROUS)
     return CONTINUE;
 
-  if (danger_level_ == download_util::ALLOW_ON_USER_GESTURE) {
+  if (danger_level_ == DownloadFileType::ALLOW_ON_USER_GESTURE) {
     // HistoryServiceFactory redirects incognito profiles to on-record profiles.
     // There's no history for on-record profiles in unit_tests.
     history::HistoryService* history_service =
         HistoryServiceFactory::GetForProfile(
             GetProfile(), ServiceAccessType::EXPLICIT_ACCESS);
 
     if (history_service && download_->GetReferrerUrl().is_valid()) {
       history_service->GetVisibleVisitCountToHost(
           download_->GetReferrerUrl(),
           base::Bind(
@@ skipping 13 matching lines @@
     danger_type_ = content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE;
   return CONTINUE;
 }
 
 void DownloadTargetDeterminer::CheckVisitedReferrerBeforeDone(
     bool visited_referrer_before) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK_EQ(STATE_DETERMINE_INTERMEDIATE_PATH, next_state_);
   danger_level_ = GetDangerLevel(
       visited_referrer_before ? VISITED_REFERRER : NO_VISITS_TO_REFERRER);
-  if (danger_level_ != download_util::NOT_DANGEROUS &&
+  if (danger_level_ != DownloadFileType::NOT_DANGEROUS &&
       danger_type_ == content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS)
     danger_type_ = content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE;
   DoLoop();
 }
 
 DownloadTargetDeterminer::Result
     DownloadTargetDeterminer::DoDetermineIntermediatePath() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!virtual_path_.empty());
   DCHECK(!local_path_.empty());
@@ skipping 167 matching lines @@
   // files), or if an extension signals that the user be prompted on a filename
   // conflict.
   return false;
 }
 
 bool DownloadTargetDeterminer::HasPromptedForPath() const {
   return (is_resumption_ && download_->GetTargetDisposition() ==
                                 DownloadItem::TARGET_DISPOSITION_PROMPT);
 }
 
-download_util::DownloadDangerLevel DownloadTargetDeterminer::GetDangerLevel(
+DownloadFileType::DangerLevel DownloadTargetDeterminer::GetDangerLevel(
     PriorVisitsToReferrer visits) const {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   // If the user has has been prompted or will be, assume that the user has
   // approved the download. A programmatic download is considered safe unless it
   // contains malware.
   if (HasPromptedForPath() || should_prompt_ ||
       !download_->GetForcedFilePath().empty())
-    return download_util::NOT_DANGEROUS;
+    return DownloadFileType::NOT_DANGEROUS;
 
   const bool is_extension_download =
       download_crx_util::IsExtensionDownload(*download_);
 
   // User-initiated extension downloads from pref-whitelisted sources are not
   // considered dangerous.
   if (download_->HasUserGesture() &&
       is_extension_download &&
       download_crx_util::OffStoreInstallAllowedByPrefs(
           GetProfile(), *download_)) {
-    return download_util::NOT_DANGEROUS;
+    return DownloadFileType::NOT_DANGEROUS;
   }
 
 #if defined(ENABLE_EXTENSIONS)
   // Extensions that are not from the gallery are considered dangerous.
   // When off-store install is disabled we skip this, since in this case, we
   // will not offer to install the extension.
   if (extensions::FeatureSwitch::easy_off_store_install()->IsEnabled() &&
       is_extension_download &&
       !extensions::WebstoreInstaller::GetAssociatedApproval(*download_)) {
-    return download_util::ALLOW_ON_USER_GESTURE;
+    return DownloadFileType::ALLOW_ON_USER_GESTURE;
   }
 #endif
 
   // Anything the user has marked auto-open is OK if it's user-initiated.
   if (download_prefs_->IsAutoOpenEnabledBasedOnExtension(virtual_path_) &&
       download_->HasUserGesture())
-    return download_util::NOT_DANGEROUS;
+    return DownloadFileType::NOT_DANGEROUS;
 
-  download_util::DownloadDangerLevel danger_level =
-      download_util::GetFileDangerLevel(virtual_path_.BaseName());
+  DownloadFileType::DangerLevel danger_level =
+      safe_browsing::FileTypePolicies::GetInstance()->GetFileDangerLevel(
+          virtual_path_.BaseName());
 
   // If the danger level is ALLOW_ON_USER_GESTURE and we have a user gesture AND
   // there was a recorded visit to the referrer prior to today, then we are
   // going to downgrade the danger_level to NOT_DANGEROUS. This prevents
   // spurious prompting for moderately dangerous files that are downloaded from
   // familiar sites.
-  if (danger_level == download_util::ALLOW_ON_USER_GESTURE &&
+  if (danger_level == DownloadFileType::ALLOW_ON_USER_GESTURE &&
       (download_->GetTransitionType() == ui::PAGE_TRANSITION_FROM_ADDRESS_BAR ||
        (download_->HasUserGesture() && visits == VISITED_REFERRER)))
-    return download_util::NOT_DANGEROUS;
+    return DownloadFileType::NOT_DANGEROUS;
   return danger_level;
 }
 
 void DownloadTargetDeterminer::OnDownloadDestroyed(
     DownloadItem* download) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK_EQ(download_, download);
   CancelOnFailureAndDeleteSelf();
 }
 
@@ skipping 15 matching lines @@
     const base::FilePath& suggested_path) {
   return base::FilePath(suggested_path.value() + kCrdownloadSuffix);
 }
 
 #if defined(OS_WIN)
 // static
 bool DownloadTargetDeterminer::IsAdobeReaderUpToDate() {
   return g_is_adobe_reader_up_to_date_;
 }
 #endif