blob: 49a80db6887349a16d2f5da72114230bd43f1ce1 [file] [log] [blame]
// 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 "components/history/core/browser/download_database.h"
#include <inttypes.h>
#include <limits>
#include <memory>
#include <string>
#include <vector>
#include "base/debug/alias.h"
#include "base/files/file_path.h"
#include "base/metrics/histogram_macros.h"
#include "base/rand_util.h"
#include "base/stl_util.h"
#include "base/strings/stringprintf.h"
#include "base/strings/utf_string_conversions.h"
#include "base/time/time.h"
#include "build/build_config.h"
#include "components/history/core/browser/download_constants.h"
#include "components/history/core/browser/download_row.h"
#include "components/history/core/browser/download_slice_info.h"
#include "components/history/core/browser/history_types.h"
#include "sql/statement.h"
namespace history {
namespace {
const char kDownloadsTable[] = "downloads";
const char kDownloadsSlicesTable[] = "downloads_slices";
// Reason for dropping a particular record. Used for UMA.
enum DroppedReason {
DROPPED_REASON_BAD_STATE = 0,
DROPPED_REASON_BAD_DANGER_TYPE = 1,
DROPPED_REASON_BAD_ID = 2,
DROPPED_REASON_DUPLICATE_ID = 3,
DROPPED_REASON_MAX
};
#if defined(OS_POSIX) || defined(OS_FUCHSIA)
// Binds/reads the given file path to the given column of the given statement.
void BindFilePath(sql::Statement& statement,
const base::FilePath& path,
int col) {
statement.BindString(col, path.value());
}
base::FilePath ColumnFilePath(sql::Statement& statement, int col) {
return base::FilePath(statement.ColumnString(col));
}
#else
// See above.
void BindFilePath(sql::Statement& statement,
const base::FilePath& path,
int col) {
statement.BindString16(col, path.value());
}
base::FilePath ColumnFilePath(sql::Statement& statement, int col) {
return base::FilePath(statement.ColumnString16(col));
}
#endif
} // namespace
DownloadDatabase::DownloadDatabase(
DownloadInterruptReason download_interrupt_reason_none,
DownloadInterruptReason download_interrupt_reason_crash)
: owning_thread_set_(false),
owning_thread_(0),
in_progress_entry_cleanup_completed_(false),
download_interrupt_reason_none_(download_interrupt_reason_none),
download_interrupt_reason_crash_(download_interrupt_reason_crash) {
}
DownloadDatabase::~DownloadDatabase() {
}
bool DownloadDatabase::EnsureColumnExists(const std::string& name,
const std::string& type) {
return EnsureColumnExistsInTable(kDownloadsTable, name, type);
}
bool DownloadDatabase::EnsureColumnExistsInTable(const std::string& table,
const std::string& name,
const std::string& type) {
std::string add_col =
"ALTER TABLE " + table + " ADD COLUMN " + name + " " + type;
return GetDB().DoesColumnExist(table.c_str(), name.c_str()) ||
GetDB().Execute(add_col.c_str());
}
bool DownloadDatabase::MigrateMimeType() {
return EnsureColumnExists("mime_type", "VARCHAR(255) NOT NULL"
" DEFAULT \"\"") &&
EnsureColumnExists("original_mime_type", "VARCHAR(255) NOT NULL"
" DEFAULT \"\"");
}
bool DownloadDatabase::MigrateDownloadsState() {
sql::Statement statement(GetDB().GetUniqueStatement(
base::StringPrintf("UPDATE %s SET state=? WHERE state=?", kDownloadsTable)
.c_str()));
statement.BindInt(0, DownloadStateToInt(DownloadState::INTERRUPTED));
statement.BindInt(1, DownloadStateToInt(DownloadState::BUG_140687));
return statement.Run();
}
bool DownloadDatabase::MigrateDownloadsReasonPathsAndDangerType() {
// We need to rename the table and copy back from it because SQLite
// provides no way to rename or delete a column.
if (!GetDB().Execute(
base::StringPrintf("ALTER TABLE %s RENAME TO downloads_tmp",
kDownloadsTable)
.c_str()))
return false;
const std::string kReasonPathDangerSchema = base::StringPrintf(
"CREATE TABLE %s ("
"id INTEGER PRIMARY KEY,"
"current_path LONGVARCHAR NOT NULL,"
"target_path LONGVARCHAR NOT NULL,"
"start_time INTEGER NOT NULL,"
"received_bytes INTEGER NOT NULL,"
"total_bytes INTEGER NOT NULL,"
"state INTEGER NOT NULL,"
"danger_type INTEGER NOT NULL,"
"interrupt_reason INTEGER NOT NULL,"
"end_time INTEGER NOT NULL,"
"opened INTEGER NOT NULL)",
kDownloadsTable);
static const char kReasonPathDangerUrlChainSchema[] =
"CREATE TABLE downloads_url_chains ("
"id INTEGER NOT NULL," // downloads.id.
"chain_index INTEGER NOT NULL," // Index of url in chain
// 0 is initial target,
// MAX is target after redirects.
"url LONGVARCHAR NOT NULL, " // URL.
"PRIMARY KEY (id, chain_index) )";
// Recreate main table.
if (!GetDB().Execute(kReasonPathDangerSchema.c_str()))
return false;
// Populate it. As we do so, we transform the time values from time_t
// (seconds since 1/1/1970 UTC), to our internal measure (microseconds
// since the Windows Epoch). Note that this is dependent on the
// internal representation of base::Time and needs to change if that changes.
sql::Statement statement_populate(GetDB().GetUniqueStatement(
base::StringPrintf(
"INSERT INTO %s "
"( id, current_path, target_path, start_time, received_bytes, "
" total_bytes, state, danger_type, interrupt_reason, end_time, "
"opened ) "
"SELECT id, full_path, full_path, "
" CASE start_time WHEN 0 THEN 0 ELSE "
" (start_time + 11644473600) * 1000000 END, "
" received_bytes, total_bytes, "
" state, ?, ?, "
" CASE end_time WHEN 0 THEN 0 ELSE "
" (end_time + 11644473600) * 1000000 END, "
" opened "
"FROM downloads_tmp",
kDownloadsTable)
.c_str()));
statement_populate.BindInt(
0, DownloadInterruptReasonToInt(download_interrupt_reason_none_));
statement_populate.BindInt(
1, DownloadDangerTypeToInt(DownloadDangerType::NOT_DANGEROUS));
if (!statement_populate.Run())
return false;
// Create new chain table and populate it.
if (!GetDB().Execute(kReasonPathDangerUrlChainSchema))
return false;
if (!GetDB().Execute("INSERT INTO downloads_url_chains "
" ( id, chain_index, url) "
" SELECT id, 0, url from downloads_tmp"))
return false;
// Get rid of temporary table.
if (!GetDB().Execute("DROP TABLE downloads_tmp"))
return false;
return true;
}
bool DownloadDatabase::MigrateReferrer() {
return EnsureColumnExists("referrer", "VARCHAR NOT NULL DEFAULT \"\"");
}
bool DownloadDatabase::MigrateDownloadedByExtension() {
return EnsureColumnExists("by_ext_id", "VARCHAR NOT NULL DEFAULT \"\"") &&
EnsureColumnExists("by_ext_name", "VARCHAR NOT NULL DEFAULT \"\"");
}
bool DownloadDatabase::MigrateDownloadValidators() {
return EnsureColumnExists("etag", "VARCHAR NOT NULL DEFAULT \"\"") &&
EnsureColumnExists("last_modified", "VARCHAR NOT NULL DEFAULT \"\"");
}
bool DownloadDatabase::MigrateHashHttpMethodAndGenerateGuids() {
if (!EnsureColumnExists("guid", "VARCHAR NOT NULL DEFAULT ''") ||
!EnsureColumnExists("hash", "BLOB NOT NULL DEFAULT X''") ||
!EnsureColumnExists("http_method", "VARCHAR NOT NULL DEFAULT ''"))
return false;
// Generate GUIDs for each download. GUIDs based on random data should conform
// with RFC 4122 section 4.4. Given the following field layout (based on RFC
// 4122):
//
// 0 1 2 3
// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// | time_low |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// | time_mid | time_hi_and_version |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// |clk_seq_hi_res | clk_seq_low | node (0-1) |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// | node (2-5) |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
//
// * Bits 4-7 of time_hi_and_version should be set to 0b0100 == 4
// * Bits 6-7 of clk_seq_hi_res should be set to 0b10
// * All other bits should be random or pseudorandom.
//
// We are going to take the liberty of setting time_low to the 32-bit download
// ID. That will guarantee that no two randomly generated GUIDs will collide
// even if the 90 bits of entropy doesn't save us.
//
// Translated to the canonical string representation, the GUID is generated
// thusly:
//
// XXXXXXXX-RRRR-4RRR-yRRR-RRRRRRRRRRRR
// \__ __/ \___________ ____________/
// \/ \/
// | R = random hex digit.
// | y = one of {'8','9','A','B'} selected randomly.
// | 4 = the character '4'.
// |
// Hex representation of 32-bit download ID.
//
// This GUID generation scheme is only used for migrated download rows and
// assumes that the likelihood of a collision with a GUID generated via
// base::GenerateGUID() will be vanishingly small.
//
// A previous version of this code generated GUIDs that used random bits for
// all but the first 32-bits. I.e. the scheme didn't respect the 6 fixed bits
// as prescribed for type 4 GUIDs. The resulting GUIDs are not believed to
// have an elevated risk of collision with GUIDs generated via
// base::GenerateGUID() and are considered valid by all known consumers. Hence
// no additional migration logic is being introduced to fix those GUIDs.
sql::Statement select(GetDB().GetUniqueStatement(
base::StringPrintf("SELECT id FROM %s", kDownloadsTable).c_str()));
sql::Statement update(GetDB().GetUniqueStatement(
base::StringPrintf("UPDATE %s SET guid = ? WHERE id = ?", kDownloadsTable)
.c_str()));
while (select.Step()) {
uint32_t id = select.ColumnInt(0);
uint64_t r1 = base::RandUint64();
uint64_t r2 = base::RandUint64();
std::string guid = base::StringPrintf(
"%08" PRIX32 "-%04" PRIX64 "-4%03" PRIX64 "-%04" PRIX64 "-%012" PRIX64,
id, r1 >> 48,
(r1 >> 36) & 0xfff,
((8 | ((r1 >> 34) & 3)) << 12) | ((r1 >> 22) & 0xfff),
r2 & 0xffffffffffff);
update.BindString(0, guid);
update.BindInt(1, id);
if (!update.Run())
return false;
update.Reset(true);
}
return true;
}
bool DownloadDatabase::MigrateDownloadTabUrl() {
return EnsureColumnExists("tab_url", "VARCHAR NOT NULL DEFAULT ''") &&
EnsureColumnExists("tab_referrer_url", "VARCHAR NOT NULL DEFAULT ''");
}
bool DownloadDatabase::MigrateDownloadSiteInstanceUrl() {
return EnsureColumnExists("site_url", "VARCHAR NOT NULL DEFAULT ''");
}
bool DownloadDatabase::MigrateDownloadLastAccessTime() {
return EnsureColumnExists("last_access_time", "INTEGER NOT NULL DEFAULT 0");
}
bool DownloadDatabase::MigrateDownloadTransient() {
return EnsureColumnExists("transient", "INTEGER NOT NULL DEFAULT 0");
}
bool DownloadDatabase::MigrateDownloadSliceFinished() {
return EnsureColumnExistsInTable(kDownloadsSlicesTable, "finished",
"INTEGER NOT NULL DEFAULT 0");
}
bool DownloadDatabase::InitDownloadTable() {
const std::string kSchema = base::StringPrintf(
"CREATE TABLE %s ("
"id INTEGER PRIMARY KEY," // Primary key.
"guid VARCHAR NOT NULL," // GUID.
"current_path LONGVARCHAR NOT NULL," // Current disk location
"target_path LONGVARCHAR NOT NULL," // Final disk location
"start_time INTEGER NOT NULL," // When the download was started.
"received_bytes INTEGER NOT NULL," // Total size downloaded.
"total_bytes INTEGER NOT NULL," // Total size of the download.
"state INTEGER NOT NULL," // 1=complete, 4=interrupted
"danger_type INTEGER NOT NULL," // Danger type, validated.
"interrupt_reason INTEGER NOT NULL," // DownloadInterruptReason
"hash BLOB NOT NULL," // Raw SHA-256 hash of contents.
"end_time INTEGER NOT NULL," // When the download completed.
"opened INTEGER NOT NULL," // 1 if it has ever been opened
// else 0
"last_access_time INTEGER NOT NULL," // The last time it was
// accessed.
"transient INTEGER NOT NULL," // 1 if it is transient, else 0.
"referrer VARCHAR NOT NULL," // HTTP Referrer
"site_url VARCHAR NOT NULL," // Site URL for initiating site
// instance.
"tab_url VARCHAR NOT NULL," // Tab URL for initiator.
"tab_referrer_url VARCHAR NOT NULL," // Tag referrer URL for
// initiator.
"http_method VARCHAR NOT NULL," // HTTP method.
"by_ext_id VARCHAR NOT NULL," // ID of extension that started the
// download
"by_ext_name VARCHAR NOT NULL," // name of extension
"etag VARCHAR NOT NULL," // ETag
"last_modified VARCHAR NOT NULL," // Last-Modified header
"mime_type VARCHAR(255) NOT NULL," // MIME type.
"original_mime_type VARCHAR(255) NOT NULL)" // Original MIME type.
,
kDownloadsTable);
const char kUrlChainSchema[] =
"CREATE TABLE downloads_url_chains ("
"id INTEGER NOT NULL," // downloads.id.
"chain_index INTEGER NOT NULL," // Index of url in chain
// 0 is initial target,
// MAX is target after redirects.
"url LONGVARCHAR NOT NULL, " // URL.
"PRIMARY KEY (id, chain_index) )";
const std::string kSlicesSchema = base::StringPrintf(
"CREATE TABLE %s ("
"download_id INTEGER NOT NULL," // downloads.id.
"offset INTEGER NOT NULL," // Offset in the target file.
"received_bytes INTEGER NOT NULL," // Total bytes downloaded.
"finished INTEGER NOT NULL DEFAULT 0," // If the slice is finished.
"PRIMARY KEY (download_id, offset) )",
kDownloadsSlicesTable);
bool ret;
if (GetDB().DoesTableExist(kDownloadsTable)) {
// If the "downloads" table exists, "downloads_url_chain" might not be there
// as it is introduced in version 24. A migration function will be run to
// create it later.
ret = EnsureColumnExists("end_time", "INTEGER NOT NULL DEFAULT 0") &&
EnsureColumnExists("opened", "INTEGER NOT NULL DEFAULT 0");
} else {
// If the "downloads" table doesn't exist, neither should the
// "downloads_url_chain" table.
ret = !GetDB().DoesTableExist("downloads_url_chain");
// Recreate the "downloads" and "downloads_url_chain" table.
ret = ret && GetDB().Execute(kSchema.c_str()) &&
GetDB().Execute(kUrlChainSchema);
}
// Making sure the "downloads_slices" table is created as it is introduced in
// version 33. This table doesn't require migration of existing tables.
return ret && (GetDB().DoesTableExist(kDownloadsSlicesTable) ||
GetDB().Execute(kSlicesSchema.c_str()));
}
uint32_t DownloadDatabase::GetNextDownloadId() {
sql::Statement select_max_id(GetDB().GetUniqueStatement(
base::StringPrintf("SELECT max(id) FROM %s", kDownloadsTable).c_str()));
bool result = select_max_id.Step();
DCHECK(result);
// If there are zero records in the downloads table, then max(id) will
// return 0 = kInvalidDownloadId, so GetNextDownloadId() will set
// *id = kInvalidDownloadId + 1.
//
// If there is at least one record but all of the |id|s are
// <= kInvalidDownloadId, then max(id) will return <= kInvalidDownloadId,
// so GetNextDownloadId() should return kInvalidDownloadId + 1.
//
// Note that any records with |id <= kInvalidDownloadId| will be dropped in
// QueryDownloads().
//
// SQLITE doesn't have unsigned integers.
return 1 + static_cast<uint32_t>(
std::max(static_cast<int64_t>(kInvalidDownloadId),
select_max_id.ColumnInt64(0)));
}
bool DownloadDatabase::DropDownloadTable() {
return GetDB().Execute(
base::StringPrintf("DROP TABLE %s", kDownloadsTable).c_str());
}
void DownloadDatabase::QueryDownloads(std::vector<DownloadRow>* results) {
EnsureInProgressEntriesCleanedUp();
results->clear();
std::set<uint32_t> ids;
DownloadRowMap info_map;
sql::Statement statement_main(GetDB().GetCachedStatement(
SQL_FROM_HERE,
base::StringPrintf(
"SELECT id, guid, current_path, target_path, mime_type, "
"original_mime_type, start_time, received_bytes, total_bytes, state, "
"danger_type, interrupt_reason, hash, end_time, opened, "
"last_access_time, transient, referrer, site_url, tab_url, "
"tab_referrer_url, http_method, by_ext_id, by_ext_name, etag, "
"last_modified FROM %s ORDER BY start_time",
kDownloadsTable)
.c_str()));
while (statement_main.Step()) {
std::unique_ptr<DownloadRow> info(new DownloadRow());
int column = 0;
// SQLITE does not have unsigned integers, so explicitly handle negative
// |id|s instead of casting them to very large uint32s, which would break
// the max(id) logic in GetNextDownloadId().
int64_t signed_id = statement_main.ColumnInt64(column++);
bool valid = ConvertIntToDownloadId(signed_id, &(info->id));
info->guid = statement_main.ColumnString(column++);
info->current_path = ColumnFilePath(statement_main, column++);
info->target_path = ColumnFilePath(statement_main, column++);
info->mime_type = statement_main.ColumnString(column++);
info->original_mime_type = statement_main.ColumnString(column++);
info->start_time =
base::Time::FromInternalValue(statement_main.ColumnInt64(column++));
info->received_bytes = statement_main.ColumnInt64(column++);
info->total_bytes = statement_main.ColumnInt64(column++);
int state = statement_main.ColumnInt(column++);
info->state = IntToDownloadState(state);
info->danger_type =
IntToDownloadDangerType(statement_main.ColumnInt(column++));
info->interrupt_reason =
IntToDownloadInterruptReason(statement_main.ColumnInt(column++));
statement_main.ColumnBlobAsString(column++, &info->hash);
info->end_time =
base::Time::FromInternalValue(statement_main.ColumnInt64(column++));
info->opened = statement_main.ColumnInt(column++) != 0;
info->last_access_time =
base::Time::FromInternalValue(statement_main.ColumnInt64(column++));
info->transient = statement_main.ColumnInt(column++) != 0;
info->referrer_url = GURL(statement_main.ColumnString(column++));
info->site_url = GURL(statement_main.ColumnString(column++));
info->tab_url = GURL(statement_main.ColumnString(column++));
info->tab_referrer_url = GURL(statement_main.ColumnString(column++));
info->http_method = statement_main.ColumnString(column++);
info->by_ext_id = statement_main.ColumnString(column++);
info->by_ext_name = statement_main.ColumnString(column++);
info->etag = statement_main.ColumnString(column++);
info->last_modified = statement_main.ColumnString(column++);
// If the record is corrupted, note that and drop it.
// http://crbug.com/251269
DroppedReason dropped_reason = DROPPED_REASON_MAX;
if (!valid) {
// SQLITE doesn't have unsigned integers.
dropped_reason = DROPPED_REASON_BAD_ID;
} else if (!ids.insert(info->id).second) {
dropped_reason = DROPPED_REASON_DUPLICATE_ID;
NOTREACHED() << info->id;
} else if (info->state == DownloadState::INVALID) {
dropped_reason = DROPPED_REASON_BAD_STATE;
} else if (info->danger_type == DownloadDangerType::INVALID) {
dropped_reason = DROPPED_REASON_BAD_DANGER_TYPE;
}
if (dropped_reason == DROPPED_REASON_MAX) {
DCHECK(!base::ContainsKey(info_map, info->id));
uint32_t id = info->id;
info_map[id] = info.release();
}
}
sql::Statement statement_chain(GetDB().GetCachedStatement(
SQL_FROM_HERE,
"SELECT id, chain_index, url FROM downloads_url_chains "
"ORDER BY id, chain_index"));
while (statement_chain.Step()) {
int column = 0;
// See the comment above about SQLITE lacking unsigned integers.
int64_t signed_id = statement_chain.ColumnInt64(column++);
int chain_index = statement_chain.ColumnInt(column++);
DownloadId id = kInvalidDownloadId;
if (!ConvertIntToDownloadId(signed_id, &id))
continue;
// Confirm the id has already been seen--if it hasn't, discard the
// record.
if (!base::ContainsKey(info_map, id))
continue;
// Confirm all previous URLs in the chain have already been seen;
// if not, fill in with null or discard record.
int current_chain_size = static_cast<int>(info_map[id]->url_chain.size());
std::vector<GURL>* url_chain(&info_map[id]->url_chain);
// Note that this DCHECK may trip as a result of corrupted databases.
// It exists because in debug builds the chances are higher there's
// an actual bug than that the database is corrupt. The DB corruption
// case in handled in production code.
DCHECK_EQ(chain_index, current_chain_size);
while (current_chain_size < chain_index) {
url_chain->push_back(GURL());
current_chain_size++;
}
if (current_chain_size > chain_index)
continue;
// Save the record.
url_chain->push_back(GURL(statement_chain.ColumnString(2)));
}
QueryDownloadSlices(&info_map);
for (auto it = info_map.begin(); it != info_map.end(); ++it) {
DownloadRow* row = it->second;
bool empty_url_chain = row->url_chain.empty();
UMA_HISTOGRAM_BOOLEAN("Download.DatabaseEmptyUrlChain", empty_url_chain);
if (empty_url_chain) {
RemoveDownload(row->id);
} else {
// Copy the contents of the stored info.
results->push_back(*row);
}
delete row;
it->second = NULL;
}
}
bool DownloadDatabase::UpdateDownload(const DownloadRow& data) {
// UpdateDownload() is called fairly frequently.
EnsureInProgressEntriesCleanedUp();
DCHECK_NE(kInvalidDownloadId, data.id);
if (data.state == DownloadState::INVALID) {
NOTREACHED();
return false;
}
if (data.danger_type == DownloadDangerType::INVALID) {
NOTREACHED();
return false;
}
sql::Statement statement(GetDB().GetCachedStatement(
SQL_FROM_HERE,
base::StringPrintf("UPDATE %s "
"SET current_path=?, target_path=?, "
"mime_type=?, original_mime_type=?, "
"received_bytes=?, state=?, "
"danger_type=?, interrupt_reason=?, hash=?, "
"end_time=?, total_bytes=?, "
"opened=?, last_access_time=?, transient=?, "
"by_ext_id=?, by_ext_name=?, "
"etag=?, last_modified=? WHERE id=?",
kDownloadsTable)
.c_str()));
int column = 0;
BindFilePath(statement, data.current_path, column++);
BindFilePath(statement, data.target_path, column++);
statement.BindString(column++, data.mime_type);
statement.BindString(column++, data.original_mime_type);
statement.BindInt64(column++, data.received_bytes);
statement.BindInt(column++, DownloadStateToInt(data.state));
statement.BindInt(column++, DownloadDangerTypeToInt(data.danger_type));
statement.BindInt(column++,
DownloadInterruptReasonToInt(data.interrupt_reason));
statement.BindBlob(column++, data.hash.data(), data.hash.size());
statement.BindInt64(column++, data.end_time.ToInternalValue());
statement.BindInt64(column++, data.total_bytes);
statement.BindInt(column++, (data.opened ? 1 : 0));
statement.BindInt64(column++, data.last_access_time.ToInternalValue());
statement.BindInt(column++, (data.transient ? 1 : 0));
statement.BindString(column++, data.by_ext_id);
statement.BindString(column++, data.by_ext_name);
statement.BindString(column++, data.etag);
statement.BindString(column++, data.last_modified);
statement.BindInt(column++, DownloadIdToInt(data.id));
if (!statement.Run())
return false;
if (data.download_slice_info.size() == 0) {
RemoveDownloadSlices(data.id);
} else {
for (size_t i = 0; i < data.download_slice_info.size(); ++i) {
if (!CreateOrUpdateDownloadSlice(data.download_slice_info[i]))
return false;
}
}
return true;
}
void DownloadDatabase::EnsureInProgressEntriesCleanedUp() {
if (in_progress_entry_cleanup_completed_)
return;
sql::Statement statement(GetDB().GetCachedStatement(
SQL_FROM_HERE,
base::StringPrintf(
"UPDATE %s SET state=?, interrupt_reason=? WHERE state=?",
kDownloadsTable)
.c_str()));
statement.BindInt(0, DownloadStateToInt(DownloadState::INTERRUPTED));
statement.BindInt(
1, DownloadInterruptReasonToInt(download_interrupt_reason_crash_));
statement.BindInt(2, DownloadStateToInt(DownloadState::IN_PROGRESS));
statement.Run();
in_progress_entry_cleanup_completed_ = true;
}
bool DownloadDatabase::CreateDownload(const DownloadRow& info) {
DCHECK_NE(kInvalidDownloadId, info.id);
DCHECK(!info.guid.empty());
EnsureInProgressEntriesCleanedUp();
if (info.url_chain.empty())
return false;
if (info.state == DownloadState::INVALID)
return false;
if (info.danger_type == DownloadDangerType::INVALID)
return false;
{
sql::Statement statement_insert(GetDB().GetCachedStatement(
SQL_FROM_HERE,
base::StringPrintf(
"INSERT INTO %s "
"(id, guid, current_path, target_path, mime_type, "
"original_mime_type, "
" start_time, received_bytes, total_bytes, state, danger_type, "
" interrupt_reason, hash, end_time, opened, last_access_time, "
"transient, referrer, site_url, tab_url, tab_referrer_url, "
"http_method, "
" by_ext_id, by_ext_name, etag, last_modified) "
"VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, "
" ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, "
" ?, ?, ?, ?, ?, ?)",
kDownloadsTable)
.c_str()));
int column = 0;
statement_insert.BindInt(column++, DownloadIdToInt(info.id));
statement_insert.BindString(column++, info.guid);
BindFilePath(statement_insert, info.current_path, column++);
BindFilePath(statement_insert, info.target_path, column++);
statement_insert.BindString(column++, info.mime_type);
statement_insert.BindString(column++, info.original_mime_type);
statement_insert.BindInt64(column++, info.start_time.ToInternalValue());
statement_insert.BindInt64(column++, info.received_bytes);
statement_insert.BindInt64(column++, info.total_bytes);
statement_insert.BindInt(column++, DownloadStateToInt(info.state));
statement_insert.BindInt(column++,
DownloadDangerTypeToInt(info.danger_type));
statement_insert.BindInt(
column++, DownloadInterruptReasonToInt(info.interrupt_reason));
statement_insert.BindBlob(column++, info.hash.data(), info.hash.size());
statement_insert.BindInt64(column++, info.end_time.ToInternalValue());
statement_insert.BindInt(column++, info.opened ? 1 : 0);
statement_insert.BindInt64(column++,
info.last_access_time.ToInternalValue());
statement_insert.BindInt(column++, info.transient ? 1 : 0);
statement_insert.BindString(column++, info.referrer_url.spec());
statement_insert.BindString(column++, info.site_url.spec());
statement_insert.BindString(column++, info.tab_url.spec());
statement_insert.BindString(column++, info.tab_referrer_url.spec());
statement_insert.BindString(column++, info.http_method);
statement_insert.BindString(column++, info.by_ext_id);
statement_insert.BindString(column++, info.by_ext_name);
statement_insert.BindString(column++, info.etag);
statement_insert.BindString(column++, info.last_modified);
if (!statement_insert.Run()) {
// GetErrorCode() returns a bitmask where the lower byte is a more general
// code and the upper byte is a more specific code. In order to save
// memory, take the general code, of which there are fewer than 50. See
// also sql/connection.cc
// http://www.sqlite.org/c3ref/c_abort_rollback.html
UMA_HISTOGRAM_ENUMERATION("Download.DatabaseMainInsertError",
GetDB().GetErrorCode() & 0xff, 50);
return false;
}
}
{
sql::Statement count_urls(GetDB().GetCachedStatement(SQL_FROM_HERE,
"SELECT count(*) FROM downloads_url_chains WHERE id=?"));
count_urls.BindInt(0, info.id);
if (count_urls.Step()) {
bool corrupt_urls = count_urls.ColumnInt(0) > 0;
if (corrupt_urls) {
// There should not be any URLs in downloads_url_chains for this
// info.id. If there are, we don't want them to interfere with
// inserting the correct URLs, so just remove them.
RemoveDownloadURLs(info.id);
}
}
}
sql::Statement statement_insert_chain(
GetDB().GetCachedStatement(SQL_FROM_HERE,
"INSERT INTO downloads_url_chains "
"(id, chain_index, url) "
"VALUES (?, ?, ?)"));
for (size_t i = 0; i < info.url_chain.size(); ++i) {
statement_insert_chain.BindInt(0, info.id);
statement_insert_chain.BindInt(1, static_cast<int>(i));
statement_insert_chain.BindString(2, info.url_chain[i].spec());
if (!statement_insert_chain.Run()) {
UMA_HISTOGRAM_ENUMERATION("Download.DatabaseURLChainInsertError",
GetDB().GetErrorCode() & 0xff, 50);
RemoveDownload(info.id);
return false;
}
statement_insert_chain.Reset(true);
}
for (size_t i = 0; i < info.download_slice_info.size(); ++i) {
if (!CreateOrUpdateDownloadSlice(info.download_slice_info[i])) {
RemoveDownload(info.id);
return false;
}
}
return true;
}
void DownloadDatabase::RemoveDownload(DownloadId id) {
EnsureInProgressEntriesCleanedUp();
sql::Statement downloads_statement(GetDB().GetCachedStatement(
SQL_FROM_HERE,
base::StringPrintf("DELETE FROM %s WHERE id=?", kDownloadsTable)
.c_str()));
downloads_statement.BindInt(0, id);
if (!downloads_statement.Run()) {
UMA_HISTOGRAM_ENUMERATION("Download.DatabaseMainDeleteError",
GetDB().GetErrorCode() & 0xff, 50);
return;
}
RemoveDownloadURLs(id);
RemoveDownloadSlices(id);
}
void DownloadDatabase::RemoveDownloadURLs(DownloadId id) {
sql::Statement urlchain_statement(GetDB().GetCachedStatement(SQL_FROM_HERE,
"DELETE FROM downloads_url_chains WHERE id=?"));
urlchain_statement.BindInt(0, id);
if (!urlchain_statement.Run()) {
UMA_HISTOGRAM_ENUMERATION("Download.DatabaseURLChainDeleteError",
GetDB().GetErrorCode() & 0xff, 50);
}
}
size_t DownloadDatabase::CountDownloads() {
EnsureInProgressEntriesCleanedUp();
sql::Statement statement(GetDB().GetCachedStatement(
SQL_FROM_HERE,
base::StringPrintf("SELECT count(*) from %s", kDownloadsTable).c_str()));
statement.Step();
return statement.ColumnInt(0);
}
bool DownloadDatabase::CreateOrUpdateDownloadSlice(
const DownloadSliceInfo& info) {
// If the slice has no data, there is no need to insert it into the db. Note
// that for each slice, |received_bytes| can only go up. So if a slice is
// already in the db, its |received_bytes| should always be larger than 0.
if (info.received_bytes == 0)
return true;
sql::Statement statement_replace(GetDB().GetCachedStatement(
SQL_FROM_HERE,
base::StringPrintf("REPLACE INTO %s "
"(download_id, offset, received_bytes, finished) "
"VALUES (?, ?, ?, ?)",
kDownloadsSlicesTable)
.c_str()));
int column = 0;
statement_replace.BindInt(column++, info.download_id);
statement_replace.BindInt64(column++, info.offset);
statement_replace.BindInt64(column++, info.received_bytes);
statement_replace.BindInt64(column++, (info.finished ? 1 : 0));
return statement_replace.Run();
}
void DownloadDatabase::RemoveDownloadSlices(DownloadId id) {
sql::Statement statement_delete(GetDB().GetCachedStatement(
SQL_FROM_HERE, base::StringPrintf("DELETE FROM %s WHERE download_id=?",
kDownloadsSlicesTable)
.c_str()));
statement_delete.BindInt(0, id);
statement_delete.Run();
}
void DownloadDatabase::QueryDownloadSlices(DownloadRowMap* download_row_map) {
DCHECK(download_row_map);
sql::Statement statement_query(GetDB().GetCachedStatement(
SQL_FROM_HERE,
base::StringPrintf("SELECT download_id, offset, received_bytes, finished "
"FROM %s "
"ORDER BY download_id, offset",
kDownloadsSlicesTable)
.c_str()));
while (statement_query.Step()) {
int column = 0;
DownloadSliceInfo info;
// Convert signed integer from sqlite to unsigned DownloadId.
int64_t signed_id = statement_query.ColumnInt64(column++);
bool success = ConvertIntToDownloadId(signed_id, &info.download_id);
DCHECK(success) << "Invalid download ID found in downloads_slices table "
<< signed_id;
info.offset = statement_query.ColumnInt64(column++);
info.received_bytes = statement_query.ColumnInt64(column++);
info.finished = static_cast<bool>(statement_query.ColumnInt64(column++));
// Confirm the download_id has already been seen--if it hasn't, discard the
// record.
auto it = download_row_map->find(info.download_id);
bool found = (it != download_row_map->end());
UMA_HISTOGRAM_BOOLEAN(
"Download.DatabaseDownloadExistsForDownloadSlice", found);
if (!found) {
RemoveDownloadSlices(info.download_id);
continue;
}
it->second->download_slice_info.push_back(info);
}
}
} // namespace history