// 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 <set>
#include <vector>

#include "base/rand_util.h"
#include "base/stl_util.h"
#include "chrome/browser/download/download_history.h"
#include "chrome/browser/history/download_database.h"
#include "chrome/browser/history/download_row.h"
#include "chrome/browser/history/history_service.h"
#include "content/public/test/mock_download_item.h"
#include "content/public/test/mock_download_manager.h"
#include "content/public/test/test_browser_thread.h"
#include "content/public/test/test_utils.h"
#include "testing/gtest/include/gtest/gtest.h"

using testing::DoAll;
using testing::Invoke;
using testing::Return;
using testing::ReturnRef;
using testing::SetArgPointee;
using testing::WithArg;
using testing::_;

namespace {

void CheckInfoEqual(const history::DownloadRow& left,
                    const history::DownloadRow& right) {
  EXPECT_EQ(left.current_path.value(), right.current_path.value());
  EXPECT_EQ(left.target_path.value(), right.target_path.value());
  EXPECT_EQ(left.url_chain.size(), right.url_chain.size());
  for (unsigned int i = 0;
       i < left.url_chain.size() && i < right.url_chain.size();
       ++i) {
    EXPECT_EQ(left.url_chain[i].spec(), right.url_chain[i].spec());
  }
  EXPECT_EQ(left.referrer_url.spec(), right.referrer_url.spec());
  EXPECT_EQ(left.start_time.ToTimeT(), right.start_time.ToTimeT());
  EXPECT_EQ(left.end_time.ToTimeT(), right.end_time.ToTimeT());
  EXPECT_EQ(left.received_bytes, right.received_bytes);
  EXPECT_EQ(left.total_bytes, right.total_bytes);
  EXPECT_EQ(left.state, right.state);
  EXPECT_EQ(left.danger_type, right.danger_type);
  EXPECT_EQ(left.id, right.id);
  EXPECT_EQ(left.opened, right.opened);
}

typedef DownloadHistory::IdSet IdSet;
typedef std::vector<history::DownloadRow> InfoVector;
typedef testing::NiceMock<content::MockDownloadItem> NiceMockDownloadItem;

class FakeHistoryAdapter : public DownloadHistory::HistoryAdapter {
 public:
  FakeHistoryAdapter()
    : DownloadHistory::HistoryAdapter(NULL),
      slow_create_download_(false),
      fail_create_download_(false) {
  }

  virtual ~FakeHistoryAdapter() {}

  virtual void QueryDownloads(
      const HistoryService::DownloadQueryCallback& callback) OVERRIDE {
    DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
    content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
        base::Bind(&FakeHistoryAdapter::QueryDownloadsDone,
            base::Unretained(this), callback));
  }

  void QueryDownloadsDone(
      const HistoryService::DownloadQueryCallback& callback) {
    DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
    CHECK(expect_query_downloads_.get());
    callback.Run(expect_query_downloads_.Pass());
  }

  void set_slow_create_download(bool slow) { slow_create_download_ = slow; }

  virtual void CreateDownload(
      const history::DownloadRow& info,
      const HistoryService::DownloadCreateCallback& callback) OVERRIDE {
    DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
    create_download_info_ = info;
    // Must not call CreateDownload() again before FinishCreateDownload()!
    DCHECK(create_download_callback_.is_null());
    create_download_callback_ = base::Bind(callback, !fail_create_download_);
    fail_create_download_ = false;
    if (!slow_create_download_)
      FinishCreateDownload();
  }

  void FinishCreateDownload() {
    DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
    create_download_callback_.Run();
    create_download_callback_.Reset();
  }

  virtual void UpdateDownload(
      const history::DownloadRow& info) OVERRIDE {
    DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
    update_download_ = info;
  }

  virtual void RemoveDownloads(const IdSet& ids) OVERRIDE {
    DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
    for (IdSet::const_iterator it = ids.begin();
         it != ids.end(); ++it) {
      remove_downloads_.insert(*it);
    }
  }

  void ExpectWillQueryDownloads(scoped_ptr<InfoVector> infos) {
    DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
    expect_query_downloads_ = infos.Pass();
  }

  void ExpectQueryDownloadsDone() {
    DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
    EXPECT_TRUE(NULL == expect_query_downloads_.get());
  }

  void FailCreateDownload() {
    DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
    fail_create_download_ = true;
  }

  void ExpectDownloadCreated(
      const history::DownloadRow& info) {
    DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
    content::RunAllPendingInMessageLoop(content::BrowserThread::UI);
    CheckInfoEqual(info, create_download_info_);
    create_download_info_ = history::DownloadRow();
  }

  void ExpectNoDownloadCreated() {
    DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
    content::RunAllPendingInMessageLoop(content::BrowserThread::UI);
    CheckInfoEqual(history::DownloadRow(), create_download_info_);
  }

  void ExpectDownloadUpdated(const history::DownloadRow& info) {
    DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
    content::RunAllPendingInMessageLoop(content::BrowserThread::UI);
    CheckInfoEqual(update_download_, info);
    update_download_ = history::DownloadRow();
  }

  void ExpectNoDownloadUpdated() {
    DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
    content::RunAllPendingInMessageLoop(content::BrowserThread::UI);
    CheckInfoEqual(history::DownloadRow(), update_download_);
  }

  void ExpectNoDownloadsRemoved() {
    DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
    content::RunAllPendingInMessageLoop(content::BrowserThread::UI);
    EXPECT_EQ(0, static_cast<int>(remove_downloads_.size()));
  }

  void ExpectDownloadsRemoved(const IdSet& ids) {
    DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
    content::RunAllPendingInMessageLoop(content::BrowserThread::UI);
    IdSet differences;
    std::insert_iterator<IdSet> differences_iter(
        differences, differences.begin());
    std::set_difference(ids.begin(), ids.end(),
                        remove_downloads_.begin(),
                        remove_downloads_.end(),
                        differences_iter);
    for (IdSet::const_iterator different = differences.begin();
         different != differences.end(); ++different) {
      EXPECT_TRUE(false) << *different;
    }
    remove_downloads_.clear();
  }

 private:
  bool slow_create_download_;
  bool fail_create_download_;
  base::Closure create_download_callback_;
  history::DownloadRow update_download_;
  scoped_ptr<InfoVector> expect_query_downloads_;
  IdSet remove_downloads_;
  history::DownloadRow create_download_info_;

  DISALLOW_COPY_AND_ASSIGN(FakeHistoryAdapter);
};

class DownloadHistoryTest : public testing::Test {
 public:
  DownloadHistoryTest()
      : ui_thread_(content::BrowserThread::UI, &loop_),
        manager_(new content::MockDownloadManager()),
        history_(NULL),
        manager_observer_(NULL),
        item_observer_(NULL),
        download_created_index_(0) {}
  virtual ~DownloadHistoryTest() {
    STLDeleteElements(&items_);
  }

 protected:
  virtual void TearDown() OVERRIDE {
    download_history_.reset();
  }

  content::MockDownloadManager& manager() { return *manager_.get(); }
  content::MockDownloadItem& item(size_t index) { return *items_[index]; }

  void SetManagerObserver(
      content::DownloadManager::Observer* manager_observer) {
    manager_observer_ = manager_observer;
  }
  content::DownloadManager::Observer* manager_observer() {
    return manager_observer_;
  }

  // Relies on the same object observing all download items.
  void SetItemObserver(
      content::DownloadItem::Observer* item_observer) {
    item_observer_ = item_observer;
  }
  content::DownloadItem::Observer* item_observer() {
    return item_observer_;
  }

  void ExpectWillQueryDownloads(scoped_ptr<InfoVector> infos) {
    DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
    CHECK(infos.get());
    EXPECT_CALL(manager(), AddObserver(_)).WillOnce(WithArg<0>(Invoke(
        this, &DownloadHistoryTest::SetManagerObserver)));
    EXPECT_CALL(manager(), RemoveObserver(_));
    download_created_index_ = 0;
    for (size_t index = 0; index < infos->size(); ++index) {
      content::MockDownloadManager::CreateDownloadItemAdapter adapter(
          infos->at(index).id,
          infos->at(index).current_path,
          infos->at(index).target_path,
          infos->at(index).url_chain,
          infos->at(index).referrer_url,
          infos->at(index).start_time,
          infos->at(index).end_time,
          infos->at(index).received_bytes,
          infos->at(index).total_bytes,
          infos->at(index).state,
          infos->at(index).danger_type,
          infos->at(index).interrupt_reason,
          infos->at(index).opened);
      EXPECT_CALL(manager(), MockCreateDownloadItem(adapter))
        .WillOnce(DoAll(
            InvokeWithoutArgs(
                this, &DownloadHistoryTest::CallOnDownloadCreatedInOrder),
            Return(&item(index))));
    }
    EXPECT_CALL(manager(), CheckForHistoryFilesRemoval());
    history_ = new FakeHistoryAdapter();
    history_->ExpectWillQueryDownloads(infos.Pass());
    EXPECT_CALL(*manager_.get(), GetAllDownloads(_)).WillRepeatedly(Return());
    download_history_.reset(new DownloadHistory(
        &manager(), scoped_ptr<DownloadHistory::HistoryAdapter>(history_)));
    content::RunAllPendingInMessageLoop(content::BrowserThread::UI);
    history_->ExpectQueryDownloadsDone();
  }

  void CallOnDownloadCreated(size_t index) {
    DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
    manager_observer()->OnDownloadCreated(&manager(), &item(index));
  }

  void CallOnDownloadCreatedInOrder() {
    DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
    // Gmock doesn't appear to support something like InvokeWithTheseArgs. Maybe
    // gmock needs to learn about base::Callback.
    CallOnDownloadCreated(download_created_index_++);
  }

  void set_slow_create_download(bool slow) {
    DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
    history_->set_slow_create_download(slow);
  }

  void FinishCreateDownload() {
    DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
    history_->FinishCreateDownload();
  }

  void FailCreateDownload() {
    DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
    history_->FailCreateDownload();
  }

  void ExpectDownloadCreated(
      const history::DownloadRow& info) {
    DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
    history_->ExpectDownloadCreated(info);
  }

  void ExpectNoDownloadCreated() {
    DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
    history_->ExpectNoDownloadCreated();
  }

  void ExpectDownloadUpdated(const history::DownloadRow& info) {
    DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
    history_->ExpectDownloadUpdated(info);
  }

  void ExpectNoDownloadUpdated() {
    DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
    history_->ExpectNoDownloadUpdated();
  }

  void ExpectNoDownloadsRemoved() {
    DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
    history_->ExpectNoDownloadsRemoved();
  }

  void ExpectDownloadsRemoved(const IdSet& ids) {
    DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
    history_->ExpectDownloadsRemoved(ids);
  }

  // Caller is responsibile for making sure reference arguments lifetime is
  // greater than the lifetime of the NiceMockDownloadItem() created by this
  // routine.
  void InitItem(
      uint32 id,
      const base::FilePath& current_path,
      const base::FilePath& target_path,
      const std::vector<GURL>& url_chain,
      const GURL& referrer,
      const base::Time& start_time,
      const base::Time& end_time,
      int64 received_bytes,
      int64 total_bytes,
      content::DownloadItem::DownloadState state,
      content::DownloadDangerType danger_type,
      content::DownloadInterruptReason interrupt_reason,
      bool opened,
      history::DownloadRow* info) {
    DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
    size_t index = items_.size();
    NiceMockDownloadItem* mock_item = new NiceMockDownloadItem();
    items_.push_back(mock_item);

    info->current_path = current_path;
    info->target_path = target_path;
    info->url_chain = url_chain;
    info->referrer_url = referrer;
    info->start_time = start_time;
    info->end_time = end_time;
    info->received_bytes = received_bytes;
    info->total_bytes = total_bytes;
    info->state = state;
    info->danger_type = danger_type;
    info->interrupt_reason = interrupt_reason;
    info->id = id;
    info->opened = opened;

    EXPECT_CALL(item(index), GetId()).WillRepeatedly(Return(id));
    EXPECT_CALL(item(index),
                GetFullPath()).WillRepeatedly(ReturnRef(current_path));
    EXPECT_CALL(item(index),
                GetTargetFilePath()).WillRepeatedly(ReturnRef(target_path));
    DCHECK_LE(1u, url_chain.size());
    EXPECT_CALL(item(index), GetURL()).WillRepeatedly(ReturnRef(url_chain[0]));
    EXPECT_CALL(item(index),
                GetUrlChain()).WillRepeatedly(ReturnRef(url_chain));
    EXPECT_CALL(item(index), GetMimeType()).WillRepeatedly(Return(
        "application/octet-stream"));
    EXPECT_CALL(item(index), GetReferrerUrl()).WillRepeatedly(ReturnRef(
        referrer));
    EXPECT_CALL(item(index), GetStartTime()).WillRepeatedly(Return(start_time));
    EXPECT_CALL(item(index), GetEndTime()).WillRepeatedly(Return(end_time));
    EXPECT_CALL(item(index), GetReceivedBytes())
        .WillRepeatedly(Return(received_bytes));
    EXPECT_CALL(item(index), GetTotalBytes()).WillRepeatedly(Return(
        total_bytes));
    EXPECT_CALL(item(index), GetState()).WillRepeatedly(Return(state));
    EXPECT_CALL(item(index), GetDangerType())
        .WillRepeatedly(Return(danger_type));
    EXPECT_CALL(item(index), GetLastReason()).WillRepeatedly(
        Return(interrupt_reason));
    EXPECT_CALL(item(index), GetOpened()).WillRepeatedly(Return(opened));
    EXPECT_CALL(item(index), GetTargetDisposition()).WillRepeatedly(Return(
          content::DownloadItem::TARGET_DISPOSITION_OVERWRITE));
    EXPECT_CALL(manager(), GetDownload(id))
        .WillRepeatedly(Return(&item(index)));
    EXPECT_CALL(item(index), AddObserver(_)).WillOnce(WithArg<0>(Invoke(
        this, &DownloadHistoryTest::SetItemObserver)));
    EXPECT_CALL(item(index), RemoveObserver(_));

    std::vector<content::DownloadItem*> items;
    for (size_t i = 0; i < items_.size(); ++i) {
      items.push_back(&item(i));
    }
    EXPECT_CALL(*manager_.get(), GetAllDownloads(_))
      .WillRepeatedly(SetArgPointee<0>(items));
  }

 private:
  base::MessageLoopForUI loop_;
  content::TestBrowserThread ui_thread_;
  std::vector<NiceMockDownloadItem*> items_;
  scoped_ptr<content::MockDownloadManager> manager_;
  FakeHistoryAdapter* history_;
  scoped_ptr<DownloadHistory> download_history_;
  content::DownloadManager::Observer* manager_observer_;
  content::DownloadItem::Observer* item_observer_;
  size_t download_created_index_;

  DISALLOW_COPY_AND_ASSIGN(DownloadHistoryTest);
};

}  // anonymous namespace

// Test loading an item from the database, changing it, saving it back, removing
// it.
TEST_F(DownloadHistoryTest, DownloadHistoryTest_Load) {
  // Load a download from history, create the item, OnDownloadCreated,
  // OnDownloadUpdated, OnDownloadRemoved.
  history::DownloadRow info;
  base::FilePath path(FILE_PATH_LITERAL("/foo/bar.pdf"));
  GURL url("http://example.com/bar.pdf");
  GURL referrer("http://example.com/referrer.html");
  std::vector<GURL> url_chain;
  url_chain.push_back(url);
  InitItem(base::RandInt(0, 1 << 20),
           path,
           path,
           url_chain,
           referrer,
           (base::Time::Now() - base::TimeDelta::FromMinutes(10)),
           (base::Time::Now() - base::TimeDelta::FromMinutes(1)),
           100,
           100,
           content::DownloadItem::COMPLETE,
           content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
           content::DOWNLOAD_INTERRUPT_REASON_NONE,
           false,
           &info);
  {
    scoped_ptr<InfoVector> infos(new InfoVector());
    infos->push_back(info);
    ExpectWillQueryDownloads(infos.Pass());
    ExpectNoDownloadCreated();
  }
  EXPECT_TRUE(DownloadHistory::IsPersisted(&item(0)));

  // Pretend that something changed on the item.
  EXPECT_CALL(item(0), GetOpened()).WillRepeatedly(Return(true));
  item_observer()->OnDownloadUpdated(&item(0));
  info.opened = true;
  ExpectDownloadUpdated(info);

  // Pretend that the user removed the item.
  IdSet ids;
  ids.insert(info.id);
  item_observer()->OnDownloadRemoved(&item(0));
  ExpectDownloadsRemoved(ids);
}

// Test creating an item, saving it to the database, changing it, saving it
// back, removing it.
TEST_F(DownloadHistoryTest, DownloadHistoryTest_Create) {
  // Create a fresh item not from history, OnDownloadCreated, OnDownloadUpdated,
  // OnDownloadRemoved.
  ExpectWillQueryDownloads(scoped_ptr<InfoVector>(new InfoVector()));

  history::DownloadRow info;
  base::FilePath path(FILE_PATH_LITERAL("/foo/bar.pdf"));
  GURL url("http://example.com/bar.pdf");
  GURL referrer("http://example.com/referrer.html");
  std::vector<GURL> url_chain;
  url_chain.push_back(url);
  InitItem(base::RandInt(0, 1 << 20),
           path,
           path,
           url_chain,
           referrer,
           (base::Time::Now() - base::TimeDelta::FromMinutes(10)),
           (base::Time::Now() - base::TimeDelta::FromMinutes(1)),
           100,
           100,
           content::DownloadItem::COMPLETE,
           content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
           content::DOWNLOAD_INTERRUPT_REASON_NONE,
           false,
           &info);

  // Pretend the manager just created |item|.
  CallOnDownloadCreated(0);
  ExpectDownloadCreated(info);
  EXPECT_TRUE(DownloadHistory::IsPersisted(&item(0)));

  // Pretend that something changed on the item.
  EXPECT_CALL(item(0), GetOpened()).WillRepeatedly(Return(true));
  item_observer()->OnDownloadUpdated(&item(0));
  info.opened = true;
  ExpectDownloadUpdated(info);

  // Pretend that the user removed the item.
  IdSet ids;
  ids.insert(info.id);
  item_observer()->OnDownloadRemoved(&item(0));
  ExpectDownloadsRemoved(ids);
}

// Test creating a new item, saving it, removing it by setting it Temporary,
// changing it without saving it back because it's Temporary, clearing
// IsTemporary, saving it back, changing it, saving it back because it isn't
// Temporary anymore.
TEST_F(DownloadHistoryTest, DownloadHistoryTest_Temporary) {
  // Create a fresh item not from history, OnDownloadCreated, OnDownloadUpdated,
  // OnDownloadRemoved.
  ExpectWillQueryDownloads(scoped_ptr<InfoVector>(new InfoVector()));

  history::DownloadRow info;
  base::FilePath path(FILE_PATH_LITERAL("/foo/bar.pdf"));
  GURL url("http://example.com/bar.pdf");
  GURL referrer("http://example.com/referrer.html");
  std::vector<GURL> url_chain;
  url_chain.push_back(url);
  InitItem(base::RandInt(0, 1 << 20),
           path,
           path,
           url_chain,
           referrer,
           (base::Time::Now() - base::TimeDelta::FromMinutes(10)),
           (base::Time::Now() - base::TimeDelta::FromMinutes(1)),
           100,
           100,
           content::DownloadItem::COMPLETE,
           content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
           content::DOWNLOAD_INTERRUPT_REASON_NONE,
           false,
           &info);

  // Pretend the manager just created |item|.
  CallOnDownloadCreated(0);
  ExpectDownloadCreated(info);
  EXPECT_TRUE(DownloadHistory::IsPersisted(&item(0)));

  // Pretend the item was marked temporary. DownloadHistory should remove it
  // from history and start ignoring it.
  EXPECT_CALL(item(0), IsTemporary()).WillRepeatedly(Return(true));
  item_observer()->OnDownloadUpdated(&item(0));
  IdSet ids;
  ids.insert(info.id);
  ExpectDownloadsRemoved(ids);

  // Change something that would make DownloadHistory call UpdateDownload if the
  // item weren't temporary.
  EXPECT_CALL(item(0), GetReceivedBytes()).WillRepeatedly(Return(4200));
  item_observer()->OnDownloadUpdated(&item(0));
  ExpectNoDownloadUpdated();

  // Changing a temporary item back to a non-temporary item should make
  // DownloadHistory call CreateDownload.
  EXPECT_CALL(item(0), IsTemporary()).WillRepeatedly(Return(false));
  item_observer()->OnDownloadUpdated(&item(0));
  info.received_bytes = 4200;
  ExpectDownloadCreated(info);
  EXPECT_TRUE(DownloadHistory::IsPersisted(&item(0)));

  EXPECT_CALL(item(0), GetReceivedBytes()).WillRepeatedly(Return(100));
  item_observer()->OnDownloadUpdated(&item(0));
  info.received_bytes = 100;
  ExpectDownloadUpdated(info);
}

// Test removing downloads while they're still being added.
TEST_F(DownloadHistoryTest,
    DownloadHistoryTest_RemoveWhileAdding) {
  ExpectWillQueryDownloads(scoped_ptr<InfoVector>(new InfoVector()));

  history::DownloadRow info;
  base::FilePath path(FILE_PATH_LITERAL("/foo/bar.pdf"));
  GURL url("http://example.com/bar.pdf");
  GURL referrer("http://example.com/referrer.html");
  std::vector<GURL> url_chain;
  url_chain.push_back(url);
  InitItem(base::RandInt(0, 1 << 20),
           path,
           path,
           url_chain,
           referrer,
           (base::Time::Now() - base::TimeDelta::FromMinutes(10)),
           (base::Time::Now() - base::TimeDelta::FromMinutes(1)),
           100,
           100,
           content::DownloadItem::COMPLETE,
           content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
           content::DOWNLOAD_INTERRUPT_REASON_NONE,
           false,
           &info);

  // Instruct CreateDownload() to not callback to DownloadHistory immediately,
  // but to wait for FinishCreateDownload().
  set_slow_create_download(true);

  // Pretend the manager just created |item|.
  CallOnDownloadCreated(0);
  ExpectDownloadCreated(info);
  EXPECT_FALSE(DownloadHistory::IsPersisted(&item(0)));

  // Call OnDownloadRemoved before calling back to DownloadHistory::ItemAdded().
  // Instead of calling RemoveDownloads() immediately, DownloadHistory should
  // add the item's id to removed_while_adding_. Then, ItemAdded should
  // immediately remove the item's record from history.
  item_observer()->OnDownloadRemoved(&item(0));
  EXPECT_CALL(manager(), GetDownload(item(0).GetId()))
    .WillRepeatedly(Return(static_cast<content::DownloadItem*>(NULL)));
  ExpectNoDownloadsRemoved();
  EXPECT_FALSE(DownloadHistory::IsPersisted(&item(0)));

  // Now callback to DownloadHistory::ItemAdded(), and expect a call to
  // RemoveDownloads() for the item that was removed while it was being added.
  FinishCreateDownload();
  IdSet ids;
  ids.insert(info.id);
  ExpectDownloadsRemoved(ids);
  EXPECT_FALSE(DownloadHistory::IsPersisted(&item(0)));
}

// Test loading multiple items from the database and removing them all.
TEST_F(DownloadHistoryTest, DownloadHistoryTest_Multiple) {
  // Load a download from history, create the item, OnDownloadCreated,
  // OnDownloadUpdated, OnDownloadRemoved.
  history::DownloadRow info0, info1;
  base::FilePath path0(FILE_PATH_LITERAL("/foo/bar.pdf"));
  GURL url0("http://example.com/bar.pdf");
  GURL referrer0("http://example.com/referrer.html");
  std::vector<GURL> url0_chain;
  url0_chain.push_back(url0);
  InitItem(base::RandInt(0, 1 << 10),
           path0,
           path0,
           url0_chain,
           referrer0,
           (base::Time::Now() - base::TimeDelta::FromMinutes(11)),
           (base::Time::Now() - base::TimeDelta::FromMinutes(2)),
           100,
           100,
           content::DownloadItem::COMPLETE,
           content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
           content::DOWNLOAD_INTERRUPT_REASON_NONE,
           false,
           &info0);
  base::FilePath path1(FILE_PATH_LITERAL("/foo/qux.pdf"));
  GURL url1("http://example.com/qux.pdf");
  GURL referrer1("http://example.com/referrer.html");
  std::vector<GURL> url1_chain;
  url1_chain.push_back(url0);
  InitItem(item(0).GetId() + base::RandInt(1, 1 << 10),
           path1,
           path1,
           url1_chain,
           referrer1,
           (base::Time::Now() - base::TimeDelta::FromMinutes(10)),
           (base::Time::Now() - base::TimeDelta::FromMinutes(1)),
           200,
           200,
           content::DownloadItem::COMPLETE,
           content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
           content::DOWNLOAD_INTERRUPT_REASON_NONE,
           false,
           &info1);
  {
    scoped_ptr<InfoVector> infos(new InfoVector());
    infos->push_back(info0);
    infos->push_back(info1);
    ExpectWillQueryDownloads(infos.Pass());
    ExpectNoDownloadCreated();
  }

  EXPECT_TRUE(DownloadHistory::IsPersisted(&item(0)));
  EXPECT_TRUE(DownloadHistory::IsPersisted(&item(1)));

  // Pretend that the user removed both items.
  IdSet ids;
  ids.insert(info0.id);
  ids.insert(info1.id);
  item_observer()->OnDownloadRemoved(&item(0));
  item_observer()->OnDownloadRemoved(&item(1));
  ExpectDownloadsRemoved(ids);
}

// Test what happens when HistoryService/CreateDownload::CreateDownload() fails.
TEST_F(DownloadHistoryTest, DownloadHistoryTest_CreateFailed) {
  // Create a fresh item not from history, OnDownloadCreated, OnDownloadUpdated,
  // OnDownloadRemoved.
  ExpectWillQueryDownloads(scoped_ptr<InfoVector>(new InfoVector()));

  history::DownloadRow info;
  base::FilePath path(FILE_PATH_LITERAL("/foo/bar.pdf"));
  GURL url("http://example.com/bar.pdf");
  GURL referrer("http://example.com/referrer.html");
  std::vector<GURL> url_chain;
  url_chain.push_back(url);
  InitItem(base::RandInt(0, 1 << 20),
           path,
           path,
           url_chain,
           referrer,
           (base::Time::Now() - base::TimeDelta::FromMinutes(10)),
           (base::Time::Now() - base::TimeDelta::FromMinutes(1)),
           100,
           100,
           content::DownloadItem::COMPLETE,
           content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
           content::DOWNLOAD_INTERRUPT_REASON_NONE,
           false,
           &info);

  FailCreateDownload();
  // Pretend the manager just created |item|.
  CallOnDownloadCreated(0);
  ExpectDownloadCreated(info);
  EXPECT_FALSE(DownloadHistory::IsPersisted(&item(0)));

  EXPECT_CALL(item(0), GetReceivedBytes()).WillRepeatedly(Return(100));
  item_observer()->OnDownloadUpdated(&item(0));
  info.received_bytes = 100;
  ExpectDownloadCreated(info);
  EXPECT_TRUE(DownloadHistory::IsPersisted(&item(0)));
}

TEST_F(DownloadHistoryTest,
    DownloadHistoryTest_UpdateWhileAdding) {
  // Create a fresh item not from history, OnDownloadCreated, OnDownloadUpdated,
  // OnDownloadRemoved.
  ExpectWillQueryDownloads(scoped_ptr<InfoVector>(new InfoVector()));

  history::DownloadRow info;
  base::FilePath path(FILE_PATH_LITERAL("/foo/bar.pdf"));
  GURL url("http://example.com/bar.pdf");
  GURL referrer("http://example.com/referrer.html");
  std::vector<GURL> url_chain;
  url_chain.push_back(url);
  InitItem(base::RandInt(0, 1 << 20),
           path,
           path,
           url_chain,
           referrer,
           (base::Time::Now() - base::TimeDelta::FromMinutes(10)),
           (base::Time::Now() - base::TimeDelta::FromMinutes(1)),
           100,
           100,
           content::DownloadItem::COMPLETE,
           content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
           content::DOWNLOAD_INTERRUPT_REASON_NONE,
           false,
           &info);

  // Instruct CreateDownload() to not callback to DownloadHistory immediately,
  // but to wait for FinishCreateDownload().
  set_slow_create_download(true);

  // Pretend the manager just created |item|.
  CallOnDownloadCreated(0);
  ExpectDownloadCreated(info);
  EXPECT_FALSE(DownloadHistory::IsPersisted(&item(0)));

  // Pretend that something changed on the item.
  EXPECT_CALL(item(0), GetOpened()).WillRepeatedly(Return(true));
  item_observer()->OnDownloadUpdated(&item(0));

  FinishCreateDownload();
  EXPECT_TRUE(DownloadHistory::IsPersisted(&item(0)));

  // ItemAdded should call OnDownloadUpdated, which should detect that the item
  // changed while it was being added and call UpdateDownload immediately.
  info.opened = true;
  ExpectDownloadUpdated(info);
}