Downloads: Added transient flag to download item and download database

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 747 matching lines @@
           "SELECT COUNT(*) from downloads_slices"));
       EXPECT_TRUE(s1.Step());
       EXPECT_EQ(0, s1.ColumnInt(0));
       const char kInsertStatement[] = "INSERT INTO downloads_slices "
           "(download_id, offset, received_bytes) VALUES (1, 0, 100)";
       ASSERT_TRUE(db.Execute(kInsertStatement));
     }
   }
 }
 
+// Tests that last access time and visible is automatically added when migrating
+// to version 35.
+TEST_F(HistoryBackendDBTest, MigrateDownloadsLastAccessTimeAndVisible) {
+  ASSERT_NO_FATAL_FAILURE(CreateDBVersion(32));
+  {
+    sql::Connection db;
+    ASSERT_TRUE(db.Open(history_dir_.Append(kHistoryFilename)));
+  }
+
+  // Re-open the db using the HistoryDatabase, which should migrate to the
+  // current version.
+  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(34, cur_version);

[David Trainor- moved to gerrit, 2017/03/06 18:28:39]

Do we want to validate that it's going to 35?

[shaktisahu, 2017/03/08 06:51:30]

Didn't get it. The new version after migration should be 35 or above. I am
checking 2 version migrations here.
I will probably change CreateDBVersion(32) to start from 33 instead, but
actually any number works here.

+    {
+      sql::Statement s(db.GetUniqueStatement(
+          "SELECT value FROM meta WHERE key = 'version'"));
+      EXPECT_TRUE(s.Step());
+      EXPECT_EQ(cur_version, s.ColumnInt(0));
+    }
+    {
+      // The downloads table should have last_access_time and visible
+      // initialized to zero and true respectively.
+      sql::Statement s(db.GetUniqueStatement(
+          "SELECT last_access_time, visible from downloads"));
+      EXPECT_TRUE(s.Step());
+      EXPECT_EQ(base::Time(), base::Time::FromInternalValue(s.ColumnInt64(0)));
+      EXPECT_EQ(true, s.ColumnInt(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));
   base::Time last_access_time;
 
   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"),
       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, last_access_time,
+      "FE672168-26EF-4275-A149-FEC25F6A75F9", false, last_access_time, true,
       "extension-id", "extension-name", std::vector<DownloadSliceInfo>());
   ASSERT_TRUE(db_->CreateDownload(download_A));
 
   url_chain.push_back(GURL("http://example.com/d"));
 
   base::Time start_time2(start_time + base::TimeDelta::FromHours(10));
   base::Time end_time2(end_time + base::TimeDelta::FromHours(10));
   base::Time last_access_time2(start_time2 + base::TimeDelta::FromHours(5));
 
   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://2.example.com"),
       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, last_access_time2,
+      "b70f3869-7d75-4878-acb4-4caf7026d12b", false, last_access_time2, true,
       "extension-id", "extension-name", std::vector<DownloadSliceInfo>());
   ASSERT_TRUE(db_->CreateDownload(download_B));
 
   EXPECT_EQ(2u, db_->CountDownloads());
 
   std::vector<DownloadRow> results;
   db_->QueryDownloads(&results);
 
   ASSERT_EQ(2u, results.size());
 
@@ skipping 20 matching lines @@
 
   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"),
       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,
-      last_access_time, "extension-id", "extension-name",
+      last_access_time, false, "extension-id", "extension-name",
       std::vector<DownloadSliceInfo>());
   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;
   download.interrupt_reason = 4;
   download.end_time += base::TimeDelta::FromHours(1);
   download.total_bytes += 1;
   download.hash = "some-other-hash";
   download.opened = !download.opened;
+  download.visible = !download.visible;
   download.by_ext_id = "by-new-extension-id";
   download.by_ext_name = "by-new-extension-name";
   download.etag = "new-etag";
   download.last_modified = "new-last-modified";
 
   ASSERT_TRUE(db_->UpdateDownload(download));
 
   std::vector<DownloadRow> results;
   db_->QueryDownloads(&results);
   ASSERT_EQ(1u, results.size());
@@ skipping 79 matching lines @@
   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()), 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, now, "by_ext_id",
+      "05AF6C8E-E4E0-45D7-B5CE-BC99F7019918", 0, now, false, "by_ext_id",
       "by_ext_name", std::vector<DownloadSliceInfo>());
 
   // 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 110 matching lines @@
   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"),
       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",
       received, 1500, DownloadState::INTERRUPTED,
       DownloadDangerType::NOT_DANGEROUS, kTestDownloadInterruptReasonCrash,
       "hash-value1", id, "FE672168-26EF-4275-A149-FEC25F6A75F9", false,
-      last_access_time, "extension-id", "extension-name", slice_info);
+      last_access_time, false, "extension-id", "extension-name", slice_info);
   ASSERT_TRUE(db_->CreateDownload(download));
   std::vector<DownloadRow> results;
   db_->QueryDownloads(&results);
   ASSERT_EQ(1u, results.size());
   EXPECT_EQ(download, results[0]);
 
   download.received_bytes += 10;
   download.download_slice_info[0].received_bytes = download.received_bytes;
   ASSERT_TRUE(db_->UpdateDownload(download));
   db_->QueryDownloads(&results);
@@ skipping 14 matching lines @@
   base::Time last_access_time(start_time + base::TimeDelta::FromHours(5));
   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"),
       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", 0,
       1500, DownloadState::INTERRUPTED, DownloadDangerType::NOT_DANGEROUS,
       kTestDownloadInterruptReasonCrash, "hash-value1", id,
-      "FE672168-26EF-4275-A149-FEC25F6A75F9", false, last_access_time,
+      "FE672168-26EF-4275-A149-FEC25F6A75F9", false, last_access_time, true,
       "extension-id", "extension-name", std::vector<DownloadSliceInfo>());
   ASSERT_TRUE(db_->CreateDownload(download));
 
   // Add a new slice and call UpdateDownload().
   download.download_slice_info.push_back(DownloadSliceInfo(id, 500, 100));
   ASSERT_TRUE(db_->UpdateDownload(download));
   std::vector<DownloadRow> results;
   db_->QueryDownloads(&results);
   ASSERT_EQ(1u, results.size());
   EXPECT_EQ(download.download_slice_info[0], results[0].download_slice_info[0]);
@@ skipping 20 matching lines @@
   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"),
       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",
       received, 1500, DownloadState::INTERRUPTED,
       DownloadDangerType::NOT_DANGEROUS, kTestDownloadInterruptReasonCrash,
       "hash-value1", id, "FE672168-26EF-4275-A149-FEC25F6A75F9", false,
-      last_access_time, "extension-id", "extension-name", slice_info);
+      last_access_time, true, "extension-id", "extension-name", slice_info);
   ASSERT_TRUE(db_->CreateDownload(download));
   std::vector<DownloadRow> results;
   db_->QueryDownloads(&results);
   ASSERT_EQ(1u, results.size());
   // Only 3 slices are inserted.
   EXPECT_EQ(3u, results[0].download_slice_info.size());
 
   // If slice info vector is empty, all slice entries will be removed.
   download.download_slice_info.clear();
   ASSERT_TRUE(db_->UpdateDownload(download));
@@ skipping 146 matching lines @@
   // URL should win instead.
   std::vector<std::unique_ptr<PageUsageData>> results2 =
       db_->QuerySegmentUsage(time, 1, base::Bind(&FilterURL));
   ASSERT_EQ(1u, results2.size());
   EXPECT_EQ(url2, results2[0]->GetURL());
   EXPECT_EQ(segment_id2, results2[0]->GetID());
 }
 
 }  // namespace
 }  // namespace history