Persist download interrupt reason, both target and current paths, and url_chain.

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 95 matching lines @@
 
 const char DownloadHistoryData::kKey[] =
   "DownloadItem DownloadHistoryData";
 
 history::DownloadRow GetDownloadRow(
     content::DownloadItem* item) {
   // TODO(asanka): Persist GetTargetFilePath() as well.
   DownloadHistoryData* data = DownloadHistoryData::Get(item);
   return history::DownloadRow(
       item->GetFullPath(),
-      item->GetURL(),
+      item->GetTargetFilePath(),
+      item->GetUrlChain(),
       item->GetReferrerUrl(),
       item->GetStartTime(),
       item->GetEndTime(),
       item->GetReceivedBytes(),
       item->GetTotalBytes(),
       item->GetState(),
+      item->GetLastReason(),
       ((data != NULL) ? data->db_handle()
        : history::DownloadDatabase::kUninitializedHandle),
       item->GetOpened());
 }
 
 bool ShouldUpdateHistory(const history::DownloadRow* previous,
                          const history::DownloadRow& current) {
   // Ignore url, referrer, start_time, db_handle, which don't change.
   return ((previous == NULL) ||
-          (previous->path != current.path) ||
+          (previous->current_path != current.current_path) ||
+          (previous->target_path != current.target_path) ||
           (previous->end_time != current.end_time) ||
           (previous->received_bytes != current.received_bytes) ||
           (previous->total_bytes != current.total_bytes) ||
           (previous->state != current.state) ||
+          (previous->interrupt_reason != current.interrupt_reason) ||
           (previous->opened != current.opened));
 }
 
 typedef std::vector<history::DownloadRow> InfoVector;
 
 }  // anonymous namespace
 
 DownloadHistory::HistoryAdapter::HistoryAdapter(HistoryService* history)
   : history_(history) {
 }
@@ skipping 70 matching lines @@
   if (!notifier_.GetManager())
     return;
   for (InfoVector::const_iterator it = infos->begin();
        it != infos->end(); ++it) {
     // OnDownloadCreated() is called inside DM::CreateDownloadItem(), so set
     // loading_db_handle_ to match up the created item with its db_handle.  All
     // methods run on the UI thread and CreateDownloadItem() is synchronous.
     loading_db_handle_ = it->db_handle;
     content::DownloadItem* download_item =
       notifier_.GetManager()->CreateDownloadItem(
-        it->path,
-        it->url,
+        it->current_path,
+        it->target_path,
+        it->url_chain,
         it->referrer_url,
         it->start_time,
         it->end_time,
         it->received_bytes,
         it->total_bytes,
         it->state,
+        it->interrupt_reason,
         it->opened);
     DownloadHistoryData* data = DownloadHistoryData::Get(download_item);
 
     // If this DCHECK fails, then you probably added an Observer that
     // synchronously creates a DownloadItem in response to
     // DownloadManager::OnDownloadCreated(), and your observer runs before
     // DownloadHistory, and DownloadManager creates items synchronously. Just
     // bounce your DownloadItem creation off the message loop to flush
     // DownloadHistory::OnDownloadCreated.
     DCHECK_EQ(it->db_handle, data->db_handle());
@@ skipping 175 matching lines @@
 
 void DownloadHistory::RemoveDownloadsBatch() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   HandleSet remove_handles;
   IdSet remove_ids;
   removing_handles_.swap(remove_handles);
   removing_ids_.swap(remove_ids);
   history_->RemoveDownloads(remove_handles);
   FOR_EACH_OBSERVER(Observer, observers_, OnDownloadsRemoved(remove_ids));
 }