Add access count and time-since-accessed histograms to temp storage eviction.

content/browser/quota/quota_database_unittest.cc

 // Copyright 2014 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 <algorithm>
 #include <iterator>
 #include <set>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 288 matching lines @@
 
   void OriginLastEvicted(const base::FilePath& kDbFile) {
     QuotaDatabase db(kDbFile);
     ASSERT_TRUE(db.LazyOpen(true));
 
     const GURL kOrigin1("http://a/");
     const GURL kOrigin2("http://b/");
     const GURL kOrigin3("http://c/");
 
     base::Time last_eviction_time;
-    EXPECT_TRUE(db.GetOriginLastEvictionTime(kOrigin1, kStorageTypeTemporary,
-                                             &last_eviction_time));
+    EXPECT_FALSE(db.GetOriginLastEvictionTime(kOrigin1, kStorageTypeTemporary,
+                                              &last_eviction_time));
     EXPECT_EQ(base::Time(), last_eviction_time);
 
     // Report last eviction time for the test origins.
     EXPECT_TRUE(db.SetOriginLastEvictionTime(
         kOrigin1, kStorageTypeTemporary, base::Time::FromInternalValue(10)));
     EXPECT_TRUE(db.SetOriginLastEvictionTime(
         kOrigin2, kStorageTypeTemporary, base::Time::FromInternalValue(20)));
     EXPECT_TRUE(db.SetOriginLastEvictionTime(
         kOrigin3, kStorageTypeTemporary, base::Time::FromInternalValue(30)));
 
     EXPECT_TRUE(db.GetOriginLastEvictionTime(kOrigin1, kStorageTypeTemporary,
                                              &last_eviction_time));
     EXPECT_EQ(base::Time::FromInternalValue(10), last_eviction_time);
     EXPECT_TRUE(db.GetOriginLastEvictionTime(kOrigin2, kStorageTypeTemporary,
                                              &last_eviction_time));
     EXPECT_EQ(base::Time::FromInternalValue(20), last_eviction_time);
     EXPECT_TRUE(db.GetOriginLastEvictionTime(kOrigin3, kStorageTypeTemporary,
                                              &last_eviction_time));
     EXPECT_EQ(base::Time::FromInternalValue(30), last_eviction_time);
 
     // Delete last eviction times for the test origins.
     EXPECT_TRUE(
         db.DeleteOriginLastEvictionTime(kOrigin1, kStorageTypeTemporary));
     EXPECT_TRUE(
         db.DeleteOriginLastEvictionTime(kOrigin2, kStorageTypeTemporary));
     EXPECT_TRUE(
         db.DeleteOriginLastEvictionTime(kOrigin3, kStorageTypeTemporary));
 
     last_eviction_time = base::Time();
-    EXPECT_TRUE(db.GetOriginLastEvictionTime(kOrigin1, kStorageTypeTemporary,
-                                             &last_eviction_time));
+    EXPECT_FALSE(db.GetOriginLastEvictionTime(kOrigin1, kStorageTypeTemporary,
+                                              &last_eviction_time));
     EXPECT_EQ(base::Time(), last_eviction_time);
-    EXPECT_TRUE(db.GetOriginLastEvictionTime(kOrigin2, kStorageTypeTemporary,
-                                             &last_eviction_time));
+    EXPECT_FALSE(db.GetOriginLastEvictionTime(kOrigin2, kStorageTypeTemporary,
+                                              &last_eviction_time));
     EXPECT_EQ(base::Time(), last_eviction_time);
-    EXPECT_TRUE(db.GetOriginLastEvictionTime(kOrigin3, kStorageTypeTemporary,
-                                             &last_eviction_time));
+    EXPECT_FALSE(db.GetOriginLastEvictionTime(kOrigin3, kStorageTypeTemporary,
+                                              &last_eviction_time));
     EXPECT_EQ(base::Time(), last_eviction_time);
 
     // Deleting an origin that is not present should not fail.
     EXPECT_TRUE(db.DeleteOriginLastEvictionTime(GURL("http://notpresent.com"),
                                                 kStorageTypeTemporary));
   }
 
   void RegisterInitialOriginInfo(const base::FilePath& kDbFile) {
     QuotaDatabase db(kDbFile);
 
@@ skipping 80 matching lines @@
     AssignOriginInfoTable(db.db_.get(), begin, end);
     db.Commit();
 
     typedef EntryVerifier<Entry> Verifier;
     Verifier verifier(begin, end);
     EXPECT_TRUE(db.DumpOriginInfoTable(
         base::Bind(&Verifier::Run, base::Unretained(&verifier))));
     EXPECT_TRUE(verifier.table.empty());
   }
 
+  void GetOriginInfo(const base::FilePath& kDbFile) {
+    const GURL kOrigin = GURL("http://go/");
+    typedef QuotaDatabase::OriginInfoTableEntry Entry;
+    Entry kTableEntries[] = {
+        Entry(kOrigin, kStorageTypeTemporary, 100, base::Time(), base::Time())};
+    Entry* begin = kTableEntries;
+    Entry* end = kTableEntries + arraysize(kTableEntries);
+
+    QuotaDatabase db(kDbFile);
+    EXPECT_TRUE(db.LazyOpen(true));
+    AssignOriginInfoTable(db.db_.get(), begin, end);
+    db.Commit();
+
+    {
+      Entry entry;
+      EXPECT_TRUE(db.GetOriginInfo(kOrigin, kStorageTypeTemporary, &entry));
+      EXPECT_EQ(kTableEntries[0].type, entry.type);
+      EXPECT_EQ(kTableEntries[0].origin, entry.origin);
+      EXPECT_EQ(kTableEntries[0].used_count, entry.used_count);
+      EXPECT_EQ(kTableEntries[0].last_access_time, entry.last_access_time);
+      EXPECT_EQ(kTableEntries[0].last_modified_time, entry.last_modified_time);
+    }
+
+    {
+      Entry entry;
+      EXPECT_FALSE(db.GetOriginInfo(GURL("http://notpresent.org/"),
+                                    kStorageTypeTemporary, &entry));
+    }
+  }
+
  private:
   template <typename Iterator>
   void AssignQuotaTable(sql::Connection* db, Iterator itr, Iterator end) {
     ASSERT_NE(db, (sql::Connection*)NULL);
     for (; itr != end; ++itr) {
       const char* kSql =
           "INSERT INTO HostQuotaTable"
           " (host, type, quota)"
           " VALUES (?, ?, ?)";
       sql::Statement statement;
@@ skipping 180 matching lines @@
 }
 
 TEST_F(QuotaDatabaseTest, DumpOriginInfoTable) {
   base::ScopedTempDir data_dir;
   ASSERT_TRUE(data_dir.CreateUniqueTempDir());
   const base::FilePath kDbFile = data_dir.path().AppendASCII(kDBFileName);
   DumpOriginInfoTable(kDbFile);
   DumpOriginInfoTable(base::FilePath());
 }
 
+TEST_F(QuotaDatabaseTest, GetOriginInfo) {
+  GetOriginInfo(base::FilePath());
+}
+
 TEST_F(QuotaDatabaseTest, OpenCorruptedDatabase) {
   base::ScopedTempDir data_dir;
   ASSERT_TRUE(data_dir.CreateUniqueTempDir());
   const base::FilePath kDbFile = data_dir.path().AppendASCII(kDBFileName);
   LazyOpen(kDbFile);
   ASSERT_TRUE(sql::test::CorruptSizeInHeader(kDbFile));
   sql::ScopedErrorIgnorer ignore_errors;
   ignore_errors.IgnoreError(SQLITE_CORRUPT);
   Reopen(kDbFile);
   EXPECT_TRUE(ignore_errors.CheckIgnoredErrors());
 }
 
 }  // namespace content