Add mime type information to the download database

chrome/browser/history/history_unittest.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.
 
 // History unit tests come in two flavors:
 //
 // 1. The more complicated style is that the unit test creates a full history
 //    service. This spawns a background thread for the history backend, and
 //    all communication is asynchronous. This is useful for testing more
 //    complicated things or end-to-end behavior.
@@ skipping 166 matching lines @@
   bool AddDownload(uint32 id,
                    DownloadItem::DownloadState state,
                    const Time& time) {
     std::vector<GURL> url_chain;
     url_chain.push_back(GURL("foo-url"));
 
     DownloadRow download(base::FilePath(FILE_PATH_LITERAL("current-path")),
                          base::FilePath(FILE_PATH_LITERAL("target-path")),
                          url_chain,
                          GURL("http://referrer.com/"),
+                         "application/vnd.oasis.opendocument.text",
+                         "application/octet-stream",
                          time,
                          time,
                          std::string(),
                          std::string(),
                          0,
                          512,
                          state,
                          content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
                          content::DOWNLOAD_INTERRUPT_REASON_NONE,
                          id,
@@ skipping 62 matching lines @@
   EXPECT_EQ(0, downloads[0].received_bytes);
   EXPECT_EQ(512, downloads[0].total_bytes);
   EXPECT_EQ(DownloadItem::COMPLETE, downloads[0].state);
   EXPECT_EQ(content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
             downloads[0].danger_type);
   EXPECT_EQ(content::DOWNLOAD_INTERRUPT_REASON_NONE,
             downloads[0].interrupt_reason);
   EXPECT_FALSE(downloads[0].opened);
   EXPECT_EQ("by_ext_id", downloads[0].by_ext_id);
   EXPECT_EQ("by_ext_name", downloads[0].by_ext_name);
+  EXPECT_EQ("application/vnd.oasis.opendocument.text", downloads[0].mime_type);
+  EXPECT_EQ("application/octet-stream", downloads[0].original_mime_type);
 
   db_->QueryDownloads(&downloads);
   EXPECT_EQ(1U, downloads.size());
   db_->RemoveDownload(id);
   db_->QueryDownloads(&downloads);
   EXPECT_EQ(0U, downloads.size());
 }
 
 TEST_F(HistoryBackendDBTest, MigrateDownloadsState) {
   // Create the db we want.
@@ skipping 359 matching lines @@
 
   CreateBackendAndDatabase();
   DeleteBackend();
 
   // We do not retain expired history entries in an archived database as of M37.
   // Verify that any legacy archived database is deleted on start-up.
   ASSERT_FALSE(base::PathExists(
       history_dir_.Append(chrome::kArchivedHistoryFilename)));
 }
 
+TEST_F(HistoryBackendDBTest, MigrateDownloadMimeType) {
+  Time now(base::Time::Now());
+  ASSERT_NO_FATAL_FAILURE(CreateDBVersion(28));
+  {
+    sql::Connection db;
+    ASSERT_TRUE(db.Open(history_dir_.Append(chrome::kHistoryFilename)));
+    {
+      sql::Statement s(db.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) VALUES "
+          "(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"));
+      s.BindInt64(0, 1);
+      s.BindString(1, "current_path");
+      s.BindString(2, "target_path");
+      s.BindInt64(3, now.ToTimeT());
+      s.BindInt64(4, 100);
+      s.BindInt64(5, 100);
+      s.BindInt(6, 1);
+      s.BindInt(7, 0);
+      s.BindInt(8, 0);
+      s.BindInt64(9, now.ToTimeT());
+      s.BindInt(10, 1);
+      s.BindString(11, "referrer");
+      s.BindString(12, "by extension ID");
+      s.BindString(13, "by extension name");
+      s.BindString(14, "etag");
+      s.BindInt64(15, now.ToTimeT());
+      ASSERT_TRUE(s.Run());
+    }
+    {
+      sql::Statement s(db.GetUniqueStatement(
+          "INSERT INTO downloads_url_chains (id, chain_index, url) VALUES "
+          "(?, ?, ?)"));
+      s.BindInt64(0, 4);
+      s.BindInt64(1, 0);
+      s.BindString(2, "url");
+      ASSERT_TRUE(s.Run());
+    }
+  }
+  // Re-open the db using the HistoryDatabase, which should migrate to the
+  // current version, creating themime_type abd original_mime_type columns.
+  CreateBackendAndDatabase();
+  DeleteBackend();
+  {
+    // Re-open the db for manual manipulation.
+    sql::Connection db;
+    ASSERT_TRUE(db.Open(history_dir_.Append(chrome::kHistoryFilename)));
+    // The version should have been updated.
+    int cur_version = HistoryDatabase::GetCurrentVersion();
+    ASSERT_LE(29, cur_version);
+    {
+      sql::Statement s(db.GetUniqueStatement(
+          "SELECT value FROM meta WHERE key = 'version'"));
+      EXPECT_TRUE(s.Step());
+      EXPECT_EQ(cur_version, s.ColumnInt(0));
+    }
+    {
+      sql::Statement s(db.GetUniqueStatement(
+          "SELECT mime_type, original_mime_type from downloads"));
+      EXPECT_TRUE(s.Step());
+      EXPECT_EQ(std::string(), s.ColumnString(0));
+      EXPECT_EQ(std::string(), s.ColumnString(1));
+    }
+  }
+}
+
 TEST_F(HistoryBackendDBTest, ConfirmDownloadRowCreateAndDelete) {
   // Create the DB.
   CreateBackendAndDatabase();
 
   base::Time now(base::Time::Now());
 
   // Add some downloads.
   uint32 id1 = 1, id2 = 2, id3 = 3;
   AddDownload(id1, DownloadItem::COMPLETE, now);
   AddDownload(id2, DownloadItem::COMPLETE, now + base::TimeDelta::FromDays(2));
@@ skipping 36 matching lines @@
 }
 
 TEST_F(HistoryBackendDBTest, DownloadNukeRecordsMissingURLs) {
   CreateBackendAndDatabase();
   base::Time now(base::Time::Now());
   std::vector<GURL> url_chain;
   DownloadRow download(base::FilePath(FILE_PATH_LITERAL("foo-path")),
                        base::FilePath(FILE_PATH_LITERAL("foo-path")),
                        url_chain,
                        GURL(std::string()),
+                       "application/octet-stream",
+                       "application/octet-stream",
                        now,
                        now,
                        std::string(),
                        std::string(),
                        0,
                        512,
                        DownloadItem::COMPLETE,
                        content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
                        content::DOWNLOAD_INTERRUPT_REASON_NONE,
                        1,
@@ skipping 1146 matching lines @@
   std::vector<PageUsageData*> results;
   db_->QuerySegmentUsage(segment_time, 10, &results);
   ASSERT_EQ(1u, results.size());
   EXPECT_EQ(url, results[0]->GetURL());
   EXPECT_EQ(segment_id, results[0]->GetID());
   EXPECT_EQ(title, results[0]->GetTitle());
   STLDeleteElements(&results);
 }
 
 }  // namespace history