Report Precache.TimeSinceLastPrecache

components/precache/core/precache_database.h

 // 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.
 
 #ifndef COMPONENTS_PRECACHE_CORE_PRECACHE_DATABASE_H_
 #define COMPONENTS_PRECACHE_CORE_PRECACHE_DATABASE_H_
 
 #include <stdint.h>
 
 #include <list>
@@ skipping 40 matching lines @@
   // Init must be called before any other methods.
   bool Init(const base::FilePath& db_path);
 
   // Deletes precache history from the precache URL table that is more than 60
   // days older than |current_time|.
   void DeleteExpiredPrecacheHistory(const base::Time& current_time);
 
   // Delete all history entries from the database.
   void ClearHistory();
 
+  // Setter and getter for the last precache timestamp.
+  void SetLastPrecacheTimestamp(const base::Time& time);
+  base::Time GetLastPrecacheTimestamp();
+
   // Report precache-related metrics in response to a URL being fetched, where
   // the fetch was motivated by precaching.
   void RecordURLPrefetch(const GURL& url,
                          const base::TimeDelta& latency,
                          const base::Time& fetch_time,
                          int64_t size,
                          bool was_cached);
 
   // Report precache-related metrics in response to a URL being fetched, where
   // the fetch was not motivated by precaching. |is_connection_cellular|
@@ skipping 31 matching lines @@
 
   // Same as Flush(), but also updates the flag |is_flush_posted_| to indicate
   // that a flush is no longer posted.
   void PostedFlush();
 
   // Post a call to PostedFlush() on the current thread's MessageLoop, if
   // |buffered_writes_| is non-empty and there isn't already a flush call
   // posted.
   void MaybePostFlush();
 
+  // Records the time since the last precache.
+  void RecordTimeSinceLastPrecache(const base::Time& fetch_time);
+
   std::unique_ptr<sql::Connection> db_;
 
   // Table that keeps track of URLs that are in the cache because of precaching,
   // and wouldn't be in the cache otherwise. If |buffered_writes_| is non-empty,
   // then this table will not be up to date until the next call to Flush().
   PrecacheURLTable precache_url_table_;
 
   // Table that persists state related to a precache session, including
   // unfinished work to be done.
   PrecacheSessionTable precache_session_table_;
 
   // A vector of write operations to be run on the database.
   std::vector<base::Closure> buffered_writes_;
 
   // Set of URLs that have been modified in |buffered_writes_|. It's a hash set
   // of strings, and not GURLs, because there is no hash function on GURL.
   base::hash_set<std::string> buffered_urls_;
 
   // Flag indicating whether or not a call to Flush() has been posted to run in
   // the future.
   bool is_flush_posted_;
 
   // ThreadChecker used to ensure that all methods other than the constructor
   // or destructor are called on the same thread.
   base::ThreadChecker thread_checker_;
 
+  // Time of the last precache. This is a cached copy of
+  // precache_session_table_.GetLastPrecacheTimestamp.
+  base::Time last_precache_timestamp_;
+
+  // This must be the last member of this class.
   base::WeakPtrFactory<PrecacheDatabase> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(PrecacheDatabase);
 };
 
 }  // namespace precache
 
 #endif  // COMPONENTS_PRECACHE_CORE_PRECACHE_DATABASE_H_