Add mime type information to the download database

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 20 matching lines @@
 
 // Reason for dropping a particular record.
 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
 };
 
-static const char kSchema[] =
-    "CREATE TABLE downloads ("
-    "id INTEGER PRIMARY KEY,"             // Primary key.
-    "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,"  // content::DownloadInterruptReason
-    "end_time INTEGER NOT NULL,"          // When the download completed.
-    "opened INTEGER NOT NULL,"            // 1 if it has ever been opened else 0
-    "referrer VARCHAR NOT NULL,"          // HTTP Referrer
-    "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
-
-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) )";
-
 #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 126 matching lines @@
 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());
 }
 
+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(
       "UPDATE downloads SET state=? WHERE state=?"));
   statement.BindInt(0, kStateInterrupted);
   statement.BindInt(1, kStateBug140687);
   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("ALTER TABLE downloads RENAME TO downloads_tmp"))
     return false;
 
+  const char kReasonPathDangerSchema[] =
+      "CREATE TABLE downloads ("
+      "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)";
+
+  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(kSchema))
+  if (!GetDB().Execute(kReasonPathDangerSchema))
     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(
       "INSERT INTO downloads "
       "( id, current_path, target_path, start_time, received_bytes, "
-      "  total_bytes, state, danger_type, interrupt_reason, end_time, opened, "
-      "  referrer, by_ext_id, by_ext_name, etag, last_modified ) "
+      "  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, \"\", \"\", \"\", \"\", \"\" "
+      "       opened "
       "FROM downloads_tmp"));
   statement_populate.BindInt(0, content::DOWNLOAD_INTERRUPT_REASON_NONE);
   statement_populate.BindInt(1, kDangerTypeNotDangerous);
   if (!statement_populate.Run())
     return false;
 
   // Create new chain table and populate it.
-  if (!GetDB().Execute(kUrlChainSchema))
+  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::InitDownloadTable() {
+  const char kSchema[] =
+      "CREATE TABLE downloads ("
+      "id INTEGER PRIMARY KEY,"             // Primary key.
+      "current_path LONGVARCHAR NOT NULL,"  // Current disk location
+      "target_path LONGVARCHAR NOT NULL,"   // Final disk location
+      "mime_type VARCHAR(255) NOT NULL,"    // Mime type.

[sky, 2014/06/05 16:02:03]

Add new types to the end so it's easier to see what's changed over time. (and
easier to compare with block on 208).

[Fredrik Öhrn, 2014/06/05 16:28:25]

Moved in patch #2.

+      "original_mime_type VARCHAR(255) NOT NULL,"  // Original mime type.
+      "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,"  // content::DownloadInterruptReason
+      "end_time INTEGER NOT NULL,"          // When the download completed.
+      "opened INTEGER NOT NULL,"            // 1 if it has ever been opened
+                                            // else 0
+      "referrer VARCHAR NOT NULL,"          // HTTP Referrer
+      "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
+
+  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) )";
+
   if (GetDB().DoesTableExist("downloads")) {
     return EnsureColumnExists("end_time", "INTEGER NOT NULL DEFAULT 0") &&
            EnsureColumnExists("opened", "INTEGER NOT NULL DEFAULT 0");
   } else {
     // If the "downloads" table doesn't exist, the downloads_url_chain
     // table better not.
     return (!GetDB().DoesTableExist("downloads_url_chain") &&
             GetDB().Execute(kSchema) && GetDB().Execute(kUrlChainSchema));
   }
 }
@@ skipping 22 matching lines @@
 void DownloadDatabase::QueryDownloads(
     std::vector<DownloadRow>* results) {
   EnsureInProgressEntriesCleanedUp();
 
   results->clear();
   std::set<uint32> ids;
 
   std::map<uint32, DownloadRow*> info_map;
 
   sql::Statement statement_main(GetDB().GetCachedStatement(SQL_FROM_HERE,
-      "SELECT id, current_path, target_path, start_time, received_bytes, "
+      "SELECT id, current_path, target_path, "
+      "mime_type, original_mime_type, "
+      "start_time, received_bytes, "
       "total_bytes, state, danger_type, interrupt_reason, end_time, opened, "
       "referrer, by_ext_id, by_ext_name, etag, last_modified "
       "FROM downloads ORDER BY start_time"));
 
   while (statement_main.Step()) {
     scoped_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 signed_id = statement_main.ColumnInt64(column++);
     info->id = static_cast<uint32>(signed_id);
     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 = IntToState(state);
     if (info->state == DownloadItem::MAX_DOWNLOAD_STATE)
       UMA_HISTOGRAM_COUNTS("Download.DatabaseInvalidState", state);
     info->danger_type = IntToDangerType(statement_main.ColumnInt(column++));
     info->interrupt_reason = static_cast<content::DownloadInterruptReason>(
@@ skipping 100 matching lines @@
     return false;
   }
   int danger_type = DangerTypeToInt(data.danger_type);
   if (danger_type == kDangerTypeInvalid) {
     NOTREACHED();
     return false;
   }
 
   sql::Statement statement(GetDB().GetCachedStatement(SQL_FROM_HERE,
       "UPDATE downloads "
-      "SET current_path=?, target_path=?, received_bytes=?, state=?, "
+      "SET current_path=?, target_path=?, "
+      "mime_type=?, original_mime_type=?, "
+      "received_bytes=?, state=?, "
       "danger_type=?, interrupt_reason=?, end_time=?, total_bytes=?, "
       "opened=?, by_ext_id=?, by_ext_name=?, etag=?, last_modified=? "
       "WHERE id=?"));
   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++, state);
   statement.BindInt(column++, danger_type);
   statement.BindInt(column++, static_cast<int>(data.interrupt_reason));
   statement.BindInt64(column++, data.end_time.ToInternalValue());
   statement.BindInt64(column++, data.total_bytes);
   statement.BindInt(column++, (data.opened ? 1 : 0));
   statement.BindString(column++, data.by_ext_id);
   statement.BindString(column++, data.by_ext_name);
   statement.BindString(column++, data.etag);
@@ skipping 29 matching lines @@
     return false;
 
   int danger_type = DangerTypeToInt(info.danger_type);
   if (danger_type == kDangerTypeInvalid)
     return false;
 
   {
     sql::Statement statement_insert(GetDB().GetCachedStatement(
         SQL_FROM_HERE,
         "INSERT INTO downloads "
-        "(id, current_path, target_path, start_time, "
+        "(id, current_path, target_path, "
+        "mime_type, original_mime_type, "
+        "start_time, "
         " received_bytes, total_bytes, state, danger_type, interrupt_reason, "
         " end_time, opened, referrer, by_ext_id, by_ext_name, etag, "
         " last_modified) "
-        "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"));
+        "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"));
 
     int column = 0;
     statement_insert.BindInt(column++, info.id);
     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++, state);
     statement_insert.BindInt(column++, danger_type);
     statement_insert.BindInt(column++, info.interrupt_reason);
     statement_insert.BindInt64(column++, info.end_time.ToInternalValue());
     statement_insert.BindInt(column++, info.opened ? 1 : 0);
     statement_insert.BindString(column++, info.referrer_url.spec());
     statement_insert.BindString(column++, info.by_ext_id);
@@ skipping 75 matching lines @@
 size_t DownloadDatabase::CountDownloads() {
   EnsureInProgressEntriesCleanedUp();
 
   sql::Statement statement(GetDB().GetCachedStatement(SQL_FROM_HERE,
       "SELECT count(*) from downloads"));
   statement.Step();
   return statement.ColumnInt(0);
 }
 
 }  // namespace history