Initial commit of CookieMonster statistics.

net/base/cookie_monster.h

 // Copyright (c) 2010 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.
 
 // Brought to you by the letter D and the number 2.
 
 #ifndef NET_BASE_COOKIE_MONSTER_H_
 #define NET_BASE_COOKIE_MONSTER_H_
 
 #include <map>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/basictypes.h"
+#include "base/histogram.h"
 #include "base/lock.h"
 #include "base/ref_counted.h"
 #include "base/scoped_ptr.h"
 #include "base/time.h"
 #include "net/base/cookie_store.h"
 
 class GURL;
 
 namespace net {
 
@@ skipping 36 matching lines @@
   CookieMonster(PersistentCookieStore* store, Delegate* delegate);
 
 #ifdef UNIT_TEST
   CookieMonster(PersistentCookieStore* store,
                 Delegate* delegate,
                 int last_access_threshold_milliseconds)
       : initialized_(false),
         store_(store),
         last_access_threshold_(base::TimeDelta::FromMilliseconds(
             last_access_threshold_milliseconds)),
-        delegate_(delegate) {
+        delegate_(delegate),
+        last_statistic_record_time_(base::Time::Now()) {
     SetDefaultCookieableSchemes();
   }
 #endif
 
   // Parse the string with the cookie time (very forgivingly).
   static base::Time ParseCookieTime(const std::string& time_string);
 
   // Returns true if a domain string represents a host-only cookie,
   // i.e. it doesn't begin with a leading '.' character.
   static bool DomainIsHostOnly(const std::string& domain_string);
@@ skipping 140 matching lines @@
 
   // Helper function that sets a canonical cookie, deleting equivalents and
   // performing garbage collection.
   bool SetCanonicalCookie(scoped_ptr<CanonicalCookie>* cc,
                           const std::string& cookie_domain,
                           const base::Time& creation_time,
                           const CookieOptions& options);
 
   void InternalUpdateCookieAccessTime(CanonicalCookie* cc);
 
-  void InternalDeleteCookie(CookieMap::iterator it, bool sync_to_store);
+  enum DeletionCause { kDeleteCookieExplicit,

[darin (slow to review), 2010/07/02 16:35:00]

"Though the style guide says to use kConstantNaming for enums now, we still use
MACRO_STYLE naming for enums for consistency with existing code."

Please see http://dev.chromium.org/developers/coding-style

+                       kDeleteCookieOverwrite,
+                       kDeleteCookieExpired,
+                       kDeleteCookieEvicted,
+                       kDeleteCookieDuplicateInBackingStore,
+                       kDeleteCookieDontRecord,
+                       kDeleteCookieLastEntry = kDeleteCookieDontRecord };
+
+  // |deletion_cause| argument is for collecting statistics.
+  void InternalDeleteCookie(CookieMap::iterator it, bool sync_to_store,
+                            DeletionCause deletion_cause);
 
   // If the number of cookies for host |key|, or globally, are over preset
   // maximums, garbage collects, first for the host and then globally, as
   // described by GarbageCollectRange().  The limits can be found as constants
   // at the top of the function body.
   //
   // Returns the number of cookies deleted (useful for debugging).
   int GarbageCollect(const base::Time& current, const std::string& key);
 
   // Deletes all expired cookies in |itpair|;
@@ skipping 11 matching lines @@
   // all expired cookies in |itpair|.  If |cookie_its| is non-NULL, it is
   // populated with all the non-expired cookies from |itpair|.
   //
   // Returns the number of cookies deleted.
   int GarbageCollectExpired(const base::Time& current,
                             const CookieMapItPair& itpair,
                             std::vector<CookieMap::iterator>* cookie_its);
 
   bool HasCookieableScheme(const GURL& url);
 
+  // Statistics support
+  // Record statistics every kRecordStatisticsIntervalSeconds of uptime.
+  static const int kRecordStatisticsIntervalSeconds = 10 * 60;
+
+  // This function should be called repeatedly, and will record
+  // statistics if a sufficient time period has passed.
+  void RecordPeriodicStats(const base::Time &current_time);

[eroman, 2010/06/21 18:22:43]

style nit:  |const base::Time& current_time|

+
   CookieMap cookies_;
 
   // Indicates whether the cookie store has been initialized. This happens
   // lazily in InitStoreIfNecessary().
   bool initialized_;
 
   scoped_refptr<PersistentCookieStore> store_;
 
   // The resolution of our time isn't enough, so we do something
   // ugly and increment when we've seen the same time twice.
   base::Time CurrentTime();
   base::Time last_time_seen_;
 
   // Minimum delay after updating a cookie's LastAccessDate before we will
   // update it again.
   const base::TimeDelta last_access_threshold_;
 
   std::vector<std::string> cookieable_schemes_;
 
   scoped_refptr<Delegate> delegate_;
 
   // Lock for thread-safety
   Lock lock_;
 
+  base::Time last_statistic_record_time_;
+
   DISALLOW_COPY_AND_ASSIGN(CookieMonster);
 };
 
 class CookieMonster::CanonicalCookie {
  public:
   CanonicalCookie() { }
   CanonicalCookie(const std::string& name,
                   const std::string& value,
                   const std::string& path,
                   bool secure,
@@ skipping 192 matching lines @@
  protected:
   PersistentCookieStore() { }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PersistentCookieStore);
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_COOKIE_MONSTER_H_