chrome/browser/download/download_history_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <vector>
   6
   7 #include "base/memory/weak_ptr.h"
   8 #include "base/rand_util.h"
   9 #include "base/stl_util.h"
  10 #include "chrome/browser/download/download_history.h"
  11 #include "chrome/browser/history/download_database.h"
  12 #include "chrome/browser/history/download_row.h"
  13 #include "chrome/browser/history/history_service.h"
  14 #include "content/public/test/mock_download_item.h"
  15 #include "content/public/test/mock_download_manager.h"
  16 #include "content/public/test/test_browser_thread.h"
  17 #include "content/public/test/test_utils.h"
  18 #include "testing/gtest/include/gtest/gtest.h"
  19
  20 #if defined(ENABLE_EXTENSIONS)
  21 #include "chrome/browser/extensions/api/downloads/downloads_api.h"
  22 #endif
  23
  24 using testing::DoAll;
  25 using testing::Invoke;
  26 using testing::Return;
  27 using testing::ReturnRefOfCopy;
  28 using testing::SetArgPointee;
  29 using testing::WithArg;
  30 using testing::_;
  31
  32 namespace {
  33
  34 void CheckInfoEqual(const history::DownloadRow& left,
  35                     const history::DownloadRow& right) {
  36   EXPECT_EQ(left.current_path.value(), right.current_path.value());
  37   EXPECT_EQ(left.target_path.value(), right.target_path.value());
  38   EXPECT_EQ(left.url_chain.size(), right.url_chain.size());
  39   for (unsigned int i = 0;
  40        i < left.url_chain.size() && i < right.url_chain.size();
  41        ++i) {
  42     EXPECT_EQ(left.url_chain[i].spec(), right.url_chain[i].spec());
  43   }
  44   EXPECT_EQ(left.referrer_url.spec(), right.referrer_url.spec());
  45   EXPECT_EQ(left.mime_type, right.mime_type);
  46   EXPECT_EQ(left.original_mime_type, right.original_mime_type);
  47   EXPECT_EQ(left.start_time.ToTimeT(), right.start_time.ToTimeT());
  48   EXPECT_EQ(left.end_time.ToTimeT(), right.end_time.ToTimeT());
  49   EXPECT_EQ(left.etag, right.etag);
  50   EXPECT_EQ(left.last_modified, right.last_modified);
  51   EXPECT_EQ(left.received_bytes, right.received_bytes);
  52   EXPECT_EQ(left.total_bytes, right.total_bytes);
  53   EXPECT_EQ(left.state, right.state);
  54   EXPECT_EQ(left.danger_type, right.danger_type);
  55   EXPECT_EQ(left.id, right.id);
  56   EXPECT_EQ(left.opened, right.opened);
  57   EXPECT_EQ(left.by_ext_id, right.by_ext_id);
  58   EXPECT_EQ(left.by_ext_name, right.by_ext_name);
  59 }
  60
  61 typedef DownloadHistory::IdSet IdSet;
  62 typedef std::vector<history::DownloadRow> InfoVector;
  63 typedef testing::StrictMock<content::MockDownloadItem> StrictMockDownloadItem;
  64
  65 class FakeHistoryAdapter : public DownloadHistory::HistoryAdapter {
  66  public:
  67   FakeHistoryAdapter()
  68     : DownloadHistory::HistoryAdapter(NULL),
  69       slow_create_download_(false),
  70       fail_create_download_(false) {
  71   }
  72
  73   virtual ~FakeHistoryAdapter() {}
  74
  75   virtual void QueryDownloads(
  76       const HistoryService::DownloadQueryCallback& callback) OVERRIDE {
  77     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
  78     content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
  79         base::Bind(&FakeHistoryAdapter::QueryDownloadsDone,
  80             base::Unretained(this), callback));
  81   }
  82
  83   void QueryDownloadsDone(
  84       const HistoryService::DownloadQueryCallback& callback) {
  85     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
  86     CHECK(expect_query_downloads_.get());
  87     callback.Run(expect_query_downloads_.Pass());
  88   }
  89
  90   void set_slow_create_download(bool slow) { slow_create_download_ = slow; }
  91
  92   virtual void CreateDownload(
  93       const history::DownloadRow& info,
  94       const HistoryService::DownloadCreateCallback& callback) OVERRIDE {
  95     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
  96     create_download_info_ = info;
  97     // Must not call CreateDownload() again before FinishCreateDownload()!
  98     DCHECK(create_download_callback_.is_null());
  99     create_download_callback_ = base::Bind(callback, !fail_create_download_);
 100     fail_create_download_ = false;
 101     if (!slow_create_download_)
 102       FinishCreateDownload();
 103   }
 104
 105   void FinishCreateDownload() {
 106     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 107     create_download_callback_.Run();
 108     create_download_callback_.Reset();
 109   }
 110
 111   virtual void UpdateDownload(
 112       const history::DownloadRow& info) OVERRIDE {
 113     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 114     update_download_ = info;
 115   }
 116
 117   virtual void RemoveDownloads(const IdSet& ids) OVERRIDE {
 118     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 119     for (IdSet::const_iterator it = ids.begin();
 120          it != ids.end(); ++it) {
 121       remove_downloads_.insert(*it);
 122     }
 123   }
 124
 125   void ExpectWillQueryDownloads(scoped_ptr<InfoVector> infos) {
 126     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 127     expect_query_downloads_ = infos.Pass();
 128   }
 129
 130   void ExpectQueryDownloadsDone() {
 131     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 132     EXPECT_TRUE(NULL == expect_query_downloads_.get());
 133   }
 134
 135   void FailCreateDownload() {
 136     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 137     fail_create_download_ = true;
 138   }
 139
 140   void ExpectDownloadCreated(
 141       const history::DownloadRow& info) {
 142     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 143     content::RunAllPendingInMessageLoop(content::BrowserThread::UI);
 144     CheckInfoEqual(info, create_download_info_);
 145     create_download_info_ = history::DownloadRow();
 146   }
 147
 148   void ExpectNoDownloadCreated() {
 149     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 150     content::RunAllPendingInMessageLoop(content::BrowserThread::UI);
 151     CheckInfoEqual(history::DownloadRow(), create_download_info_);
 152   }
 153
 154   void ExpectDownloadUpdated(const history::DownloadRow& info) {
 155     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 156     content::RunAllPendingInMessageLoop(content::BrowserThread::UI);
 157     CheckInfoEqual(update_download_, info);
 158     update_download_ = history::DownloadRow();
 159   }
 160
 161   void ExpectNoDownloadUpdated() {
 162     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 163     content::RunAllPendingInMessageLoop(content::BrowserThread::UI);
 164     CheckInfoEqual(history::DownloadRow(), update_download_);
 165   }
 166
 167   void ExpectNoDownloadsRemoved() {
 168     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 169     content::RunAllPendingInMessageLoop(content::BrowserThread::UI);
 170     EXPECT_EQ(0, static_cast<int>(remove_downloads_.size()));
 171   }
 172
 173   void ExpectDownloadsRemoved(const IdSet& ids) {
 174     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 175     content::RunAllPendingInMessageLoop(content::BrowserThread::UI);
 176     IdSet differences = base::STLSetDifference<IdSet>(ids, remove_downloads_);
 177     for (IdSet::const_iterator different = differences.begin();
 178          different != differences.end(); ++different) {
 179       EXPECT_TRUE(false) << *different;
 180     }
 181     remove_downloads_.clear();
 182   }
 183
 184  private:
 185   bool slow_create_download_;
 186   bool fail_create_download_;
 187   base::Closure create_download_callback_;
 188   history::DownloadRow update_download_;
 189   scoped_ptr<InfoVector> expect_query_downloads_;
 190   IdSet remove_downloads_;
 191   history::DownloadRow create_download_info_;
 192
 193   DISALLOW_COPY_AND_ASSIGN(FakeHistoryAdapter);
 194 };
 195
 196 class DownloadHistoryTest : public testing::Test {
 197  public:
 198   // Generic callback that receives a pointer to a StrictMockDownloadItem.
 199   typedef base::Callback<void(content::MockDownloadItem*)> DownloadItemCallback;
 200
 201   DownloadHistoryTest()
 202       : ui_thread_(content::BrowserThread::UI, &loop_),
 203         manager_(new content::MockDownloadManager()),
 204         history_(NULL),
 205         manager_observer_(NULL),
 206         download_created_index_(0) {}
 207   virtual ~DownloadHistoryTest() {
 208     STLDeleteElements(&items_);
 209   }
 210
 211  protected:
 212   virtual void TearDown() OVERRIDE {
 213     download_history_.reset();
 214   }
 215
 216   content::MockDownloadManager& manager() { return *manager_.get(); }
 217   content::MockDownloadItem& item(size_t index) { return *items_[index]; }
 218   DownloadHistory* download_history() { return download_history_.get(); }
 219
 220   void SetManagerObserver(
 221       content::DownloadManager::Observer* manager_observer) {
 222     manager_observer_ = manager_observer;
 223   }
 224   content::DownloadManager::Observer* manager_observer() {
 225     return manager_observer_;
 226   }
 227
 228   void CreateDownloadHistory(scoped_ptr<InfoVector> infos) {
 229     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 230     CHECK(infos.get());
 231     EXPECT_CALL(manager(), AddObserver(_)).WillOnce(WithArg<0>(Invoke(
 232         this, &DownloadHistoryTest::SetManagerObserver)));
 233     EXPECT_CALL(manager(), RemoveObserver(_));
 234     download_created_index_ = 0;
 235     for (size_t index = 0; index < infos->size(); ++index) {
 236       content::MockDownloadManager::CreateDownloadItemAdapter adapter(
 237           infos->at(index).id,
 238           infos->at(index).current_path,
 239           infos->at(index).target_path,
 240           infos->at(index).url_chain,
 241           infos->at(index).referrer_url,
 242           infos->at(index).mime_type,
 243           infos->at(index).original_mime_type,
 244           infos->at(index).start_time,
 245           infos->at(index).end_time,
 246           infos->at(index).etag,
 247           infos->at(index).last_modified,
 248           infos->at(index).received_bytes,
 249           infos->at(index).total_bytes,
 250           infos->at(index).state,
 251           infos->at(index).danger_type,
 252           infos->at(index).interrupt_reason,
 253           infos->at(index).opened);
 254       EXPECT_CALL(manager(), MockCreateDownloadItem(adapter))
 255         .WillOnce(DoAll(
 256             InvokeWithoutArgs(
 257                 this, &DownloadHistoryTest::CallOnDownloadCreatedInOrder),
 258             Return(&item(index))));
 259     }
 260     EXPECT_CALL(manager(), CheckForHistoryFilesRemoval());
 261     history_ = new FakeHistoryAdapter();
 262     history_->ExpectWillQueryDownloads(infos.Pass());
 263     EXPECT_CALL(*manager_.get(), GetAllDownloads(_)).WillRepeatedly(Return());
 264     download_history_.reset(new DownloadHistory(
 265         &manager(), scoped_ptr<DownloadHistory::HistoryAdapter>(history_)));
 266     content::RunAllPendingInMessageLoop(content::BrowserThread::UI);
 267     history_->ExpectQueryDownloadsDone();
 268   }
 269
 270   void CallOnDownloadCreated(size_t index) {
 271     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 272     if (!pre_on_create_handler_.is_null())
 273       pre_on_create_handler_.Run(&item(index));
 274     manager_observer()->OnDownloadCreated(&manager(), &item(index));
 275     if (!post_on_create_handler_.is_null())
 276       post_on_create_handler_.Run(&item(index));
 277   }
 278
 279   void CallOnDownloadCreatedInOrder() {
 280     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 281     // Gmock doesn't appear to support something like InvokeWithTheseArgs. Maybe
 282     // gmock needs to learn about base::Callback.
 283     CallOnDownloadCreated(download_created_index_++);
 284   }
 285
 286   void set_slow_create_download(bool slow) {
 287     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 288     history_->set_slow_create_download(slow);
 289   }
 290
 291   void FinishCreateDownload() {
 292     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 293     history_->FinishCreateDownload();
 294   }
 295
 296   void FailCreateDownload() {
 297     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 298     history_->FailCreateDownload();
 299   }
 300
 301   void ExpectDownloadCreated(
 302       const history::DownloadRow& info) {
 303     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 304     history_->ExpectDownloadCreated(info);
 305   }
 306
 307   void ExpectNoDownloadCreated() {
 308     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 309     history_->ExpectNoDownloadCreated();
 310   }
 311
 312   void ExpectDownloadUpdated(const history::DownloadRow& info) {
 313     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 314     history_->ExpectDownloadUpdated(info);
 315   }
 316
 317   void ExpectNoDownloadUpdated() {
 318     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 319     history_->ExpectNoDownloadUpdated();
 320   }
 321
 322   void ExpectNoDownloadsRemoved() {
 323     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 324     history_->ExpectNoDownloadsRemoved();
 325   }
 326
 327   void ExpectDownloadsRemoved(const IdSet& ids) {
 328     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 329     history_->ExpectDownloadsRemoved(ids);
 330   }
 331
 332   void ExpectDownloadsRestoredFromHistory(bool expected_value) {
 333     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 334     pre_on_create_handler_ =
 335         base::Bind(&DownloadHistoryTest::CheckDownloadWasRestoredFromHistory,
 336                    base::Unretained(this),
 337                    expected_value);
 338     post_on_create_handler_ =
 339         base::Bind(&DownloadHistoryTest::CheckDownloadWasRestoredFromHistory,
 340                    base::Unretained(this),
 341                    expected_value);
 342   }
 343
 344   void InitBasicItem(const base::FilePath::CharType* path,
 345                      const char* url_string,
 346                      const char* referrer_string,
 347                      history::DownloadRow* info) {
 348     GURL url(url_string);
 349     GURL referrer(referrer_string);
 350     std::vector<GURL> url_chain;
 351     url_chain.push_back(url);
 352     InitItem(static_cast<uint32>(items_.size() + 1),
 353              base::FilePath(path),
 354              base::FilePath(path),
 355              url_chain,
 356              referrer,
 357              "application/octet-stream",
 358              "application/octet-stream",
 359              (base::Time::Now() - base::TimeDelta::FromMinutes(10)),
 360              (base::Time::Now() - base::TimeDelta::FromMinutes(1)),
 361              "Etag",
 362              "abc",
 363              100,
 364              100,
 365              content::DownloadItem::COMPLETE,
 366              content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
 367              content::DOWNLOAD_INTERRUPT_REASON_NONE,
 368              false,
 369              std::string(),
 370              std::string(),
 371              info);
 372   }
 373
 374   void InitItem(
 375       uint32 id,
 376       const base::FilePath& current_path,
 377       const base::FilePath& target_path,
 378       const std::vector<GURL>& url_chain,
 379       const GURL& referrer,
 380       const std::string& mime_type,
 381       const std::string& original_mime_type,
 382       const base::Time& start_time,
 383       const base::Time& end_time,
 384       const std::string& etag,
 385       const std::string& last_modified,
 386       int64 received_bytes,
 387       int64 total_bytes,
 388       content::DownloadItem::DownloadState state,
 389       content::DownloadDangerType danger_type,
 390       content::DownloadInterruptReason interrupt_reason,
 391       bool opened,
 392       const std::string& by_extension_id,
 393       const std::string& by_extension_name,
 394       history::DownloadRow* info) {
 395     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 396
 397     size_t index = items_.size();
 398     StrictMockDownloadItem* mock_item = new StrictMockDownloadItem();
 399     items_.push_back(mock_item);
 400
 401     info->current_path = current_path;
 402     info->target_path = target_path;
 403     info->url_chain = url_chain;
 404     info->referrer_url = referrer;
 405     info->mime_type = mime_type;
 406     info->original_mime_type = original_mime_type;
 407     info->start_time = start_time;
 408     info->end_time = end_time;
 409     info->etag = etag;
 410     info->last_modified = last_modified;
 411     info->received_bytes = received_bytes;
 412     info->total_bytes = total_bytes;
 413     info->state = state;
 414     info->danger_type = danger_type;
 415     info->interrupt_reason = interrupt_reason;
 416     info->id = id;
 417     info->opened = opened;
 418     info->by_ext_id = by_extension_id;
 419     info->by_ext_name = by_extension_name;
 420
 421     EXPECT_CALL(item(index), GetId()).WillRepeatedly(Return(id));
 422     EXPECT_CALL(item(index), GetFullPath())
 423         .WillRepeatedly(ReturnRefOfCopy(current_path));
 424     EXPECT_CALL(item(index), GetTargetFilePath())
 425         .WillRepeatedly(ReturnRefOfCopy(target_path));
 426     DCHECK_LE(1u, url_chain.size());
 427     EXPECT_CALL(item(index), GetURL())
 428         .WillRepeatedly(ReturnRefOfCopy(url_chain[0]));
 429     EXPECT_CALL(item(index), GetUrlChain())
 430         .WillRepeatedly(ReturnRefOfCopy(url_chain));
 431     EXPECT_CALL(item(index), GetMimeType()).WillRepeatedly(Return(mime_type));
 432     EXPECT_CALL(item(index), GetOriginalMimeType()).WillRepeatedly(Return(
 433         original_mime_type));
 434     EXPECT_CALL(item(index), GetReferrerUrl())
 435         .WillRepeatedly(ReturnRefOfCopy(referrer));
 436     EXPECT_CALL(item(index), GetStartTime()).WillRepeatedly(Return(start_time));
 437     EXPECT_CALL(item(index), GetEndTime()).WillRepeatedly(Return(end_time));
 438     EXPECT_CALL(item(index), GetETag()).WillRepeatedly(ReturnRefOfCopy(etag));
 439     EXPECT_CALL(item(index), GetLastModifiedTime())
 440         .WillRepeatedly(ReturnRefOfCopy(last_modified));
 441     EXPECT_CALL(item(index), GetReceivedBytes())
 442         .WillRepeatedly(Return(received_bytes));
 443     EXPECT_CALL(item(index), GetTotalBytes())
 444         .WillRepeatedly(Return(total_bytes));
 445     EXPECT_CALL(item(index), GetState()).WillRepeatedly(Return(state));
 446     EXPECT_CALL(item(index), GetDangerType())
 447         .WillRepeatedly(Return(danger_type));
 448     EXPECT_CALL(item(index), GetLastReason())
 449         .WillRepeatedly(Return(interrupt_reason));
 450     EXPECT_CALL(item(index), GetOpened()).WillRepeatedly(Return(opened));
 451     EXPECT_CALL(item(index), GetTargetDisposition())
 452         .WillRepeatedly(
 453             Return(content::DownloadItem::TARGET_DISPOSITION_OVERWRITE));
 454     EXPECT_CALL(manager(), GetDownload(id))
 455         .WillRepeatedly(Return(&item(index)));
 456     EXPECT_CALL(item(index), IsTemporary()).WillRepeatedly(Return(false));
 457 #if defined(ENABLE_EXTENSIONS)
 458     new extensions::DownloadedByExtension(
 459         &item(index), by_extension_id, by_extension_name);
 460 #endif
 461
 462     std::vector<content::DownloadItem*> items;
 463     for (size_t i = 0; i < items_.size(); ++i) {
 464       items.push_back(&item(i));
 465     }
 466     EXPECT_CALL(*manager_.get(), GetAllDownloads(_))
 467         .WillRepeatedly(SetArgPointee<0>(items));
 468   }
 469
 470  private:
 471   void CheckDownloadWasRestoredFromHistory(bool expected_value,
 472                                            content::MockDownloadItem* item) {
 473     ASSERT_TRUE(download_history_.get());
 474     EXPECT_EQ(expected_value, download_history_->WasRestoredFromHistory(item));
 475   }
 476
 477   base::MessageLoopForUI loop_;
 478   content::TestBrowserThread ui_thread_;
 479   std::vector<StrictMockDownloadItem*> items_;
 480   scoped_ptr<content::MockDownloadManager> manager_;
 481   FakeHistoryAdapter* history_;
 482   scoped_ptr<DownloadHistory> download_history_;
 483   content::DownloadManager::Observer* manager_observer_;
 484   size_t download_created_index_;
 485   DownloadItemCallback pre_on_create_handler_;
 486   DownloadItemCallback post_on_create_handler_;
 487
 488   DISALLOW_COPY_AND_ASSIGN(DownloadHistoryTest);
 489 };
 490
 491 // Test loading an item from the database, changing it, saving it back, removing
 492 // it.
 493 TEST_F(DownloadHistoryTest, DownloadHistoryTest_Load) {
 494   // Load a download from history, create the item, OnDownloadCreated,
 495   // OnDownloadUpdated, OnDownloadRemoved.
 496   history::DownloadRow info;
 497   InitBasicItem(FILE_PATH_LITERAL("/foo/bar.pdf"),
 498                 "http://example.com/bar.pdf",
 499                 "http://example.com/referrer.html",
 500                 &info);
 501   {
 502     scoped_ptr<InfoVector> infos(new InfoVector());
 503     infos->push_back(info);
 504     CreateDownloadHistory(infos.Pass());
 505     ExpectNoDownloadCreated();
 506   }
 507   EXPECT_TRUE(DownloadHistory::IsPersisted(&item(0)));
 508
 509   // Pretend that something changed on the item.
 510   EXPECT_CALL(item(0), GetOpened()).WillRepeatedly(Return(true));
 511   item(0).NotifyObserversDownloadUpdated();
 512   info.opened = true;
 513   ExpectDownloadUpdated(info);
 514
 515   // Pretend that the user removed the item.
 516   IdSet ids;
 517   ids.insert(info.id);
 518   item(0).NotifyObserversDownloadRemoved();
 519   ExpectDownloadsRemoved(ids);
 520 }
 521
 522 // Test that WasRestoredFromHistory accurately identifies downloads that were
 523 // created from history, even during an OnDownloadCreated() handler.
 524 TEST_F(DownloadHistoryTest, DownloadHistoryTest_WasRestoredFromHistory_True) {
 525   // This sets DownloadHistoryTest to call DH::WasRestoredFromHistory() both
 526   // before and after DH::OnDownloadCreated() is called. At each call, the
 527   // expected return value is |true| since the download was restored from
 528   // history.
 529   ExpectDownloadsRestoredFromHistory(true);
 530
 531   // Construct a DownloadHistory with a single history download. This results in
 532   // DownloadManager::CreateDownload() being called for the restored download.
 533   // The above test expectation should verify that the value of
 534   // WasRestoredFromHistory is correct for this download.
 535   history::DownloadRow info;
 536   InitBasicItem(FILE_PATH_LITERAL("/foo/bar.pdf"),
 537                 "http://example.com/bar.pdf",
 538                 "http://example.com/referrer.html",
 539                 &info);
 540   scoped_ptr<InfoVector> infos(new InfoVector());
 541   infos->push_back(info);
 542   CreateDownloadHistory(infos.Pass());
 543
 544   EXPECT_TRUE(DownloadHistory::IsPersisted(&item(0)));
 545 }
 546
 547 // Test that WasRestoredFromHistory accurately identifies downloads that were
 548 // not created from history.
 549 TEST_F(DownloadHistoryTest, DownloadHistoryTest_WasRestoredFromHistory_False) {
 550   // This sets DownloadHistoryTest to call DH::WasRestoredFromHistory() both
 551   // before and after DH::OnDownloadCreated() is called. At each call, the
 552   // expected return value is |true| since the download was restored from
 553   // history.
 554   ExpectDownloadsRestoredFromHistory(false);
 555
 556   // Create a DownloadHistory with no history downloads. No
 557   // DownloadManager::CreateDownload() calls are expected.
 558   CreateDownloadHistory(scoped_ptr<InfoVector>(new InfoVector()));
 559
 560   // Notify DownloadHistory that a new download was created. The above test
 561   // expecation should verify that WasRestoredFromHistory is correct for this
 562   // download.
 563   history::DownloadRow info;
 564   InitBasicItem(FILE_PATH_LITERAL("/foo/bar.pdf"),
 565                 "http://example.com/bar.pdf",
 566                 "http://example.com/referrer.html",
 567                 &info);
 568   CallOnDownloadCreated(0);
 569   ExpectDownloadCreated(info);
 570 }
 571
 572 // Test creating an item, saving it to the database, changing it, saving it
 573 // back, removing it.
 574 TEST_F(DownloadHistoryTest, DownloadHistoryTest_Create) {
 575   // Create a fresh item not from history, OnDownloadCreated, OnDownloadUpdated,
 576   // OnDownloadRemoved.
 577   CreateDownloadHistory(scoped_ptr<InfoVector>(new InfoVector()));
 578
 579   history::DownloadRow info;
 580   InitBasicItem(FILE_PATH_LITERAL("/foo/bar.pdf"),
 581                 "http://example.com/bar.pdf",
 582                 "http://example.com/referrer.html",
 583                 &info);
 584
 585   // Pretend the manager just created |item|.
 586   CallOnDownloadCreated(0);
 587   ExpectDownloadCreated(info);
 588   EXPECT_TRUE(DownloadHistory::IsPersisted(&item(0)));
 589
 590   // Pretend that something changed on the item.
 591   EXPECT_CALL(item(0), GetOpened()).WillRepeatedly(Return(true));
 592   item(0).NotifyObserversDownloadUpdated();
 593   info.opened = true;
 594   ExpectDownloadUpdated(info);
 595
 596   // Pretend that the user removed the item.
 597   IdSet ids;
 598   ids.insert(info.id);
 599   item(0).NotifyObserversDownloadRemoved();
 600   ExpectDownloadsRemoved(ids);
 601 }
 602
 603 // Test that changes to persisted fields in a DownloadItem triggers database
 604 // updates.
 605 TEST_F(DownloadHistoryTest, DownloadHistoryTest_Update) {
 606   CreateDownloadHistory(scoped_ptr<InfoVector>(new InfoVector()));
 607
 608   history::DownloadRow info;
 609   InitBasicItem(FILE_PATH_LITERAL("/foo/bar.pdf"),
 610                 "http://example.com/bar.pdf",
 611                 "http://example.com/referrer.html",
 612                 &info);
 613   CallOnDownloadCreated(0);
 614   ExpectDownloadCreated(info);
 615   EXPECT_TRUE(DownloadHistory::IsPersisted(&item(0)));
 616
 617   base::FilePath new_path(FILE_PATH_LITERAL("/foo/baz.txt"));
 618   base::Time new_time(base::Time::Now());
 619   std::string new_etag("new etag");
 620   std::string new_last_modifed("new last modified");
 621
 622   // current_path
 623   EXPECT_CALL(item(0), GetFullPath()).WillRepeatedly(ReturnRefOfCopy(new_path));
 624   info.current_path = new_path;
 625   item(0).NotifyObserversDownloadUpdated();
 626   ExpectDownloadUpdated(info);
 627
 628   // target_path
 629   EXPECT_CALL(item(0), GetTargetFilePath())
 630       .WillRepeatedly(ReturnRefOfCopy(new_path));
 631   info.target_path = new_path;
 632   item(0).NotifyObserversDownloadUpdated();
 633   ExpectDownloadUpdated(info);
 634
 635   // end_time
 636   EXPECT_CALL(item(0), GetEndTime()).WillRepeatedly(Return(new_time));
 637   info.end_time = new_time;
 638   item(0).NotifyObserversDownloadUpdated();
 639   ExpectDownloadUpdated(info);
 640
 641   // received_bytes
 642   EXPECT_CALL(item(0), GetReceivedBytes()).WillRepeatedly(Return(101));
 643   info.received_bytes = 101;
 644   item(0).NotifyObserversDownloadUpdated();
 645   ExpectDownloadUpdated(info);
 646
 647   // total_bytes
 648   EXPECT_CALL(item(0), GetTotalBytes()).WillRepeatedly(Return(102));
 649   info.total_bytes = 102;
 650   item(0).NotifyObserversDownloadUpdated();
 651   ExpectDownloadUpdated(info);
 652
 653   // etag
 654   EXPECT_CALL(item(0), GetETag()).WillRepeatedly(ReturnRefOfCopy(new_etag));
 655   info.etag = new_etag;
 656   item(0).NotifyObserversDownloadUpdated();
 657   ExpectDownloadUpdated(info);
 658
 659   // last_modified
 660   EXPECT_CALL(item(0), GetLastModifiedTime())
 661       .WillRepeatedly(ReturnRefOfCopy(new_last_modifed));
 662   info.last_modified = new_last_modifed;
 663   item(0).NotifyObserversDownloadUpdated();
 664   ExpectDownloadUpdated(info);
 665
 666   // state
 667   EXPECT_CALL(item(0), GetState())
 668       .WillRepeatedly(Return(content::DownloadItem::INTERRUPTED));
 669   info.state = content::DownloadItem::INTERRUPTED;
 670   item(0).NotifyObserversDownloadUpdated();
 671   ExpectDownloadUpdated(info);
 672
 673   // danger_type
 674   EXPECT_CALL(item(0), GetDangerType())
 675       .WillRepeatedly(Return(content::DOWNLOAD_DANGER_TYPE_DANGEROUS_CONTENT));
 676   info.danger_type = content::DOWNLOAD_DANGER_TYPE_DANGEROUS_CONTENT;
 677   item(0).NotifyObserversDownloadUpdated();
 678   ExpectDownloadUpdated(info);
 679
 680   // interrupt_reason
 681   EXPECT_CALL(item(0), GetLastReason())
 682       .WillRepeatedly(Return(content::DOWNLOAD_INTERRUPT_REASON_SERVER_FAILED));
 683   info.interrupt_reason = content::DOWNLOAD_INTERRUPT_REASON_SERVER_FAILED;
 684   item(0).NotifyObserversDownloadUpdated();
 685   ExpectDownloadUpdated(info);
 686
 687   // opened
 688   EXPECT_CALL(item(0), GetOpened()).WillRepeatedly(Return(true));
 689   info.opened = true;
 690   item(0).NotifyObserversDownloadUpdated();
 691   ExpectDownloadUpdated(info);
 692 }
 693
 694 // Test creating a new item, saving it, removing it by setting it Temporary,
 695 // changing it without saving it back because it's Temporary, clearing
 696 // IsTemporary, saving it back, changing it, saving it back because it isn't
 697 // Temporary anymore.
 698 TEST_F(DownloadHistoryTest, DownloadHistoryTest_Temporary) {
 699   // Create a fresh item not from history, OnDownloadCreated, OnDownloadUpdated,
 700   // OnDownloadRemoved.
 701   CreateDownloadHistory(scoped_ptr<InfoVector>(new InfoVector()));
 702
 703   history::DownloadRow info;
 704   InitBasicItem(FILE_PATH_LITERAL("/foo/bar.pdf"),
 705                 "http://example.com/bar.pdf",
 706                 "http://example.com/referrer.html",
 707                 &info);
 708
 709   // Pretend the manager just created |item|.
 710   CallOnDownloadCreated(0);
 711   ExpectDownloadCreated(info);
 712   EXPECT_TRUE(DownloadHistory::IsPersisted(&item(0)));
 713
 714   // Pretend the item was marked temporary. DownloadHistory should remove it
 715   // from history and start ignoring it.
 716   EXPECT_CALL(item(0), IsTemporary()).WillRepeatedly(Return(true));
 717   item(0).NotifyObserversDownloadUpdated();
 718   IdSet ids;
 719   ids.insert(info.id);
 720   ExpectDownloadsRemoved(ids);
 721
 722   // Change something that would make DownloadHistory call UpdateDownload if the
 723   // item weren't temporary.
 724   EXPECT_CALL(item(0), GetReceivedBytes()).WillRepeatedly(Return(4200));
 725   item(0).NotifyObserversDownloadUpdated();
 726   ExpectNoDownloadUpdated();
 727
 728   // Changing a temporary item back to a non-temporary item should make
 729   // DownloadHistory call CreateDownload.
 730   EXPECT_CALL(item(0), IsTemporary()).WillRepeatedly(Return(false));
 731   item(0).NotifyObserversDownloadUpdated();
 732   info.received_bytes = 4200;
 733   ExpectDownloadCreated(info);
 734   EXPECT_TRUE(DownloadHistory::IsPersisted(&item(0)));
 735
 736   EXPECT_CALL(item(0), GetReceivedBytes()).WillRepeatedly(Return(100));
 737   item(0).NotifyObserversDownloadUpdated();
 738   info.received_bytes = 100;
 739   ExpectDownloadUpdated(info);
 740 }
 741
 742 // Test removing downloads while they're still being added.
 743 TEST_F(DownloadHistoryTest, DownloadHistoryTest_RemoveWhileAdding) {
 744   CreateDownloadHistory(scoped_ptr<InfoVector>(new InfoVector()));
 745
 746   history::DownloadRow info;
 747   InitBasicItem(FILE_PATH_LITERAL("/foo/bar.pdf"),
 748                 "http://example.com/bar.pdf",
 749                 "http://example.com/referrer.html",
 750                 &info);
 751
 752   // Instruct CreateDownload() to not callback to DownloadHistory immediately,
 753   // but to wait for FinishCreateDownload().
 754   set_slow_create_download(true);
 755
 756   // Pretend the manager just created |item|.
 757   CallOnDownloadCreated(0);
 758   ExpectDownloadCreated(info);
 759   EXPECT_FALSE(DownloadHistory::IsPersisted(&item(0)));
 760
 761   // Call OnDownloadRemoved before calling back to DownloadHistory::ItemAdded().
 762   // Instead of calling RemoveDownloads() immediately, DownloadHistory should
 763   // add the item's id to removed_while_adding_. Then, ItemAdded should
 764   // immediately remove the item's record from history.
 765   item(0).NotifyObserversDownloadRemoved();
 766   EXPECT_CALL(manager(), GetDownload(item(0).GetId()))
 767     .WillRepeatedly(Return(static_cast<content::DownloadItem*>(NULL)));
 768   ExpectNoDownloadsRemoved();
 769   EXPECT_FALSE(DownloadHistory::IsPersisted(&item(0)));
 770
 771   // Now callback to DownloadHistory::ItemAdded(), and expect a call to
 772   // RemoveDownloads() for the item that was removed while it was being added.
 773   FinishCreateDownload();
 774   IdSet ids;
 775   ids.insert(info.id);
 776   ExpectDownloadsRemoved(ids);
 777   EXPECT_FALSE(DownloadHistory::IsPersisted(&item(0)));
 778 }
 779
 780 // Test loading multiple items from the database and removing them all.
 781 TEST_F(DownloadHistoryTest, DownloadHistoryTest_Multiple) {
 782   // Load a download from history, create the item, OnDownloadCreated,
 783   // OnDownloadUpdated, OnDownloadRemoved.
 784   history::DownloadRow info0, info1;
 785   InitBasicItem(FILE_PATH_LITERAL("/foo/bar.pdf"),
 786                 "http://example.com/bar.pdf",
 787                 "http://example.com/referrer.html",
 788                 &info0);
 789   InitBasicItem(FILE_PATH_LITERAL("/foo/qux.pdf"),
 790                 "http://example.com/qux.pdf",
 791                 "http://example.com/referrer1.html",
 792                 &info1);
 793   {
 794     scoped_ptr<InfoVector> infos(new InfoVector());
 795     infos->push_back(info0);
 796     infos->push_back(info1);
 797     CreateDownloadHistory(infos.Pass());
 798     ExpectNoDownloadCreated();
 799   }
 800
 801   EXPECT_TRUE(DownloadHistory::IsPersisted(&item(0)));
 802   EXPECT_TRUE(DownloadHistory::IsPersisted(&item(1)));
 803
 804   // Pretend that the user removed both items.
 805   IdSet ids;
 806   ids.insert(info0.id);
 807   ids.insert(info1.id);
 808   item(0).NotifyObserversDownloadRemoved();
 809   item(1).NotifyObserversDownloadRemoved();
 810   ExpectDownloadsRemoved(ids);
 811 }
 812
 813 // Test what happens when HistoryService/CreateDownload::CreateDownload() fails.
 814 TEST_F(DownloadHistoryTest, DownloadHistoryTest_CreateFailed) {
 815   // Create a fresh item not from history, OnDownloadCreated, OnDownloadUpdated,
 816   // OnDownloadRemoved.
 817   CreateDownloadHistory(scoped_ptr<InfoVector>(new InfoVector()));
 818
 819   history::DownloadRow info;
 820   InitBasicItem(FILE_PATH_LITERAL("/foo/bar.pdf"),
 821                 "http://example.com/bar.pdf",
 822                 "http://example.com/referrer.html",
 823                 &info);
 824
 825   FailCreateDownload();
 826   // Pretend the manager just created |item|.
 827   CallOnDownloadCreated(0);
 828   ExpectDownloadCreated(info);
 829   EXPECT_FALSE(DownloadHistory::IsPersisted(&item(0)));
 830
 831   EXPECT_CALL(item(0), GetReceivedBytes()).WillRepeatedly(Return(100));
 832   item(0).NotifyObserversDownloadUpdated();
 833   info.received_bytes = 100;
 834   ExpectDownloadCreated(info);
 835   EXPECT_TRUE(DownloadHistory::IsPersisted(&item(0)));
 836 }
 837
 838 TEST_F(DownloadHistoryTest, DownloadHistoryTest_UpdateWhileAdding) {
 839   // Create a fresh item not from history, OnDownloadCreated, OnDownloadUpdated,
 840   // OnDownloadRemoved.
 841   CreateDownloadHistory(scoped_ptr<InfoVector>(new InfoVector()));
 842
 843   history::DownloadRow info;
 844   InitBasicItem(FILE_PATH_LITERAL("/foo/bar.pdf"),
 845                 "http://example.com/bar.pdf",
 846                 "http://example.com/referrer.html",
 847                 &info);
 848
 849   // Instruct CreateDownload() to not callback to DownloadHistory immediately,
 850   // but to wait for FinishCreateDownload().
 851   set_slow_create_download(true);
 852
 853   // Pretend the manager just created |item|.
 854   CallOnDownloadCreated(0);
 855   ExpectDownloadCreated(info);
 856   EXPECT_FALSE(DownloadHistory::IsPersisted(&item(0)));
 857
 858   // Pretend that something changed on the item.
 859   EXPECT_CALL(item(0), GetOpened()).WillRepeatedly(Return(true));
 860   item(0).NotifyObserversDownloadUpdated();
 861
 862   FinishCreateDownload();
 863   EXPECT_TRUE(DownloadHistory::IsPersisted(&item(0)));
 864
 865   // ItemAdded should call OnDownloadUpdated, which should detect that the item
 866   // changed while it was being added and call UpdateDownload immediately.
 867   info.opened = true;
 868   ExpectDownloadUpdated(info);
 869 }
 870
 871 }  // anonymous namespace