[Downloads] Gracefully handle SafeBrowsing check failures.

chrome/browser/download/download_item_model.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_item_model.h"
 
 #include "base/i18n/number_formatting.h"
 #include "base/i18n/rtl.h"
 #include "base/metrics/field_trial.h"
 #include "base/strings/string16.h"
@@ skipping 30 matching lines @@
 class DownloadItemModelData : public base::SupportsUserData::Data {
  public:
   // Get the DownloadItemModelData object for |download|. Returns NULL if
   // there's no model data.
   static const DownloadItemModelData* Get(const DownloadItem* download);
 
   // Get the DownloadItemModelData object for |download|. Creates a model data
   // object if not found. Always returns a non-NULL pointer, unless OOM.
   static DownloadItemModelData* GetOrCreate(DownloadItem* download);
 
-  bool should_show_in_shelf() const { return should_show_in_shelf_; }
-  void set_should_show_in_shelf(bool should_show_in_shelf) {
-    should_show_in_shelf_ = should_show_in_shelf;
-  }
-
-  bool was_ui_notified() const { return was_ui_notified_; }
-  void set_was_ui_notified(bool was_ui_notified) {
-    was_ui_notified_ = was_ui_notified;
-  }
-
-  bool should_prefer_opening_in_browser() const {
-    return should_prefer_opening_in_browser_;
-  }
-  void set_should_prefer_opening_in_browser(bool preference) {
-    should_prefer_opening_in_browser_ = preference;
-  }
-
- private:
-  DownloadItemModelData();
-  virtual ~DownloadItemModelData() {}
-
-  static const char kKey[];
-
   // Whether the download should be displayed in the download shelf. True by
   // default.
   bool should_show_in_shelf_;
 
   // Whether the UI has been notified about this download.
   bool was_ui_notified_;
 
   // Whether the download should be opened in the browser vs. the system handler
   // for the file type.
   bool should_prefer_opening_in_browser_;
+
+  // Whether the download should be considered dangerous if SafeBrowsing doesn't
+  // come up with a verdict.
+  bool is_dangerous_file_based_on_type_;
+
+ private:
+  DownloadItemModelData();
+  virtual ~DownloadItemModelData() {}
+
+  static const char kKey[];
 };
 
 // static
 const char DownloadItemModelData::kKey[] = "DownloadItemModelData key";
 
 // static
 const DownloadItemModelData* DownloadItemModelData::Get(
     const DownloadItem* download) {
   return static_cast<const DownloadItemModelData*>(download->GetUserData(kKey));
 }
 
 // static
 DownloadItemModelData* DownloadItemModelData::GetOrCreate(
     DownloadItem* download) {
   DownloadItemModelData* data =
       static_cast<DownloadItemModelData*>(download->GetUserData(kKey));
   if (data == NULL) {
     data = new DownloadItemModelData();
     download->SetUserData(kKey, data);
   }
   return data;
 }
 
 DownloadItemModelData::DownloadItemModelData()
     : should_show_in_shelf_(true),
       was_ui_notified_(false),
-      should_prefer_opening_in_browser_(false) {
+      should_prefer_opening_in_browser_(false),
+      is_dangerous_file_based_on_type_(false) {
 }
 
 base::string16 InterruptReasonStatusMessage(int reason) {
   int string_id = IDS_DOWNLOAD_INTERRUPTED_STATUS;
 
   switch (static_cast<content::DownloadInterruptReason>(reason)) {
     case content::DOWNLOAD_INTERRUPT_REASON_FILE_ACCESS_DENIED:
       string_id = IDS_DOWNLOAD_INTERRUPTED_STATUS_ACCESS_DENIED;
       break;
     case content::DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE:
@@ skipping 432 matching lines @@
   return false;
 }
 
 bool DownloadItemModel::ShouldShowDownloadStartedAnimation() const {
   return !download_->IsSavePackageDownload() &&
       !download_crx_util::IsExtensionDownload(*download_);
 }
 
 bool DownloadItemModel::ShouldShowInShelf() const {
   const DownloadItemModelData* data = DownloadItemModelData::Get(download_);
-  return !data || data->should_show_in_shelf();
+  return !data || data->should_show_in_shelf_;
 }
 
 void DownloadItemModel::SetShouldShowInShelf(bool should_show) {
   DownloadItemModelData* data = DownloadItemModelData::GetOrCreate(download_);
-  data->set_should_show_in_shelf(should_show);
+  data->should_show_in_shelf_ = should_show;
 }
 
 bool DownloadItemModel::ShouldNotifyUI() const {
   Profile* profile =
       Profile::FromBrowserContext(download_->GetBrowserContext());
   DownloadService* download_service =
       DownloadServiceFactory::GetForBrowserContext(profile);
   DownloadHistory* download_history =
       (download_service ? download_service->GetDownloadHistory() : NULL);
 
   // The browser is only interested in new downloads. Ones that were restored
   // from history are not displayed on the shelf. The downloads page
   // independently listens for new downloads when it is active. Note that the UI
   // will be notified of downloads even if they are not meant to be displayed on
   // the shelf (i.e. ShouldShowInShelf() returns false). This is because:
   // *  The shelf isn't the only UI. E.g. on Android, the UI is the system
   //    DownloadManager.
   // *  There are other UI activities that need to be performed. E.g. if the
   //    download was initiated from a new tab, then that tab should be closed.
   //
   // TODO(asanka): If an interrupted download is restored from history and is
   // resumed, then ideally the UI should be notified.
   return !download_history ||
          !download_history->WasRestoredFromHistory(download_);
 }
 
 bool DownloadItemModel::WasUINotified() const {
   const DownloadItemModelData* data = DownloadItemModelData::Get(download_);
-  return data && data->was_ui_notified();
+  return data && data->was_ui_notified_;
 }
 
 void DownloadItemModel::SetWasUINotified(bool was_ui_notified) {
   DownloadItemModelData* data = DownloadItemModelData::GetOrCreate(download_);
-  data->set_was_ui_notified(was_ui_notified);
+  data->was_ui_notified_ = was_ui_notified;
 }
 
 bool DownloadItemModel::ShouldPreferOpeningInBrowser() const {
   const DownloadItemModelData* data = DownloadItemModelData::Get(download_);
-  return data && data->should_prefer_opening_in_browser();
+  return data && data->should_prefer_opening_in_browser_;
 }
 
 void DownloadItemModel::SetShouldPreferOpeningInBrowser(bool preference) {
   DownloadItemModelData* data = DownloadItemModelData::GetOrCreate(download_);
-  data->set_should_prefer_opening_in_browser(preference);
+  data->should_prefer_opening_in_browser_ = preference;
+}
+
+bool DownloadItemModel::IsDangerousFileBasedOnType() const {
+  const DownloadItemModelData* data = DownloadItemModelData::Get(download_);
+  return data && data->is_dangerous_file_based_on_type_;
+}
+
+void DownloadItemModel::SetIsDangerousFileBasedOnType(bool dangerous) {
+  DownloadItemModelData* data = DownloadItemModelData::GetOrCreate(download_);
+  data->is_dangerous_file_based_on_type_ = dangerous;
 }
 
 base::string16 DownloadItemModel::GetProgressSizesString() const {
   base::string16 size_ratio;
   int64 size = GetCompletedBytes();
   int64 total = GetTotalBytes();
   if (total > 0) {
     ui::DataUnits amount_units = ui::GetByteDisplayUnits(total);
     base::string16 simple_size = ui::FormatBytesWithUnits(size, amount_units, false);
 
@@ skipping 72 matching lines @@
   if (!download_service)
     return;
 
   ChromeDownloadManagerDelegate* delegate =
       download_service->GetDownloadManagerDelegate();
   if (!delegate)
     return;
   delegate->OpenDownloadUsingPlatformHandler(download_);
   RecordDownloadOpenMethod(DOWNLOAD_OPEN_METHOD_USER_PLATFORM);
 }