[Downloads/History] Add tab-url and tab-referrer-url to DownloadRow

components/history/core/browser/history_backend_db_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 56 matching lines @@
                           base::Time()));
   db_->QueryDownloads(&downloads);
   EXPECT_EQ(1U, downloads.size());
 
   EXPECT_EQ(base::FilePath(FILE_PATH_LITERAL("current-path")),
             downloads[0].current_path);
   EXPECT_EQ(base::FilePath(FILE_PATH_LITERAL("target-path")),
             downloads[0].target_path);
   EXPECT_EQ(1UL, downloads[0].url_chain.size());
   EXPECT_EQ(GURL("foo-url"), downloads[0].url_chain[0]);
-  EXPECT_EQ(std::string("http://referrer.com/"),
-            std::string(downloads[0].referrer_url.spec()));
+  EXPECT_EQ(std::string("http://referrer.example.com/"),
+            downloads[0].referrer_url.spec());
+  EXPECT_EQ(std::string("http://tab-url.example.com/"),
+            downloads[0].tab_url.spec());
+  EXPECT_EQ(std::string("http://tab-referrer-url.example.com/"),
+            downloads[0].tab_referrer_url.spec());
   EXPECT_EQ(now, downloads[0].start_time);
   EXPECT_EQ(now, downloads[0].end_time);
   EXPECT_EQ(0, downloads[0].received_bytes);
   EXPECT_EQ(512, downloads[0].total_bytes);
   EXPECT_EQ(DownloadState::COMPLETE, downloads[0].state);
   EXPECT_EQ(DownloadDangerType::NOT_DANGEROUS, downloads[0].danger_type);
   EXPECT_EQ(kTestDownloadInterruptReasonNone, 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);
@@ skipping 515 matching lines @@
         EXPECT_TRUE(IsValidRFC4122Ver4GUID(guid));
         EXPECT_EQ(guid, base::ToUpperASCII(guid));
         guids.insert(guid);
       }
       EXPECT_TRUE(s.Succeeded());
       EXPECT_EQ(kDownloadCount, guids.size());
     }
   }
 }
 
+TEST_F(HistoryBackendDBTest, MigrateTabUrls) {
+  ASSERT_NO_FATAL_FAILURE(CreateDBVersion(30));
+  {
+    sql::Connection db;
+    ASSERT_TRUE(db.Open(history_dir_.Append(kHistoryFilename)));
+    {
+      sql::Statement s(db.GetUniqueStatement(
+          "INSERT INTO downloads ("
+          "    id, guid, current_path, target_path, start_time, received_bytes,"
+          "    total_bytes, state, danger_type, interrupt_reason, hash,"
+          "    end_time, opened, referrer, http_method, by_ext_id, by_ext_name,"
+          "    etag, last_modified, mime_type, original_mime_type)"
+          "VALUES("
+          "    1, '435A5C7A-F6B7-4DF2-8696-22E4FCBA3EB2', 'foo.txt', 'foo.txt',"
+          "    13104873187307670, 11, 11, 1, 0, 0, X'', 13104873187521021, 0,"
+          "    'http://example.com/dl/', '', '', '', '', '', 'text/plain',"
+          "    'text/plain')"));
+      ASSERT_TRUE(s.Run());
+    }
+    {
+      sql::Statement s(db.GetUniqueStatement(
+          "INSERT INTO downloads_url_chains (id, chain_index, url) VALUES "
+          "(4, 0, 'url')"));
+      ASSERT_TRUE(s.Run());
+    }
+  }
+
+  // Re-open the db using the HistoryDatabase, which should migrate to the
+  // current version, creating the tab_url and tab_referrer_url columns.
+  CreateBackendAndDatabase();
+  DeleteBackend();
+  {
+    // Re-open the db for manual manipulation.
+    sql::Connection db;
+    ASSERT_TRUE(db.Open(history_dir_.Append(kHistoryFilename)));
+    // The version should have been updated.
+    int cur_version = HistoryDatabase::GetCurrentVersion();
+    ASSERT_LE(31, 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 tab_url, tab_referrer_url from downloads"));
+      EXPECT_TRUE(s.Step());
+      EXPECT_EQ(std::string(), s.ColumnString(0));
+      EXPECT_EQ(std::string(), s.ColumnString(1));
+    }
+  }
+}
+
 TEST_F(HistoryBackendDBTest, DownloadCreateAndQuery) {
   CreateBackendAndDatabase();
 
   ASSERT_EQ(0u, db_->CountDownloads());
 
   std::vector<GURL> url_chain;
   url_chain.push_back(GURL("http://example.com/a"));
   url_chain.push_back(GURL("http://example.com/b"));
   url_chain.push_back(GURL("http://example.com/c"));
 
   base::Time start_time(base::Time::Now());
   base::Time end_time(start_time + base::TimeDelta::FromHours(1));
 
-  DownloadRow download_A(base::FilePath(FILE_PATH_LITERAL("/path/1")),
-                         base::FilePath(FILE_PATH_LITERAL("/path/2")),
-                         url_chain,
-                         GURL("http://example.com/referrer"),
-                         "GET",
-                         "mime/type",
-                         "original/mime-type",
-                         start_time,
-                         end_time,
-                         "etag1",
-                         "last_modified_1",
-                         100,
-                         1000,
-                         DownloadState::INTERRUPTED,
-                         DownloadDangerType::NOT_DANGEROUS,
-                         kTestDownloadInterruptReasonCrash,
-                         "hash-value1",
-                         1,
-                         "FE672168-26EF-4275-A149-FEC25F6A75F9",
-                         false,
-                         "extension-id",
-                         "extension-name");
+  DownloadRow download_A(
+      base::FilePath(FILE_PATH_LITERAL("/path/1")),
+      base::FilePath(FILE_PATH_LITERAL("/path/2")), url_chain,
+      GURL("http://example.com/referrer"), GURL("http://example.com/tab-url"),
+      GURL("http://example.com/tab-referrer"), "GET", "mime/type",
+      "original/mime-type", start_time, end_time, "etag1", "last_modified_1",
+      100, 1000, DownloadState::INTERRUPTED, DownloadDangerType::NOT_DANGEROUS,
+      kTestDownloadInterruptReasonCrash, "hash-value1", 1,
+      "FE672168-26EF-4275-A149-FEC25F6A75F9", false, "extension-id",
+      "extension-name");
   ASSERT_TRUE(db_->CreateDownload(download_A));
 
   url_chain.push_back(GURL("http://example.com/d"));
 
-  DownloadRow download_B(base::FilePath(FILE_PATH_LITERAL("/path/3")),
-                         base::FilePath(FILE_PATH_LITERAL("/path/4")),
-                         url_chain,
-                         GURL("http://example.com/referrer2"),
-                         "POST",
-                         "mime/type2",
-                         "original/mime-type2",
-                         start_time,
-                         end_time,
-                         "etag2",
-                         "last_modified_2",
-                         1001,
-                         1001,
-                         DownloadState::COMPLETE,
-                         DownloadDangerType::DANGEROUS_FILE,
-                         kTestDownloadInterruptReasonNone,
-                         std::string(),
-                         2,
-                         "b70f3869-7d75-4878-acb4-4caf7026d12b",
-                         false,
-                         "extension-id",
-                         "extension-name");
+  base::Time start_time2(start_time + base::TimeDelta::FromHours(10));
+  base::Time end_time2(end_time + base::TimeDelta::FromHours(10));
+
+  DownloadRow download_B(
+      base::FilePath(FILE_PATH_LITERAL("/path/3")),
+      base::FilePath(FILE_PATH_LITERAL("/path/4")), url_chain,
+      GURL("http://example.com/referrer2"), GURL("http://example.com/tab-url2"),
+      GURL("http://example.com/tab-referrer2"), "POST", "mime/type2",
+      "original/mime-type2", start_time2, end_time2, "etag2", "last_modified_2",
+      1001, 1001, DownloadState::COMPLETE, DownloadDangerType::DANGEROUS_FILE,
+      kTestDownloadInterruptReasonNone, std::string(), 2,
+      "b70f3869-7d75-4878-acb4-4caf7026d12b", false, "extension-id",
+      "extension-name");
   ASSERT_TRUE(db_->CreateDownload(download_B));
 
   EXPECT_EQ(2u, db_->CountDownloads());
 
   std::vector<DownloadRow> results;
   db_->QueryDownloads(&results);
 
   ASSERT_EQ(2u, results.size());
 
   const DownloadRow& retrieved_download_A =
       results[0].id == 1 ? results[0] : results[1];
   const DownloadRow& retrieved_download_B =
       results[0].id == 1 ? results[1] : results[0];
 
   EXPECT_EQ(download_A, retrieved_download_A);
   EXPECT_EQ(download_B, retrieved_download_B);
 }
 
 TEST_F(HistoryBackendDBTest, DownloadCreateAndUpdate_VolatileFields) {
   CreateBackendAndDatabase();
 
   std::vector<GURL> url_chain;
   url_chain.push_back(GURL("http://example.com/a"));
   url_chain.push_back(GURL("http://example.com/b"));
   url_chain.push_back(GURL("http://example.com/c"));
 
   base::Time start_time(base::Time::Now());
   base::Time end_time(start_time + base::TimeDelta::FromHours(1));
 
-  DownloadRow download(base::FilePath(FILE_PATH_LITERAL("/path/1")),
-                       base::FilePath(FILE_PATH_LITERAL("/path/2")),
-                       url_chain,
-                       GURL("http://example.com/referrer"),
-                       "GET",
-                       "mime/type",
-                       "original/mime-type",
-                       start_time,
-                       end_time,
-                       "etag1",
-                       "last_modified_1",
-                       100,
-                       1000,
-                       DownloadState::INTERRUPTED,
-                       DownloadDangerType::NOT_DANGEROUS,
-                       3,
-                       "some-hash-value",
-                       1,
-                       "FE672168-26EF-4275-A149-FEC25F6A75F9",
-                       false,
-                       "extension-id",
-                       "extension-name");
+  DownloadRow download(
+      base::FilePath(FILE_PATH_LITERAL("/path/1")),
+      base::FilePath(FILE_PATH_LITERAL("/path/2")), url_chain,
+      GURL("http://example.com/referrer"), GURL("http://example.com/tab-url"),
+      GURL("http://example.com/tab-referrer"), "GET", "mime/type",
+      "original/mime-type", start_time, end_time, "etag1", "last_modified_1",
+      100, 1000, DownloadState::INTERRUPTED, DownloadDangerType::NOT_DANGEROUS,
+      3, "some-hash-value", 1, "FE672168-26EF-4275-A149-FEC25F6A75F9", false,
+      "extension-id", "extension-name");
   db_->CreateDownload(download);
 
   download.current_path =
       base::FilePath(FILE_PATH_LITERAL("/new/current_path"));
   download.target_path = base::FilePath(FILE_PATH_LITERAL("/new/target_path"));
   download.mime_type = "new/mime/type";
   download.original_mime_type = "new/original/mime/type";
   download.received_bytes += 1000;
   download.state = DownloadState::CANCELLED;
   download.danger_type = DownloadDangerType::USER_VALIDATED;
@@ skipping 69 matching lines @@
         "Select Count(*) from downloads_url_chains"));
     EXPECT_TRUE(statement1.Step());
     EXPECT_EQ(1, statement1.ColumnInt(0));
   }
 }
 
 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()),
-                       std::string(),
-                       "application/octet-stream",
-                       "application/octet-stream",
-                       now,
-                       now,
-                       std::string(),
-                       std::string(),
-                       0,
-                       512,
-                       DownloadState::COMPLETE,
-                       DownloadDangerType::NOT_DANGEROUS,
-                       kTestDownloadInterruptReasonNone,
-                       std::string(),
-                       1,
-                       "05AF6C8E-E4E0-45D7-B5CE-BC99F7019918",
-                       0,
-                       "by_ext_id",
-                       "by_ext_name");
+  DownloadRow download(
+      base::FilePath(FILE_PATH_LITERAL("foo-path")),
+      base::FilePath(FILE_PATH_LITERAL("foo-path")), url_chain,
+      GURL(std::string()), GURL(std::string()), GURL(std::string()),
+      std::string(), "application/octet-stream", "application/octet-stream",
+      now, now, std::string(), std::string(), 0, 512, DownloadState::COMPLETE,
+      DownloadDangerType::NOT_DANGEROUS, kTestDownloadInterruptReasonNone,
+      std::string(), 1, "05AF6C8E-E4E0-45D7-B5CE-BC99F7019918", 0, "by_ext_id",
+      "by_ext_name");
 
   // Creating records without any urls should fail.
   EXPECT_FALSE(db_->CreateDownload(download));
 
   download.url_chain.push_back(GURL("foo-url"));
   EXPECT_TRUE(db_->CreateDownload(download));
 
   // Pretend that the URLs were dropped.
   DeleteBackend();
   {
@@ skipping 187 matching lines @@
       // Current browser version must be already higher than 28.
       ASSERT_LT(28, HistoryDatabase::GetCurrentVersion());
       // Expect that version in DB remains the same.
       EXPECT_EQ(28, meta.GetVersionNumber());
     }
   }
 }
 
 }  // namespace
 }  // namespace history