Implementing EvictedDomainCookieCounter to keep user metrics on cookie eviction and reinstatement.

net/cookies/evicted_domain_cookie_counter.h

Index: net/cookies/evicted_domain_cookie_counter.h
diff --git a/net/cookies/evicted_domain_cookie_counter.h b/net/cookies/evicted_domain_cookie_counter.h
new file mode 100644
index 0000000000000000000000000000000000000000..c1e5083d599c1b0f0b0d268e36571380d8403b53
--- /dev/null
+++ b/net/cookies/evicted_domain_cookie_counter.h
@@ -0,0 +1,151 @@
+// 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 NET_COOKIES_EVICTED_DOMAIN_COOKIE_COUNTER_
+#define NET_COOKIES_EVICTED_DOMAIN_COOKIE_COUNTER_
+
+#include <map>
+#include <string>
+
+#include "base/basictypes.h"
+#include "base/compiler_specific.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/time.h"
+#include "net/cookies/cookie_monster.h"
+
+namespace net {
+
+class CanonicalCookie;
+
+// The Evicted Domain Cookie Counter generates statistics on "wrongly evicted"
+// cookies, i.e., cookies that were "evicted" (on reaching domain cookie limit)
+// but are then "reinstated" later by a website because they were important.
+// Here is a specific scenario: a long-lived login session cookie gets evicted
+// due to its age, thereby forcing the user to lose session, and is reinstated
+// when the annoyed user reauthenticates.
+//
+// A solution to the above problem is the Cookie Priority Field, which gives
+// server a way to protect important cookies, thereby decreasing the chance
+// that these cookies are wrongly evicted. To measure the effictiveness of this

[erikwright (departed), 2013/03/25 17:29:41]

effectiveness.

[huangs, 2013/03/25 21:02:12]

Done.

+// solution, we record eviction statistics before vs. after the fix.
+//
+// Specifically, we wish to record statistics on "reinstatement delay", i.e.,
+// the duration between eviction and reinstatement of cookie. We expect that
+// after the fix, average reinstantement delay will increase, since low priority
+// cookies are less likely to be reinstated after eviction.
+//
+// Statistics for Google domains are tracked separately.
+//
+class NET_EXPORT EvictedDomainCookieCounter : public CookieMonster::Delegate {
+ public:
+  // Structure to store sanitized data from CanonicalCookie.
+  struct EvictedCookie {
+    base::Time eviction_time_;
+    base::Time expiry_time_;
+    bool is_google_;
+
+    EvictedCookie(base::Time eviction_time,
+                  base::Time expiry_time,
+                  bool is_google)
+        : eviction_time_(eviction_time),
+          expiry_time_(expiry_time),
+          is_google_(is_google) {}
+
+    void set_expired() {
+      expiry_time_ = base::Time::UnixEpoch();
+    }
+    bool is_expired(const base::Time& current) {
+      return !expiry_time_.is_null() && current >= expiry_time_;
+    }
+  };
+
+  class Delegate {
+   public:
+    virtual ~Delegate() {};
+
+    // Called when a stored evicted cookie is reinstated.
+    virtual void Report(const EvictedCookie& dc,
+                        const base::Time& reinstatement_time) = 0;
+
+    // Getter of time is placed here to enable mocks.
+    virtual base::Time CurrentTime() = 0;
+  };
+
+  // |next_delegate| can be NULL.
+  explicit EvictedDomainCookieCounter(
+    scoped_refptr<CookieMonster::Delegate> next_delegate);
+
+  EvictedDomainCookieCounter(
+      scoped_refptr<CookieMonster::Delegate> next_cookie_monster_delegate,
+      scoped_ptr<Delegate> delegate,
+      size_t max_size,
+      size_t purge_count);
+
+  // Returns whether or not |cc| is a cookie from Google.
+  // Used for non-security-sensitive purpose of segregrating metrics.

[erikwright (departed), 2013/03/25 17:29:41]

segregating

[huangs, 2013/03/25 21:02:12]

Done.

+  static bool UnsafeIsGoogleCookie(const CanonicalCookie& cc);
+
+  // Returns the number of evicted cookies stored.
+  size_t GetStorageSize() const;
+
+  // CookieMonster::Delegate implementation.
+  virtual void OnCookieChanged(const CanonicalCookie& cc,
+                               bool removed,
+                               ChangeCause cause) OVERRIDE;
+
+ private:
+  // Identifier of an evicted cookie. Can be obtained from GetKey().
+  typedef std::string EvictedCookieKey;
+
+  // Storage class of evicted cookie.
+  typedef std::map<EvictedCookieKey, EvictedCookie*> EvictedCookieMap;
+
+  ~EvictedDomainCookieCounter();
+
+  // Computes a key for |cc| compatible with CanonicalCookie::IsEquivalent(),
+  // i.e., IsEquivalent(a, b) ==> GetKey(a) == GetKey(b).
+  static EvictedCookieKey GetKey(const CanonicalCookie& cc);
+
+  // Deallocates and removes an evicted cookie with given |key| if it is stored.
+  void FreeEvictedCookie(const EvictedCookieKey& key);
+
+  // Deallocates and removes all expired evicted cookies.
+  void FreeExpiredEvictedCookies(base::Time time_bound);
+
+  // If too many evicted cookies are stored, delete the expired ones, then
+  // delete cookies that were evicted the longest, until size limit reached.
+  void GarbageCollect(const base::Time& current);
+
+  // Called when a cookie is evicted. Adds the evicted cookie to storage,
+  // possibly replacing an existing equivalent cookie.
+  void StoreEvictedCookie(const EvictedCookieKey& key,
+                          const CanonicalCookie& cc,
+                          const base::Time& current);
+
+  // Called when a new cookie is added. If reinstatement occurs, then notifies
+  // |delegate_| and then removes the evicted cookie.
+  void ProcessNewCookie(const EvictedCookieKey& key,
+                        const CanonicalCookie& cc,
+                        const base::Time& current);
+
+  // Another delegate to forward events to.
+  scoped_refptr<CookieMonster::Delegate> next_cookie_monster_delegate_;
+
+  scoped_ptr<Delegate> delegate_;
+
+  EvictedCookieMap evicted_cookies_;
+
+  // Capacity of the evicted cookie storage, before garbage collection occurs.
+  const size_t max_size_;
+
+  // After garbage collection, size reduces to <= |max_size_| - |purge_count_|.
+  const size_t purge_count_;
+
+  DISALLOW_COPY_AND_ASSIGN(EvictedDomainCookieCounter);
+};
+
+}  // namespace net
+
+#endif // NET_COOKIES_EVICTED_DOMAIN_COOKIE_COUNTER_