Precache tracking database

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 "base/basictypes.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/threading/non_thread_safe.h"
+
+class GURL;
+
+namespace base {
+class Time;
+}
+
+namespace sql {
+class Connection;
+}
+
+namespace precache {
+
+class PrecacheStatisticsTable;
+class PrecacheURLTable;
+
+// Class that tracks information related to precaching. This class can be
+// constructed or destroyed on any threads, but all other methods must be called
+// on the same thread (e.g. the DB thread).
+class PrecacheDatabase : public base::RefCountedThreadSafe<PrecacheDatabase>,
+                         base::NonThreadSafe {
+ public:
+  // A PrecacheDatabase can be constructed on any thread.
+  PrecacheDatabase();
+
+  // Initializes the precache database with the specified connection. The
+  // PrecacheDatabase takes ownership of |db|. Init must be called before any
+  // other methods.
+  void Init(scoped_ptr<sql::Connection> db);
+
+  // Reports UMA of precache statistics for days up to and including the day of
+  // |end_date|. The precache statistics for these days are deleted from the
+  // database after they have been reported, and expired precache history is
+  // deleted from the precache URL table.
+  void ReportAndDeleteOldStats(const base::Time& end_date);
+
+  // Update precache-related metrics in response to a URL being fetched.
+  // |is_precache| indicates whether or not the fetch is a precache request, and
+  // |is_connection_cellular| indicates whether the current network connection
+  // is a cellular network.
+  void RecordURLFetched(const GURL& url, const base::Time& fetch_time,
+                        int64 size, bool was_cached, bool is_precache,
+                        bool is_connection_cellular);

[davidben, 2013/11/06 23:50:53]

What if you split this into RecordURLFetched and RecordURLPrecached or something
like that? It looks like the handling for those two cases is completely
different anyway. It'd let you cut down a bit on the pile of booleans here.
Dunno what your intended caller looks like, but this seems to also match how
your unit tests uses this anyway.

[sclittle, 2013/11/09 01:07:58]

Done.

+
+ private:
+  friend class base::RefCountedThreadSafe<PrecacheDatabase>;
+  friend class PrecacheDatabaseTest;
+
+  ~PrecacheDatabase();
+
+  bool IsDatabaseAccessible() const;
+
+  scoped_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.
+  scoped_ptr<PrecacheURLTable> precache_url_table_;
+
+  // Table that keeps track of daily cumulative statistics that are relevant to
+  // precaching.
+  scoped_ptr<PrecacheStatisticsTable> precache_statistics_table_;
+
+  DISALLOW_COPY_AND_ASSIGN(PrecacheDatabase);
+};
+
+}  // namespace precache
+
+#endif  // COMPONENTS_PRECACHE_CORE_PRECACHE_DATABASE_H_