[Downloads] Ask DownloadHistory if a download was from history.

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"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/supports_user_data.h"
 #include "base/time/time.h"
 #include "chrome/browser/download/chrome_download_manager_delegate.h"
 #include "chrome/browser/download/download_crx_util.h"
+#include "chrome/browser/download/download_history.h"
 #include "chrome/browser/download/download_service.h"
 #include "chrome/browser/download/download_service_factory.h"
 #include "chrome/browser/download/download_stats.h"
+#include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/safe_browsing/download_feedback_service.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/l10n/time_format.h"
 #include "ui/base/text/bytes_formatting.h"
 #include "ui/gfx/text_elider.h"
@@ skipping 14 matching lines @@
 
   // 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 should_notify_ui() const { return should_notify_ui_; }
-  void set_should_notify_ui(bool should_notify_ui) {
-    should_notify_ui_ = should_notify_ui;
+  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 should be notified when the download is ready to be
-  // presented.
-  bool should_notify_ui_;
+  // 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_;
 };
 
 // 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),
-      should_notify_ui_(false),
+      was_ui_notified_(false),
       should_prefer_opening_in_browser_(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;
@@ skipping 430 matching lines @@
   const DownloadItemModelData* data = DownloadItemModelData::Get(download_);
   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);
 }
 
 bool DownloadItemModel::ShouldNotifyUI() const {
-  const DownloadItemModelData* data = DownloadItemModelData::Get(download_);
-  return data && data->should_notify_ui();
+  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_);
 }
 
-void DownloadItemModel::SetShouldNotifyUI(bool should_notify) {
+bool DownloadItemModel::WasUINotified() const {
+  const DownloadItemModelData* data = DownloadItemModelData::Get(download_);
+  return data && data->was_ui_notified();
+}
+
+void DownloadItemModel::SetWasUINotified(bool was_ui_notified) {
   DownloadItemModelData* data = DownloadItemModelData::GetOrCreate(download_);
-  data->set_should_notify_ui(should_notify);
+  data->set_was_ui_notified(was_ui_notified);
 }
 
 bool DownloadItemModel::ShouldPreferOpeningInBrowser() const {
   const DownloadItemModelData* data = DownloadItemModelData::Get(download_);
   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);
@@ skipping 82 matching lines @@
   if (!download_service)
     return;
 
   ChromeDownloadManagerDelegate* delegate =
       download_service->GetDownloadManagerDelegate();
   if (!delegate)
     return;
   delegate->OpenDownloadUsingPlatformHandler(download_);
   RecordDownloadOpenMethod(DOWNLOAD_OPEN_METHOD_USER_PLATFORM);
 }