Use DownloadItemModel for storing chrome/ specific UI data for DownloadItems.

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/string16.h"
+#include "base/supports_user_data.h"
 #include "base/sys_string_conversions.h"
+#include "base/time.h"
 #include "base/utf_string_conversions.h"
-#include "base/time.h"
 #include "chrome/browser/download/download_crx_util.h"
 #include "chrome/common/time_format.h"
 #include "content/public/browser/download_danger_type.h"
 #include "content/public/browser/download_interrupt_reasons.h"
 #include "content/public/browser/download_item.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/text/bytes_formatting.h"
 #include "ui/base/text/text_elider.h"
 
 using base::TimeDelta;
 using content::DownloadItem;
 
 namespace {
 
+// Per DownloadItem data used by DownloadItemModel. The model doesn't keep any
+// state since there could be multiple models associated with a single
+// DownloadItem, and the lifetime of the model is shorter than the DownloadItem.
+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;
+  }
+
+ 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_;
+};
+
+// 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) {
+}
+
 string16 InterruptReasonStatusMessage(int reason) {
   int string_id = 0;
 
   switch (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:
       string_id = IDS_DOWNLOAD_INTERRUPTED_STATUS_DISK_FULL;
       break;
@@ skipping 121 matching lines @@
     : download_(download) {
 }
 
 DownloadItemModel::~DownloadItemModel() {
 }
 
 void DownloadItemModel::CancelTask() {
   download_->Cancel(true /* update history service */);
 }
 
+string16 DownloadItemModel::GetInterruptReasonText() const {
+  if (download_->GetState() != DownloadItem::INTERRUPTED ||
+      download_->GetLastReason() ==
+      content::DOWNLOAD_INTERRUPT_REASON_USER_CANCELED) {
+    return string16();
+  }
+  return InterruptReasonMessage(download_->GetLastReason());
+}
+
 string16 DownloadItemModel::GetStatusText() const {
   string16 status_text;
   switch (download_->GetState()) {
     case DownloadItem::IN_PROGRESS:
       status_text = GetInProgressStatusString();
       break;
     case DownloadItem::COMPLETE:
       if (download_->GetFileExternallyRemoved()) {
         status_text = l10n_util::GetStringUTF16(IDS_DOWNLOAD_STATUS_REMOVED);
       } else {
@@ skipping 16 matching lines @@
       }
       break;
     }
     default:
       NOTREACHED();
   }
 
   return status_text;
 }
 
-string16 DownloadItemModel::GetInterruptReasonText() const {
-  if (download_->GetState() != DownloadItem::INTERRUPTED ||
-      download_->GetLastReason() ==
-      content::DOWNLOAD_INTERRUPT_REASON_USER_CANCELED) {
-    return string16();
-  }
-  return InterruptReasonMessage(download_->GetLastReason());
-}
-
 string16 DownloadItemModel::GetTooltipText(const gfx::Font& font,
                                            int max_width) const {
   string16 tooltip = ui::ElideFilename(
       download_->GetFileNameToReportUser(), font, max_width);
   content::DownloadInterruptReason reason = download_->GetLastReason();
   if (download_->GetState() == DownloadItem::INTERRUPTED &&
       reason != content::DOWNLOAD_INTERRUPT_REASON_USER_CANCELED) {
     tooltip += ASCIIToUTF16("\n");
     tooltip += ui::ElideText(InterruptReasonStatusMessage(reason),
                              font, max_width, ui::ELIDE_AT_END);
   }
   return tooltip;
 }
 
-// TODO(asanka,rdsmith): Once 'open' moves exclusively to the
-//     ChromeDownloadManagerDelegate, we should calculate the percentage here
-//     instead of calling into the DownloadItem.
-int DownloadItemModel::PercentComplete() const {
-  return download_->PercentComplete();
-}
-
 string16 DownloadItemModel::GetWarningText(const gfx::Font& font,
                                            int base_width) const {
   // Should only be called if IsDangerous().
   DCHECK(IsDangerous());
   switch (download_->GetDangerType()) {
     case content::DOWNLOAD_DANGER_TYPE_DANGEROUS_URL:
       return l10n_util::GetStringUTF16(IDS_PROMPT_MALICIOUS_DOWNLOAD_URL);
 
     case content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE:
       if (download_crx_util::IsExtensionDownload(*download_)) {
@@ skipping 31 matching lines @@
   DCHECK(IsDangerous());
   if (download_->GetDangerType() ==
           content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE &&
       download_crx_util::IsExtensionDownload(*download_)) {
     return l10n_util::GetStringUTF16(IDS_CONTINUE_EXTENSION_DOWNLOAD);
   } else {
     return l10n_util::GetStringUTF16(IDS_CONFIRM_DOWNLOAD);
   }
 }
 
+int64 DownloadItemModel::GetCompletedBytes() const {
+  return download_->GetReceivedBytes();
+}
+
+int64 DownloadItemModel::GetTotalBytes() const {
+  return download_->AllDataSaved() ? download_->GetReceivedBytes() :
+                                     download_->GetTotalBytes();
+}
+
+// TODO(asanka,rdsmith): Once 'open' moves exclusively to the
+//     ChromeDownloadManagerDelegate, we should calculate the percentage here
+//     instead of calling into the DownloadItem.

[Randy Smith (Not in Mondays), 2012/12/08 19:37:16]

Despite the fact that this is just copied, the indentation looks wrong to me. 
If you agree, could you fix it?  (If not, don't worry about it.)

[asanka, 2012/12/10 16:30:36]

I originally added the +4 indent here because the subsequent lines are
continuation of the TODO description.

I didn't find anything in the style guide about this and changing the indent
doesn't affect the word wrapping. So I think I'll leave it as-is.

+int DownloadItemModel::PercentComplete() const {
+  return download_->PercentComplete();
+}
+
+bool DownloadItemModel::IsDangerous() const {
+  return download_->GetSafetyState() == DownloadItem::DANGEROUS;
+}
+
 bool DownloadItemModel::IsMalicious() const {
   if (!IsDangerous())
     return false;
   switch (download_->GetDangerType()) {
     case content::DOWNLOAD_DANGER_TYPE_DANGEROUS_URL:
     case content::DOWNLOAD_DANGER_TYPE_DANGEROUS_CONTENT:
     case content::DOWNLOAD_DANGER_TYPE_UNCOMMON_CONTENT:
       return true;
 
     case content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS:
     case content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT:
     case content::DOWNLOAD_DANGER_TYPE_MAX:
       // We shouldn't get any of these due to the IsDangerous() test above.
       NOTREACHED();
       // Fallthrough.
     case content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE:
       return false;
   }
   NOTREACHED();
   return false;
 }
 
-bool DownloadItemModel::IsDangerous() const {
-  return download_->GetSafetyState() == DownloadItem::DANGEROUS;
+bool DownloadItemModel::ShouldShowInShelf() const {
+  const DownloadItemModelData* data = DownloadItemModelData::Get(download_);
+  return !data || data->should_show_in_shelf();
 }
 
-int64 DownloadItemModel::GetTotalBytes() const {
-  return download_->AllDataSaved() ? download_->GetReceivedBytes() :
-                                     download_->GetTotalBytes();
-}
-
-int64 DownloadItemModel::GetCompletedBytes() const {
-  return download_->GetReceivedBytes();
+void DownloadItemModel::SetShouldShowInShelf(bool should_show) {
+  DownloadItemModelData* data = DownloadItemModelData::GetOrCreate(download_);
+  data->set_should_show_in_shelf(should_show);
 }
 
 string16 DownloadItemModel::GetProgressSizesString() const {
   string16 size_ratio;
   int64 size = GetCompletedBytes();
   int64 total = GetTotalBytes();
   if (total > 0) {
     ui::DataUnits amount_units = ui::GetByteDisplayUnits(total);
     string16 simple_size = ui::FormatBytesWithUnits(size, amount_units, false);
 
@@ skipping 55 matching lines @@
   }
 
   // In progress download with no known time left and non-zero completed bytes:
   // "100/120 MB" or "100 MB"
   if (GetCompletedBytes() > 0)
     return size_ratio;
 
   // Instead of displaying "0 B" we say "Starting..."
   return l10n_util::GetStringUTF16(IDS_DOWNLOAD_STATUS_STARTING);
 }