Add the referrer url to the downloads table in the History 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 19 matching lines @@
 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[] =
-  "CREATE TABLE downloads ("
-  "id INTEGER PRIMARY KEY,"           // Primary key.
-  "current_path LONGVARCHAR NOT NULL,"  // Current disk location of the download
-  "target_path LONGVARCHAR NOT NULL,"  // Final disk location of the download
-  "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, "    // Not dangerous, danger type, validated.
-  "interrupt_reason INTEGER NOT NULL,"  // Reason the download was interrupted.
-  "end_time INTEGER NOT NULL,"        // When the download completed.
-  "opened INTEGER NOT NULL)";         // 1 if it has ever been opened else 0
+    "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, "  // Not dangerous, danger type, validated.
+    "interrupt_reason INTEGER NOT NULL,"
+    "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
 
 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) )";
 
@@ skipping 165 matching lines @@
   if (!GetDB().Execute(kSchema))
     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 ) "
+    "  state, danger_type, interrupt_reason, end_time, opened, referrer ) "
     "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))
     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::InitDownloadTable() {
   GetMetaTable().GetValue(kNextDownloadId, &next_id_);
   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 10 matching lines @@
 
   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 "
-      "FROM downloads "
-      "ORDER BY start_time"));
+      "total_bytes, state, danger_type, interrupt_reason, end_time, opened, "
+      "referrer "
+      "FROM downloads ORDER BY start_time"));
 
   while (statement_main.Step()) {
     scoped_ptr<DownloadRow> info(new DownloadRow());
     int column = 0;
 
     int db_handle = statement_main.ColumnInt64(column++);
     info->db_handle = db_handle;
     info->current_path = ColumnFilePath(statement_main, column++);
     info->target_path = ColumnFilePath(statement_main, 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>(
         statement_main.ColumnInt(column++));
     info->end_time = base::Time::FromInternalValue(
         statement_main.ColumnInt64(column++));
     info->opened = statement_main.ColumnInt(column++) != 0;
+    info->referrer_url = GURL(statement_main.ColumnString(column++));
     if (info->db_handle >= next_db_handle_)
       next_db_handle_ = info->db_handle + 1;
     if (!db_handles.insert(info->db_handle).second) {
       // info->db_handle was already in db_handles. The database is corrupt.
       base::debug::Alias(&info->db_handle);
       DCHECK(false);
     }
 
     // If the record is corrupted, note that and drop it.
     if (info->state == DownloadItem::MAX_DOWNLOAD_STATE ||
@@ skipping 141 matching lines @@
     return kUninitializedHandle;
 
   int db_handle = next_db_handle_++;
 
   {
     sql::Statement statement_insert(GetDB().GetCachedStatement(
         SQL_FROM_HERE,
         "INSERT INTO downloads "
         "(id, current_path, target_path, start_time, "
         " received_bytes, total_bytes, state, danger_type, interrupt_reason, "
-        " end_time, opened) "
-        "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"));
+        " end_time, opened, referrer) "
+        "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"));
 
     int column = 0;
     statement_insert.BindInt64(column++, db_handle);
     BindFilePath(statement_insert, info.current_path, column++);
     BindFilePath(statement_insert, info.target_path, column++);
     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());
     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 kUninitializedHandle;
     }
@@ skipping 65 matching lines @@
 int DownloadDatabase::CountDownloads() {
   EnsureInProgressEntriesCleanedUp();
 
   sql::Statement statement(GetDB().GetCachedStatement(SQL_FROM_HERE,
       "SELECT count(*) from downloads"));
   statement.Step();
   return statement.ColumnInt(0);
 }
 
 }  // namespace history