[Offline pages] Adding expiration capability to OfflinePageModel

components/offline_pages/offline_page_metadata_store_sql.cc

 // Copyright 2016 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 "components/offline_pages/offline_page_metadata_store_sql.h"
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
@@ skipping 20 matching lines @@
     " creation_time INTEGER NOT NULL,"
     " file_size INTEGER NOT NULL,"
     " version INTEGER NOT NULL,"
     " last_access_time INTEGER NOT NULL,"
     " access_count INTEGER NOT NULL,"
     " status INTEGER NOT NULL DEFAULT 0,"
     // A note on this field:  It will be NULL for now and is reserved for
     // later use.  We will treat NULL as "Unknown" in any subsequent queries
     // for user_initiated values.
     " user_initiated INTEGER,"  // this is actually a boolean
+    " expiration_time INTEGER NOT NULL,"
     " client_namespace VARCHAR NOT NULL,"
     " client_id VARCHAR NOT NULL,"
     " online_url VARCHAR NOT NULL,"
     " offline_url VARCHAR NOT NULL DEFAULT '',"
     " file_path VARCHAR NOT NULL"
     ")";
 
 // This is cloned from //content/browser/appcache/appcache_database.cc
 struct TableInfo {
   const char* table_name;
   const char* columns;
 };
 
 const TableInfo kOfflinePagesTable{OFFLINE_PAGES_TABLE_NAME,
                                    kOfflinePagesColumns};
 
 // This enum is used to define the indices for the columns in each row
 // that hold the different pieces of offline page.
 enum : int {
   OP_OFFLINE_ID = 0,
   OP_CREATION_TIME,
   OP_FILE_SIZE,
   OP_VERSION,
   OP_LAST_ACCESS_TIME,
   OP_ACCESS_COUNT,
   OP_STATUS,
   OP_USER_INITIATED,
+  OP_EXPIRATION_TIME,
   OP_CLIENT_NAMESPACE,
   OP_CLIENT_ID,
   OP_ONLINE_URL,
   OP_OFFLINE_URL,
-  OP_FILE_PATH
+  OP_FILE_PATH,
 };
 
 bool CreateTable(sql::Connection* db, const TableInfo& table_info) {
   std::string sql("CREATE TABLE ");
   sql += table_info.table_name;
   sql += table_info.columns;
   return db->Execute(sql.c_str());
 }
 
 bool CreateSchema(sql::Connection* db) {
@@ skipping 36 matching lines @@
 #endif
   int64_t file_size = statement->ColumnInt64(OP_FILE_SIZE);
   base::Time creation_time =
       base::Time::FromInternalValue(statement->ColumnInt64(OP_CREATION_TIME));
 
   OfflinePageItem item(url, id, client_id, path, file_size, creation_time);
   item.last_access_time = base::Time::FromInternalValue(
       statement->ColumnInt64(OP_LAST_ACCESS_TIME));
   item.version = statement->ColumnInt(OP_VERSION);
   item.access_count = statement->ColumnInt(OP_ACCESS_COUNT);
+  item.expiration_time =
+      base::Time::FromInternalValue(statement->ColumnInt64(OP_EXPIRATION_TIME));
   return item;
 }
 
 bool InsertOrReplace(sql::Connection* db, const OfflinePageItem& item) {
   const char kSql[] =
       "INSERT OR REPLACE INTO " OFFLINE_PAGES_TABLE_NAME
       " (offline_id, online_url, client_namespace, client_id, file_path, "
-      "file_size, creation_time, last_access_time, version, access_count)"
+      "file_size, creation_time, last_access_time, version, access_count, "
+      "expiration_time)"
       " VALUES "
-      " (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
+      " (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
 
   sql::Statement statement(db->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindInt64(0, item.offline_id);
   statement.BindString(1, item.url.spec());
   statement.BindString(2, item.client_id.name_space);
   statement.BindString(3, item.client_id.id);
 #if defined(OS_POSIX)
   std::string path_string = item.file_path.value();
 #elif defined(OS_WIN)
   std::string path_string = base::WideToUTF8(item.file_path.value());
 #else
 #error Unknown OS
 #endif
   statement.BindString(4, path_string);
   statement.BindInt64(5, item.file_size);
   statement.BindInt64(6, item.creation_time.ToInternalValue());
   statement.BindInt64(7, item.last_access_time.ToInternalValue());
   statement.BindInt(8, item.version);
   statement.BindInt(9, item.access_count);
+  statement.BindInt64(10, item.expiration_time.ToInternalValue());
   return statement.Run();
 }
 
 bool InitDatabase(sql::Connection* db, base::FilePath path) {
   db->set_page_size(4096);
   db->set_cache_size(500);
   db->set_histogram_tag("OfflinePageMetadata");
   db->set_exclusive_locking();
 
   base::File::Error err;
@@ skipping 155 matching lines @@
 }
 
 void OfflinePageMetadataStoreSQL::Reset(const ResetCallback& callback) {
   background_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&OfflinePageMetadataStoreSQL::ResetSync, base::Passed(&db_),
                  base::ThreadTaskRunnerHandle::Get(), callback));
 }
 
 }  // namespace offline_pages