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>
 
 #include "base/debug/alias.h"
 #include "base/files/file_path.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/stringprintf.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "chrome/browser/history/download_row.h"
 #include "chrome/browser/history/history_types.h"
 #include "content/public/browser/download_interrupt_reasons.h"
 #include "content/public/browser/download_item.h"
 #include "sql/statement.h"
 
 using content::DownloadItem;
 
 namespace history {
 
-// static
-const int64 DownloadDatabase::kUninitializedHandle = -1;
-
 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::MAX_DOWNLOAD_STATE:
-      NOTREACHED();
-      return kStateInvalid;
-  }
-  NOTREACHED();
-  return kStateInvalid;
-}
-
-DownloadItem::DownloadState IntToState(int state) {
-  switch (state) {
-    case kStateInProgress: return DownloadItem::IN_PROGRESS;
-    case kStateComplete: return DownloadItem::COMPLETE;
-    case kStateCancelled: return DownloadItem::CANCELLED;
-    // We should not need kStateBug140687 here because MigrateDownloadsState()
-    // is called in HistoryDatabase::Init().
-    case 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;
-    case content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE:
-      return kDangerTypeDangerousFile;
-    case content::DOWNLOAD_DANGER_TYPE_DANGEROUS_URL:
-      return kDangerTypeDangerousUrl;
-    case content::DOWNLOAD_DANGER_TYPE_DANGEROUS_CONTENT:
-      return kDangerTypeDangerousContent;
-    case content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT:
-      return kDangerTypeMaybeDangerousContent;
-    case content::DOWNLOAD_DANGER_TYPE_UNCOMMON_CONTENT:
-      return kDangerTypeUncommonContent;
-    case content::DOWNLOAD_DANGER_TYPE_USER_VALIDATED:
-      return kDangerTypeUserValidated;
-    case content::DOWNLOAD_DANGER_TYPE_DANGEROUS_HOST:
-      return kDangerTypeDangerousHost;
-    case content::DOWNLOAD_DANGER_TYPE_MAX:
-      NOTREACHED();
-      return kDangerTypeInvalid;
-  }
-  NOTREACHED();
-  return kDangerTypeInvalid;
-}
-
-content::DownloadDangerType IntToDangerType(int danger_type) {
-  switch (danger_type) {
-    case kDangerTypeNotDangerous:
-      return content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS;
-    case kDangerTypeDangerousFile:
-      return content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE;
-    case kDangerTypeDangerousUrl:
-      return content::DOWNLOAD_DANGER_TYPE_DANGEROUS_URL;
-    case kDangerTypeDangerousContent:
-      return content::DOWNLOAD_DANGER_TYPE_DANGEROUS_CONTENT;
-    case kDangerTypeMaybeDangerousContent:
-      return content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT;
-    case kDangerTypeUncommonContent:
-      return content::DOWNLOAD_DANGER_TYPE_UNCOMMON_CONTENT;
-    case kDangerTypeUserValidated:
-      return content::DOWNLOAD_DANGER_TYPE_USER_VALIDATED;
-    case 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,
                   int col) {
   statement.BindString(col, path.value());
 }
 base::FilePath ColumnFilePath(sql::Statement& statement, int col) {
   return base::FilePath(statement.ColumnString(col));
 }
@@ skipping 10 matching lines @@
 }
 
 #endif
 
 // 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
 
+// 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;
+
+int DownloadDatabase::StateToInt(DownloadItem::DownloadState state) {
+  switch (state) {
+    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 DownloadDatabase::kStateInvalid;
+  }
+  NOTREACHED();
+  return DownloadDatabase::kStateInvalid;
+}
+
+DownloadItem::DownloadState DownloadDatabase::IntToState(int state) {
+  switch (state) {
+    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 DownloadDatabase::kStateInterrupted: return DownloadItem::INTERRUPTED;
+    default: return DownloadItem::MAX_DOWNLOAD_STATE;
+  }
+}
+
+int DownloadDatabase::DangerTypeToInt(content::DownloadDangerType danger_type) {
+  switch (danger_type) {
+    case content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS:
+      return DownloadDatabase::kDangerTypeNotDangerous;
+    case content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE:
+      return DownloadDatabase::kDangerTypeDangerousFile;
+    case content::DOWNLOAD_DANGER_TYPE_DANGEROUS_URL:
+      return DownloadDatabase::kDangerTypeDangerousUrl;
+    case content::DOWNLOAD_DANGER_TYPE_DANGEROUS_CONTENT:
+      return DownloadDatabase::kDangerTypeDangerousContent;
+    case content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT:
+      return DownloadDatabase::kDangerTypeMaybeDangerousContent;
+    case content::DOWNLOAD_DANGER_TYPE_UNCOMMON_CONTENT:
+      return DownloadDatabase::kDangerTypeUncommonContent;
+    case content::DOWNLOAD_DANGER_TYPE_USER_VALIDATED:
+      return DownloadDatabase::kDangerTypeUserValidated;
+    case content::DOWNLOAD_DANGER_TYPE_DANGEROUS_HOST:
+      return DownloadDatabase::kDangerTypeDangerousHost;
+    case content::DOWNLOAD_DANGER_TYPE_MAX:
+      NOTREACHED();
+      return DownloadDatabase::kDangerTypeInvalid;
+  }
+  NOTREACHED();
+  return DownloadDatabase::kDangerTypeInvalid;
+}
+
+content::DownloadDangerType DownloadDatabase::IntToDangerType(int danger_type) {
+  switch (danger_type) {
+    case DownloadDatabase::kDangerTypeNotDangerous:
+      return content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS;
+    case DownloadDatabase::kDangerTypeDangerousFile:
+      return content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE;
+    case DownloadDatabase::kDangerTypeDangerousUrl:
+      return content::DOWNLOAD_DANGER_TYPE_DANGEROUS_URL;
+    case DownloadDatabase::kDangerTypeDangerousContent:
+      return content::DOWNLOAD_DANGER_TYPE_DANGEROUS_CONTENT;
+    case DownloadDatabase::kDangerTypeMaybeDangerousContent:
+      return content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT;
+    case DownloadDatabase::kDangerTypeUncommonContent:
+      return content::DOWNLOAD_DANGER_TYPE_UNCOMMON_CONTENT;
+    case DownloadDatabase::kDangerTypeUserValidated:
+      return content::DOWNLOAD_DANGER_TYPE_USER_VALIDATED;
+    case DownloadDatabase::kDangerTypeDangerousHost:
+      return content::DOWNLOAD_DANGER_TYPE_DANGEROUS_HOST;
+    default:
+      return content::DOWNLOAD_DANGER_TYPE_MAX;
+  }
+}
+
 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) {
+  EnsureInProgressEntriesCleanedUp();
+
   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 98 matching lines @@
     } else {
       // Copy the contents of the stored info.
       results->push_back(*row);
     }
     delete row;
     it->second = NULL;
   }
 }
 
 bool DownloadDatabase::UpdateDownload(const DownloadRow& data) {
+  EnsureInProgressEntriesCleanedUp();
+
   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::EnsureInProgressEntriesCleanedUp() {
+  if (in_progress_entry_cleanup_completed_)
+    return;
+
   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) {
+  EnsureInProgressEntriesCleanedUp();
+
   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_);
   }
 
   if (info.url_chain.empty())
     return kUninitializedHandle;
@@ skipping 74 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) {
+  EnsureInProgressEntriesCleanedUp();
+
   sql::Statement downloads_statement(GetDB().GetCachedStatement(SQL_FROM_HERE,
       "DELETE FROM downloads WHERE id=?"));
   downloads_statement.BindInt64(0, handle);
   if (!downloads_statement.Run()) {
     UMA_HISTOGRAM_ENUMERATION("Download.DatabaseMainDeleteError",
                               GetDB().GetErrorCode() & 0xff, 50);
     return;
   }
   RemoveDownloadURLs(handle);
 }
 
 void DownloadDatabase::RemoveDownloadURLs(int64 handle) {
   sql::Statement urlchain_statement(GetDB().GetCachedStatement(SQL_FROM_HERE,
       "DELETE FROM downloads_url_chains WHERE id=?"));
   urlchain_statement.BindInt64(0, handle);
   if (!urlchain_statement.Run()) {
     UMA_HISTOGRAM_ENUMERATION("Download.DatabaseURLChainDeleteError",
                               GetDB().GetErrorCode() & 0xff, 50);
   }
 }
 
 int DownloadDatabase::CountDownloads() {
+  EnsureInProgressEntriesCleanedUp();
+
   sql::Statement statement(GetDB().GetCachedStatement(SQL_FROM_HERE,
       "SELECT count(*) from downloads"));
   statement.Step();
   return statement.ColumnInt(0);
 }
 
 }  // namespace history