Add Quota.TimeSinceOriginEvicted UMA histogram.

storage/browser/quota/quota_database.cc

 // Copyright 2013 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 "storage/browser/quota/quota_database.h"
 
 #include <vector>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "sql/connection.h"
 #include "sql/meta_table.h"
 #include "sql/statement.h"
 #include "sql/transaction.h"
 #include "storage/browser/quota/special_storage_policy.h"
 
 namespace storage {
 namespace {
 
 // Definitions for database schema.
 
-const int kCurrentVersion = 4;
+const int kCurrentVersion = 5;
 const int kCompatibleVersion = 2;
 
 const char kHostQuotaTable[] = "HostQuotaTable";
 const char kOriginInfoTable[] = "OriginInfoTable";
+const char kEvictionInfoTable[] = "EvictionInfoTable";
 const char kIsOriginTableBootstrapped[] = "IsOriginTableBootstrapped";
 
 bool VerifyValidQuotaConfig(const char* key) {
   return (key != NULL &&
           (!strcmp(key, QuotaDatabase::kDesiredAvailableSpaceKey) ||
            !strcmp(key, QuotaDatabase::kTemporaryQuotaOverrideKey)));
 }
 
 const int kCommitIntervalMs = 30000;
 
@@ skipping 16 matching lines @@
 }
 
 }  // anonymous namespace
 
 // static
 const char QuotaDatabase::kDesiredAvailableSpaceKey[] = "DesiredAvailableSpace";
 const char QuotaDatabase::kTemporaryQuotaOverrideKey[] =
     "TemporaryQuotaOverride";
 
 const QuotaDatabase::TableSchema QuotaDatabase::kTables[] = {
-  { kHostQuotaTable,
-    "(host TEXT NOT NULL,"
-    " type INTEGER NOT NULL,"
-    " quota INTEGER DEFAULT 0,"
-    " UNIQUE(host, type))" },
-  { kOriginInfoTable,
-    "(origin TEXT NOT NULL,"
-    " type INTEGER NOT NULL,"
-    " used_count INTEGER DEFAULT 0,"
-    " last_access_time INTEGER DEFAULT 0,"
-    " last_modified_time INTEGER DEFAULT 0,"
-    " UNIQUE(origin, type))" },
-};
+    {kHostQuotaTable,
+     "(host TEXT NOT NULL,"
+     " type INTEGER NOT NULL,"
+     " quota INTEGER DEFAULT 0,"
+     " UNIQUE(host, type))"},
+    {kOriginInfoTable,
+     "(origin TEXT NOT NULL,"
+     " type INTEGER NOT NULL,"
+     " used_count INTEGER DEFAULT 0,"
+     " last_access_time INTEGER DEFAULT 0,"
+     " last_modified_time INTEGER DEFAULT 0,"
+     " UNIQUE(origin, type))"},
+    {kEvictionInfoTable,
+     "(origin TEXT NOT NULL,"
+     " type INTEGER NOT NULL,"
+     " last_eviction_time INTEGER DEFAULT 0,"
+     " UNIQUE(origin, type))"}};
 
 // static
 const QuotaDatabase::IndexSchema QuotaDatabase::kIndexes[] = {
   { "HostIndex",
     kHostQuotaTable,
     "(host)",
     false },
   { "OriginInfoIndex",
     kOriginInfoTable,
     "(origin)",
     false },
   { "OriginLastAccessTimeIndex",
     kOriginInfoTable,
     "(last_access_time)",
     false },
   { "OriginLastModifiedTimeIndex",
     kOriginInfoTable,
     "(last_modified_time)",
     false },

[michaeln, 2015/10/13 21:35:36]

do you want an index on the origin column?

[calamity, 2015/10/15 07:56:43]

Hmm. I don't think it will be necessary. We're not really doing queries that
would benefit from an origin-only index. sqlite already generates an auto index
from the unique constraint for (origin, type) which should satisfy our query
needs.

In fact, I'm not sure some of these other indexes here are good ideas either.
The access/modified time indexes are going to incur overhead as they are
constantly written to while the benefit of avoiding a sort at eviction time is
rare. A full scan per eviction is probably more performant than constantly
updating the indexes on every storage access. The other 2 indexes also probably
don't need to be there since the auto index for the tables satisfies their query
needs.

 };
 
 struct QuotaDatabase::QuotaTableImporter {
   bool Append(const QuotaTableEntry& entry) {
     entries.push_back(entry);
     return true;
   }
   std::vector<QuotaTableEntry> entries;
 };
 
@@ skipping 150 matching lines @@
   statement.BindString(1, origin.spec());
   statement.BindInt(2, static_cast<int>(type));
 
   if (!statement.Run())
     return false;
 
   ScheduleCommit();
   return true;
 }
 
+bool QuotaDatabase::GetOriginLastEvictionTime(const GURL& origin,
+                                              StorageType type,
+                                              base::Time* last_modified_time) {
+  DCHECK(last_modified_time);
+  if (!LazyOpen(false))
+    return false;
+
+  const char* kSql =
+      "SELECT last_eviction_time"
+      " FROM EvictionInfoTable"
+      " WHERE origin = ? AND type = ?";
+
+  sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
+  statement.BindString(0, origin.spec());
+  statement.BindInt(1, static_cast<int>(type));
+
+  if (!statement.Step())
+    return statement.Succeeded();
+
+  *last_modified_time = base::Time::FromInternalValue(statement.ColumnInt64(0));
+  return true;
+}
+
+bool QuotaDatabase::SetOriginLastEvictionTime(const GURL& origin,
+                                              StorageType type,
+                                              base::Time last_modified_time) {
+  if (!LazyOpen(true))
+    return false;
+
+  const char* kSql =
+      "INSERT OR REPLACE INTO EvictionInfoTable"
+      " (last_eviction_time, origin, type)"
+      " VALUES (?, ?, ?)";
+  sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
+  statement.BindInt64(0, last_modified_time.ToInternalValue());
+  statement.BindString(1, origin.spec());
+  statement.BindInt(2, static_cast<int>(type));
+
+  if (!statement.Run())
+    return false;
+
+  ScheduleCommit();
+  return true;
+}
+
+bool QuotaDatabase::DeleteOriginLastEvictionTime(const GURL& origin,
+                                                 StorageType type) {
+  if (!LazyOpen(false))
+    return false;
+
+  const char* kSql =
+      "DELETE FROM EvictionInfoTable"
+      " WHERE origin = ? AND type = ?";
+
+  sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
+  statement.BindString(0, origin.spec());
+  statement.BindInt(1, static_cast<int>(type));
+
+  if (!statement.Run())
+    return false;
+
+  ScheduleCommit();
+  return true;
+}
+
 bool QuotaDatabase::RegisterInitialOriginInfo(
     const std::set<GURL>& origins, StorageType type) {
   if (!LazyOpen(true))
     return false;
 
   typedef std::set<GURL>::const_iterator itr_type;
   for (itr_type itr = origins.begin(), end = origins.end();
        itr != end; ++itr) {
     const char* kSql =
         "INSERT OR IGNORE INTO OriginInfoTable"
@@ skipping 319 matching lines @@
 
   // So we can't go recursive.
   if (is_recreating_)
     return false;
 
   base::AutoReset<bool> auto_reset(&is_recreating_, true);
   return LazyOpen(true);
 }
 
 bool QuotaDatabase::UpgradeSchema(int current_version) {
+  bool upgraded = false;
   if (current_version == 2) {
     QuotaTableImporter importer;
     typedef std::vector<QuotaTableEntry> QuotaTableEntries;
     if (!DumpQuotaTable(base::Bind(&QuotaTableImporter::Append,
                                    base::Unretained(&importer)))) {
       return false;
     }
     ResetSchema();
     for (QuotaTableEntries::const_iterator iter = importer.entries.begin();
          iter != importer.entries.end(); ++iter) {
       if (!SetHostQuota(iter->host, iter->type, iter->quota))
         return false;
     }
     Commit();
-    return true;
+    upgraded = true;
+  } else if (current_version < 5) {
+    const QuotaDatabase::TableSchema& eviction_table_schema = kTables[2];
+    DCHECK_EQ(strcmp(kEvictionInfoTable, eviction_table_schema.table_name), 0);
+
+    std::string sql("CREATE TABLE ");
+    sql += eviction_table_schema.table_name;
+    sql += eviction_table_schema.columns;
+    if (!db_->Execute(sql.c_str())) {
+      VLOG(1) << "Failed to execute " << sql;
+      return false;
+    }

[michaeln, 2015/10/13 21:35:36]

do you want an index on the origin column?

[calamity, 2015/10/15 07:56:43]

See above.

+
+    meta_table_->SetVersionNumber(5);

[michaeln, 2015/10/13 21:35:36]

i think you want to to Commit() here

[calamity, 2015/10/15 07:56:43]

Done.

[calamity, 2015/10/15 11:11:06]

Oops, missed this one. Will do it tomorrow.

+    upgraded = true;
   }
-  return false;
+  return upgraded;
 }
 
 bool QuotaDatabase::DumpQuotaTable(const QuotaTableCallback& callback) {
   if (!LazyOpen(true))
     return false;
 
   const char* kSql = "SELECT * FROM HostQuotaTable";
   sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
 
   while (statement.Step()) {
@@ skipping 47 matching lines @@
   if (lhs.origin < rhs.origin) return true;
   if (rhs.origin < lhs.origin) return false;
   if (lhs.type < rhs.type) return true;
   if (rhs.type < lhs.type) return false;
   if (lhs.used_count < rhs.used_count) return true;
   if (rhs.used_count < lhs.used_count) return false;
   return lhs.last_access_time < rhs.last_access_time;
 }
 
 }  // namespace storage