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

chrome/browser/download/download_history.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.
 
 // DownloadHistory manages persisting DownloadItems to the history service by
 // observing a single DownloadManager and all its DownloadItems using an
 // AllDownloadItemNotifier.
 //
 // DownloadHistory decides whether and when to add items to, remove items from,
 // and update items in the database. DownloadHistory uses DownloadHistoryData to
@@ skipping 45 matching lines @@
     PERSISTING,
     PERSISTED,
   };
 
   static DownloadHistoryData* Get(content::DownloadItem* item) {
     base::SupportsUserData::Data* data = item->GetUserData(kKey);
     return (data == NULL) ? NULL :
       static_cast<DownloadHistoryData*>(data);
   }
 
+  static const DownloadHistoryData* Get(const content::DownloadItem* item) {
+    const base::SupportsUserData::Data* data = item->GetUserData(kKey);
+    return (data == NULL) ? NULL
+                          : static_cast<const DownloadHistoryData*>(data);
+  }
+
   explicit DownloadHistoryData(content::DownloadItem* item)
-    : state_(NOT_PERSISTED) {
+      : state_(NOT_PERSISTED),
+        was_restored_from_history_(false) {
     item->SetUserData(kKey, this);
   }
 
   virtual ~DownloadHistoryData() {
   }
 
   PersistenceState state() const { return state_; }
   void SetState(PersistenceState s) { state_ = s; }
 
+  bool was_restored_from_history() const { return was_restored_from_history_; }
+  void set_was_restored_from_history(bool value) {
+    was_restored_from_history_ = value;
+  }
+
   // This allows DownloadHistory::OnDownloadUpdated() to see what changed in a
   // DownloadItem if anything, in order to prevent writing to the database
   // unnecessarily.  It is nullified when the item is no longer in progress in
   // order to save memory.
   history::DownloadRow* info() { return info_.get(); }
   void set_info(const history::DownloadRow& i) {
     info_.reset(new history::DownloadRow(i));
   }
   void clear_info() {
     info_.reset();
   }
 
  private:
   static const char kKey[];
 
   PersistenceState state_;
   scoped_ptr<history::DownloadRow> info_;
+  bool was_restored_from_history_;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadHistoryData);
 };
 
 const char DownloadHistoryData::kKey[] =
   "DownloadItem DownloadHistoryData";
 
 history::DownloadRow GetDownloadRow(
     content::DownloadItem* item) {
   std::string by_ext_id, by_ext_name;
@@ skipping 71 matching lines @@
 
 void DownloadHistory::HistoryAdapter::RemoveDownloads(
     const std::set<uint32>& ids) {
   history_->RemoveDownloads(ids);
 }
 
 
 DownloadHistory::Observer::Observer() {}
 DownloadHistory::Observer::~Observer() {}
 
-bool DownloadHistory::IsPersisted(content::DownloadItem* item) {
-  DownloadHistoryData* data = DownloadHistoryData::Get(item);
+// static
+bool DownloadHistory::IsPersisted(const content::DownloadItem* item) {
+  const DownloadHistoryData* data = DownloadHistoryData::Get(item);
   return data && (data->state() == DownloadHistoryData::PERSISTED);
 }
 
 DownloadHistory::DownloadHistory(content::DownloadManager* manager,
                                  scoped_ptr<HistoryAdapter> history)
   : notifier_(manager, this),
     history_(history.Pass()),
     loading_id_(content::DownloadItem::kInvalidId),
     history_size_(0),
     weak_ptr_factory_(this) {
@@ skipping 17 matching lines @@
 void DownloadHistory::AddObserver(DownloadHistory::Observer* observer) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   observers_.AddObserver(observer);
 }
 
 void DownloadHistory::RemoveObserver(DownloadHistory::Observer* observer) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   observers_.RemoveObserver(observer);
 }
 
+bool DownloadHistory::WasRestoredFromHistory(
+    const content::DownloadItem* download) const {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  const DownloadHistoryData* data = DownloadHistoryData::Get(download);
+
+  // The OnDownloadCreated handler sets the was_restored_from_history flag when
+  // resetting the loading_id_. So one of the two conditions below will hold for
+  // a download restored from history even if the caller of this method is
+  // racing with our OnDownloadCreated handler.
+  return (data && data->was_restored_from_history()) ||
+         download->GetId() == loading_id_;
+}
+
 void DownloadHistory::QueryCallback(scoped_ptr<InfoVector> infos) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   // ManagerGoingDown() may have happened before the history loaded.
   if (!notifier_.GetManager())
     return;
   for (InfoVector::const_iterator it = infos->begin();
        it != infos->end(); ++it) {
     loading_id_ = it->id;
     content::DownloadItem* item = notifier_.GetManager()->CreateDownloadItem(
         loading_id_,
@@ skipping 10 matching lines @@
         it->state,
         it->danger_type,
         it->interrupt_reason,
         it->opened);
 #if !defined(OS_ANDROID)
     if (!it->by_ext_id.empty() && !it->by_ext_name.empty()) {
       new DownloadedByExtension(item, it->by_ext_id, it->by_ext_name);
       item->UpdateObservers();
     }
 #endif
-    DCHECK_EQ(DownloadHistoryData::Get(item)->state(),
-              DownloadHistoryData::PERSISTED);
+    DCHECK_EQ(DownloadHistoryData::PERSISTED,
+              DownloadHistoryData::Get(item)->state());
     ++history_size_;
   }
   notifier_.GetManager()->CheckForHistoryFilesRemoval();
 }
 
 void DownloadHistory::MaybeAddToHistory(content::DownloadItem* item) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   uint32 download_id = item->GetId();
   DownloadHistoryData* data = DownloadHistoryData::Get(item);
@@ skipping 71 matching lines @@
 
 void DownloadHistory::OnDownloadCreated(
     content::DownloadManager* manager, content::DownloadItem* item) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   // All downloads should pass through OnDownloadCreated exactly once.
   CHECK(!DownloadHistoryData::Get(item));
   DownloadHistoryData* data = new DownloadHistoryData(item);
   if (item->GetId() == loading_id_) {
     data->SetState(DownloadHistoryData::PERSISTED);
+    data->set_was_restored_from_history(true);
     loading_id_ = content::DownloadItem::kInvalidId;
   }
   if (item->GetState() == content::DownloadItem::IN_PROGRESS) {
     data->set_info(GetDownloadRow(item));
   }
   MaybeAddToHistory(item);
 }
 
 void DownloadHistory::OnDownloadUpdated(
     content::DownloadManager* manager, content::DownloadItem* item) {
@@ skipping 65 matching lines @@
   removing_ids_.insert(download_id);
 }
 
 void DownloadHistory::RemoveDownloadsBatch() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   IdSet remove_ids;
   removing_ids_.swap(remove_ids);
   history_->RemoveDownloads(remove_ids);
   FOR_EACH_OBSERVER(Observer, observers_, OnDownloadsRemoved(remove_ids));
 }