Add daily quota for precache

components/precache/core/precache_session_table.cc

Index: components/precache/core/precache_session_table.cc
diff --git a/components/precache/core/precache_session_table.cc b/components/precache/core/precache_session_table.cc
index 9993c069bbe72ef3de7d9384c6bd79b3d25042b4..f7ac55c7a0e5333efc3a96a3fa05fe34fe00e23a 100644
--- a/components/precache/core/precache_session_table.cc
+++ b/components/precache/core/precache_session_table.cc
@@ -29,25 +29,37 @@ bool PrecacheSessionTable::Init(sql::Connection* db) {
   return CreateTableIfNonExistent();
 }
 
-void PrecacheSessionTable::SetLastPrecacheTimestamp(const base::Time& time) {
-  DCHECK(!time.is_null());
-  Timestamp timestamp;
-  timestamp.set_seconds((time - base::Time::UnixEpoch()).InSeconds());
+void PrecacheSessionTable::SetSessionDataType(SessionDataType id,
+                                              const std::string& data) {
   Statement statement(db_->GetCachedStatement(
       SQL_FROM_HERE,
       "INSERT OR REPLACE INTO precache_session (type, value) VALUES(?,?)"));
-  statement.BindInt(0, static_cast<int>(LAST_PRECACHE_TIMESTAMP));
-  statement.BindString(1, timestamp.SerializeAsString());
+  statement.BindInt(0, static_cast<int>(id));
+  statement.BindString(1, data);
   statement.Run();
 }
 
-base::Time PrecacheSessionTable::GetLastPrecacheTimestamp() {
+std::string PrecacheSessionTable::GetSessionDataType(SessionDataType id) {
   Statement statement(db_->GetCachedStatement(
       SQL_FROM_HERE, "SELECT value from precache_session where type=?"));
-  statement.BindInt(0, static_cast<int>(LAST_PRECACHE_TIMESTAMP));
+  statement.BindInt(0, static_cast<int>(id));
+  return statement.Step() ? statement.ColumnString(0) : std::string();
+}
+
+void PrecacheSessionTable::SetLastPrecacheTimestamp(const base::Time& time) {
+  DCHECK(!time.is_null());
+  Timestamp timestamp;
+  timestamp.set_seconds((time - base::Time::UnixEpoch()).InSeconds());
+  SetSessionDataType(SessionDataType::LAST_PRECACHE_TIMESTAMP,
+                     timestamp.SerializeAsString());
+}
+
+base::Time PrecacheSessionTable::GetLastPrecacheTimestamp() {
   Timestamp timestamp;
-  if (statement.Step())
-    timestamp.ParseFromString(statement.ColumnString(0));
+  const std::string data =
+      GetSessionDataType(SessionDataType::LAST_PRECACHE_TIMESTAMP);
+  if (!data.empty())
+    timestamp.ParseFromString(data);
   return timestamp.has_seconds()
              ? base::Time::UnixEpoch() +
                    base::TimeDelta::FromSeconds(timestamp.seconds())
@@ -57,44 +69,49 @@ base::Time PrecacheSessionTable::GetLastPrecacheTimestamp() {
 void PrecacheSessionTable::DeleteLastPrecacheTimestamp() {
   Statement statement(db_->GetCachedStatement(
       SQL_FROM_HERE, "DELETE FROM precache_session where type=?"));
-  statement.BindInt(0, static_cast<int>(LAST_PRECACHE_TIMESTAMP));
+  statement.BindInt(0,
+                    static_cast<int>(SessionDataType::LAST_PRECACHE_TIMESTAMP));
   statement.Run();
 }
 
 // Store unfinished work.
 void PrecacheSessionTable::SaveUnfinishedWork(
     std::unique_ptr<PrecacheUnfinishedWork> unfinished_work) {
-  Statement statement(db_->GetCachedStatement(
-      SQL_FROM_HERE,
-      "INSERT OR REPLACE INTO precache_session (type, value) VALUES(?,?)"));
-  statement.BindInt(0, static_cast<int>(UNFINISHED_WORK));
-  statement.BindString(1, unfinished_work->SerializeAsString());
-  statement.Run();
+  SetSessionDataType(SessionDataType::UNFINISHED_WORK,
+                     unfinished_work->SerializeAsString());
 }
 
 // Retrieve unfinished work.
 std::unique_ptr<PrecacheUnfinishedWork>
 PrecacheSessionTable::GetUnfinishedWork() {
-  Statement statement(db_->GetCachedStatement(
-      SQL_FROM_HERE, "SELECT value from precache_session where type=?"));
-  statement.BindInt(0, static_cast<int>(UNFINISHED_WORK));
+  const std::string data = GetSessionDataType(SessionDataType::UNFINISHED_WORK);
   std::unique_ptr<PrecacheUnfinishedWork> unfinished_work(
       new PrecacheUnfinishedWork());
-  if (statement.Step())
-    unfinished_work->ParseFromString(statement.ColumnString(0));
+  if (!data.empty())
+    unfinished_work->ParseFromString(data);
   return unfinished_work;
 }
 
-
-
 void PrecacheSessionTable::DeleteUnfinishedWork() {
   Statement statement(
       db_->GetCachedStatement(
           SQL_FROM_HERE, "DELETE FROM precache_session where type=?"));
-  statement.BindInt(0, static_cast<int>(UNFINISHED_WORK));
+  statement.BindInt(0, static_cast<int>(SessionDataType::UNFINISHED_WORK));
   statement.Run();
 }
 
+void PrecacheSessionTable::SaveQuota(const PrecacheQuota& quota) {
+  SetSessionDataType(SessionDataType::QUOTA, quota.SerializeAsString());
+}
+
+PrecacheQuota PrecacheSessionTable::GetQuota() {
+  PrecacheQuota quota;
+  const std::string data = GetSessionDataType(SessionDataType::QUOTA);
+  if (!data.empty())
+    quota.ParseFromString(data);
+  return quota;
+}
+
 bool PrecacheSessionTable::CreateTableIfNonExistent() {
   return db_->Execute(
       "CREATE TABLE IF NOT EXISTS precache_session (type INTEGER PRIMARY KEY, "