Clean up entries left by crashes in the DownloadDB.

chrome/browser/history/download_database.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/history/download_database.h"
 
 #include <limits>
 #include <string>
 #include <vector>
 
@@ skipping 12 matching lines @@
 #include "content/public/browser/download_item.h"
 #include "sql/statement.h"
 
 using content::DownloadItem;
 
 namespace history {
 
 // static
 const int64 DownloadDatabase::kUninitializedHandle = -1;
 
+// These constants and the transformation functions below are used to allow
+// DownloadItem::DownloadState and DownloadDangerType to change without
+// breaking the database schema.
+// They guarantee that the values of the |state| field in the database are one
+// of the values returned by StateToInt, and that the values of the |state|
+// field of the DownloadRows returned by QueryDownloads() are one of the values
+// returned by IntToState().
+const int DownloadDatabase::kStateInvalid = -1;
+const int DownloadDatabase::kStateInProgress = 0;
+const int DownloadDatabase::kStateComplete = 1;
+const int DownloadDatabase::kStateCancelled = 2;
+const int DownloadDatabase::kStateBug140687 = 3;
+const int DownloadDatabase::kStateInterrupted = 4;
+
+const int DownloadDatabase::kDangerTypeInvalid = -1;
+const int DownloadDatabase::kDangerTypeNotDangerous = 0;
+const int DownloadDatabase::kDangerTypeDangerousFile = 1;
+const int DownloadDatabase::kDangerTypeDangerousUrl = 2;
+const int DownloadDatabase::kDangerTypeDangerousContent = 3;
+const int DownloadDatabase::kDangerTypeMaybeDangerousContent = 4;
+const int DownloadDatabase::kDangerTypeUncommonContent = 5;
+const int DownloadDatabase::kDangerTypeUserValidated = 6;
+const int DownloadDatabase::kDangerTypeDangerousHost = 7;
+
 namespace {
 
 // Reason for dropping a particular record.
 enum DroppedReason {
   DROPPED_REASON_BAD_STATE = 0,
   DROPPED_REASON_BAD_DANGER_TYPE = 1,
   DROPPED_REASON_MAX
 };
 
 static const char kSchema[] =
@@ skipping 12 matching lines @@
 
 static 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) )";
 
-// These constants and next two functions are used to allow
-// DownloadItem::DownloadState and DownloadDangerType to change without
-// breaking the database schema.
-// They guarantee that the values of the |state| field in the database are one
-// of the values returned by StateToInt, and that the values of the |state|
-// field of the DownloadRows returned by QueryDownloads() are one of the values
-// returned by IntToState().
-static const int kStateInvalid = -1;
-static const int kStateInProgress = 0;
-static const int kStateComplete = 1;
-static const int kStateCancelled = 2;
-static const int kStateBug140687 = 3;
-static const int kStateInterrupted = 4;
-
-static const int kDangerTypeInvalid = -1;
-static const int kDangerTypeNotDangerous = 0;
-static const int kDangerTypeDangerousFile = 1;
-static const int kDangerTypeDangerousUrl = 2;
-static const int kDangerTypeDangerousContent = 3;
-static const int kDangerTypeMaybeDangerousContent = 4;
-static const int kDangerTypeUncommonContent = 5;
-static const int kDangerTypeUserValidated = 6;
-static const int kDangerTypeDangerousHost = 7;
-
 int StateToInt(DownloadItem::DownloadState state) {
   switch (state) {
-    case DownloadItem::IN_PROGRESS: return kStateInProgress;
-    case DownloadItem::COMPLETE: return kStateComplete;
-    case DownloadItem::CANCELLED: return kStateCancelled;
-    case DownloadItem::INTERRUPTED: return kStateInterrupted;
+    case DownloadItem::IN_PROGRESS: return DownloadDatabase::kStateInProgress;
+    case DownloadItem::COMPLETE: return DownloadDatabase::kStateComplete;
+    case DownloadItem::CANCELLED: return DownloadDatabase::kStateCancelled;
+    case DownloadItem::INTERRUPTED: return DownloadDatabase::kStateInterrupted;
     case DownloadItem::MAX_DOWNLOAD_STATE:
       NOTREACHED();
-      return kStateInvalid;
+      return DownloadDatabase::kStateInvalid;
   }
   NOTREACHED();
-  return kStateInvalid;
+  return DownloadDatabase::kStateInvalid;
 }
 
 DownloadItem::DownloadState IntToState(int state) {
   switch (state) {
-    case kStateInProgress: return DownloadItem::IN_PROGRESS;
-    case kStateComplete: return DownloadItem::COMPLETE;
-    case kStateCancelled: return DownloadItem::CANCELLED;
+    case DownloadDatabase::kStateInProgress: return DownloadItem::IN_PROGRESS;
+    case DownloadDatabase::kStateComplete: return DownloadItem::COMPLETE;
+    case DownloadDatabase::kStateCancelled: return DownloadItem::CANCELLED;
     // We should not need kStateBug140687 here because MigrateDownloadsState()
     // is called in HistoryDatabase::Init().
-    case kStateInterrupted: return DownloadItem::INTERRUPTED;
+    case DownloadDatabase::kStateInterrupted: return DownloadItem::INTERRUPTED;
     default: return DownloadItem::MAX_DOWNLOAD_STATE;
   }
 }
 
 int DangerTypeToInt(content::DownloadDangerType danger_type) {
   switch (danger_type) {
     case content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS:
-      return kDangerTypeNotDangerous;
+      return DownloadDatabase::kDangerTypeNotDangerous;
     case content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE:
-      return kDangerTypeDangerousFile;
+      return DownloadDatabase::kDangerTypeDangerousFile;
     case content::DOWNLOAD_DANGER_TYPE_DANGEROUS_URL:
-      return kDangerTypeDangerousUrl;
+      return DownloadDatabase::kDangerTypeDangerousUrl;
     case content::DOWNLOAD_DANGER_TYPE_DANGEROUS_CONTENT:
-      return kDangerTypeDangerousContent;
+      return DownloadDatabase::kDangerTypeDangerousContent;
     case content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT:
-      return kDangerTypeMaybeDangerousContent;
+      return DownloadDatabase::kDangerTypeMaybeDangerousContent;
     case content::DOWNLOAD_DANGER_TYPE_UNCOMMON_CONTENT:
-      return kDangerTypeUncommonContent;
+      return DownloadDatabase::kDangerTypeUncommonContent;
     case content::DOWNLOAD_DANGER_TYPE_USER_VALIDATED:
-      return kDangerTypeUserValidated;
+      return DownloadDatabase::kDangerTypeUserValidated;
     case content::DOWNLOAD_DANGER_TYPE_DANGEROUS_HOST:
-      return kDangerTypeDangerousHost;
+      return DownloadDatabase::kDangerTypeDangerousHost;
     case content::DOWNLOAD_DANGER_TYPE_MAX:
       NOTREACHED();
-      return kDangerTypeInvalid;
+      return DownloadDatabase::kDangerTypeInvalid;
   }
   NOTREACHED();
-  return kDangerTypeInvalid;
+  return DownloadDatabase::kDangerTypeInvalid;
 }
 
 content::DownloadDangerType IntToDangerType(int danger_type) {
   switch (danger_type) {
-    case kDangerTypeNotDangerous:
+    case DownloadDatabase::kDangerTypeNotDangerous:
       return content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS;
-    case kDangerTypeDangerousFile:
+    case DownloadDatabase::kDangerTypeDangerousFile:
       return content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE;
-    case kDangerTypeDangerousUrl:
+    case DownloadDatabase::kDangerTypeDangerousUrl:
       return content::DOWNLOAD_DANGER_TYPE_DANGEROUS_URL;
-    case kDangerTypeDangerousContent:
+    case DownloadDatabase::kDangerTypeDangerousContent:
       return content::DOWNLOAD_DANGER_TYPE_DANGEROUS_CONTENT;
-    case kDangerTypeMaybeDangerousContent:
+    case DownloadDatabase::kDangerTypeMaybeDangerousContent:
       return content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT;
-    case kDangerTypeUncommonContent:
+    case DownloadDatabase::kDangerTypeUncommonContent:
       return content::DOWNLOAD_DANGER_TYPE_UNCOMMON_CONTENT;
-    case kDangerTypeUserValidated:
+    case DownloadDatabase::kDangerTypeUserValidated:
       return content::DOWNLOAD_DANGER_TYPE_USER_VALIDATED;
-    case kDangerTypeDangerousHost:
+    case DownloadDatabase::kDangerTypeDangerousHost:
       return content::DOWNLOAD_DANGER_TYPE_DANGEROUS_HOST;
     default:
       return content::DOWNLOAD_DANGER_TYPE_MAX;
   }
 }
 
 #if defined(OS_POSIX)
 
 // Binds/reads the given file path to the given column of the given statement.
 void BindFilePath(sql::Statement& statement, const base::FilePath& path,
@@ skipping 20 matching lines @@
 // Key in the meta_table containing the next id to use for a new download in
 // this profile.
 static const char kNextDownloadId[] = "next_download_id";
 
 }  // namespace
 
 DownloadDatabase::DownloadDatabase()
     : owning_thread_set_(false),
       owning_thread_(0),
       next_id_(0),
-      next_db_handle_(0) {
+      next_db_handle_(0),
+      in_progress_entry_cleanup_completed_(false) {
 }
 
 DownloadDatabase::~DownloadDatabase() {
 }
 
 bool DownloadDatabase::EnsureColumnExists(
     const std::string& name, const std::string& type) {
   std::string add_col = "ALTER TABLE downloads ADD COLUMN " + name + " " + type;
   return GetDB().DoesColumnExist("downloads", name.c_str()) ||
          GetDB().Execute(add_col.c_str());
@@ skipping 67 matching lines @@
             GetDB().Execute(kSchema) && GetDB().Execute(kUrlChainSchema));
   }
 }
 
 bool DownloadDatabase::DropDownloadTable() {
   return GetDB().Execute("DROP TABLE downloads");
 }
 
 void DownloadDatabase::QueryDownloads(
     std::vector<DownloadRow>* results) {
+  if (!in_progress_entry_cleanup_completed_)
+    CleanUpInProgressEntries();
+
   results->clear();
   if (next_db_handle_ < 1)
     next_db_handle_ = 1;
   std::set<int64> db_handles;
 
   std::map<DownloadID, DownloadRow*> info_map;
 
   sql::Statement statement_main(GetDB().GetCachedStatement(SQL_FROM_HERE,
       "SELECT id, current_path, target_path, start_time, received_bytes, "
         "total_bytes, state, danger_type, interrupt_reason, end_time, opened "
@@ skipping 91 matching lines @@
   for (std::map<DownloadID, DownloadRow*>::iterator
            it = info_map.begin(); it != info_map.end(); ++it) {
     // Copy the contents of the stored info.
     results->push_back(*it->second);
     delete it->second;
     it->second = NULL;
   }
 }
 
 bool DownloadDatabase::UpdateDownload(const DownloadRow& data) {
+  if (!in_progress_entry_cleanup_completed_)
+    CleanUpInProgressEntries();
+
   DCHECK(data.db_handle > 0);
   int state = StateToInt(data.state);
   if (state == kStateInvalid) {
     NOTREACHED();
     return false;
   }
   int danger_type = DangerTypeToInt(data.danger_type);
   if (danger_type == kDangerTypeInvalid) {
     NOTREACHED();
     return false;
@@ skipping 12 matching lines @@
   statement.BindInt(column++, danger_type);
   statement.BindInt(column++, static_cast<int>(data.interrupt_reason));
   statement.BindInt64(column++, data.end_time.ToInternalValue());
   statement.BindInt(column++, data.total_bytes);
   statement.BindInt(column++, (data.opened ? 1 : 0));
   statement.BindInt64(column++, data.db_handle);
 
   return statement.Run();
 }
 
-bool DownloadDatabase::CleanUpInProgressEntries() {
+void DownloadDatabase::CleanUpInProgressEntries() {

[brettw, 2013/04/01 23:52:51]

I sort of prefer the scheme where the function is
EnsureInProgressEntriesCleanedUp() and it checks the flag and returns early,
which saves you the bool check in every caller. You can keep it like this if you
prefer, though.

[Randy Smith (Not in Mondays), 2013/04/02 18:58:52]

Done.

   sql::Statement statement(GetDB().GetCachedStatement(SQL_FROM_HERE,
-      "UPDATE downloads SET state=? WHERE state=?"));
-  statement.BindInt(0, kStateCancelled);
-  statement.BindInt(1, kStateInProgress);
+      "UPDATE downloads SET state=?, interrupt_reason=? WHERE state=?"));
+  statement.BindInt(0, kStateInterrupted);
+  statement.BindInt(1, content::DOWNLOAD_INTERRUPT_REASON_CRASH);
+  statement.BindInt(2, kStateInProgress);
 
-  return statement.Run();
+  statement.Run();
+  in_progress_entry_cleanup_completed_ = true;
 }
 
 int64 DownloadDatabase::CreateDownload(
     const DownloadRow& info) {
+  if (!in_progress_entry_cleanup_completed_)
+    CleanUpInProgressEntries();
+
   if (next_db_handle_ == 0) {
     // This is unlikely. All current known tests and users already call
     // QueryDownloads() before CreateDownload().
     std::vector<DownloadRow> results;
     QueryDownloads(&results);
     CHECK_NE(0, next_db_handle_);
   }
 
   int state = StateToInt(info.state);
   if (state == kStateInvalid)
@@ skipping 48 matching lines @@
     statement_insert_chain.Reset(true);
   }
 
   // TODO(benjhayden) if(info.id>next_id_){setvalue;next_id_=info.id;}
   GetMetaTable().SetValue(kNextDownloadId, ++next_id_);
 
   return db_handle;
 }
 
 void DownloadDatabase::RemoveDownload(int64 handle) {
+  if (!in_progress_entry_cleanup_completed_)
+    CleanUpInProgressEntries();
+
   sql::Statement downloads_statement(GetDB().GetCachedStatement(SQL_FROM_HERE,
       "DELETE FROM downloads WHERE id=?"));
   downloads_statement.BindInt64(0, handle);
   downloads_statement.Run();
 
   sql::Statement urlchain_statement(GetDB().GetCachedStatement(SQL_FROM_HERE,
       "DELETE FROM downloads_url_chains WHERE id=?"));
   urlchain_statement.BindInt64(0, handle);
   urlchain_statement.Run();
 }
 
 int DownloadDatabase::CountDownloads() {
+  if (!in_progress_entry_cleanup_completed_)
+    CleanUpInProgressEntries();
+
   sql::Statement statement(GetDB().GetCachedStatement(SQL_FROM_HERE,
       "SELECT count(*) from downloads"));
   statement.Step();
   return statement.ColumnInt(0);
 }
 
 }  // namespace history