Fixes targeting the unique creation times invariant in the CookieMonster:

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"
+#include "testing/gtest/include/gtest/gtest_prod.h"
 
 class GURL;
 
 namespace net {
 
 // The cookie monster is the system for storing and retrieving cookies. It has
 // an in-memory list of all cookies, and synchronizes non-session cookies to an
 // optional permanent storage that implements the PersistentCookieStore
 // interface.
 //
@@ skipping 67 matching lines @@
   // cookie value attribute) and will return false without setting the cookie
   // if such characters are found.
   bool SetCookieWithDetails(const GURL& url,
                             const std::string& name,
                             const std::string& value,
                             const std::string& domain,
                             const std::string& path,
                             const base::Time& expiration_time,
                             bool secure, bool http_only);
 
-  // Exposed for unit testing.
-  bool SetCookieWithCreationTimeAndOptions(const GURL& url,
-                                           const std::string& cookie_line,
-                                           const base::Time& creation_time,
-                                           const CookieOptions& options);
-  bool SetCookieWithCreationTime(const GURL& url,
-                                 const std::string& cookie_line,
-                                 const base::Time& creation_time) {
-    return SetCookieWithCreationTimeAndOptions(url, cookie_line, creation_time,
-                                               CookieOptions());
-  }
-
   // Returns all the cookies, for use in management UI, etc. This does not mark
   // the cookies as having been accessed.
   CookieList GetAllCookies();
 
   // Returns all the cookies, for use in management UI, etc. Filters results
   // using given url scheme, host / domain and path. This does not mark the
   // cookies as having been accessed.
   CookieList GetAllCookiesForURL(const GURL& url);
 
   // Delete all of the cookies.
@@ skipping 28 matching lines @@
   // There are some unknowns about how to correctly handle file:// cookies,
   // and our implementation for this is not robust enough. This allows you
   // to enable support, but it should only be used for testing. Bug 1157243.
   // Must be called before creating a CookieMonster instance.
   static void EnableFileScheme();
   static bool enable_file_scheme_;
 
  private:
   ~CookieMonster();
 
+  // Testing support.
+  friend class CookieMonsterTest;
+  FRIEND_TEST(CookieMonsterTest, TestCookieDeleteAllCreatedAfterTimestamp);
+  FRIEND_TEST(CookieMonsterTest, TestCookieDeleteAllCreatedBetweenTimestamps);
+  bool SetCookieWithCreationTime(const GURL& url,
+                                 const std::string& cookie_line,
+                                 const base::Time& creation_time);
+
   // Called by all non-static functions to ensure that the cookies store has
   // been initialized. This is not done during creating so it doesn't block
   // the window showing.
   // Note: this method should always be called with lock_ held.
   void InitIfNecessary() {
     if (!initialized_) {
       if (store_)
         InitStore();
       initialized_ = true;
     }
@@ skipping 33 matching lines @@
   // return value with be true if |skip_httponly| skipped an httponly cookie.
   // NOTE: There should never be more than a single matching equivalent cookie.
   bool DeleteAnyEquivalentCookie(const std::string& key,
                                  const CanonicalCookie& ecc,
                                  bool skip_httponly);
 
   void InternalInsertCookie(const std::string& key,
                             CanonicalCookie* cc,
                             bool sync_to_store);
 
+  // Helper function that sets cookies with more control.
+  // Not exposed as we don't want callers to have the ability
+  // to specify (potentially duplicate) creation times.
+  bool SetCookieWithCreationTimeAndOptions(const GURL& url,
+                                           const std::string& cookie_line,
+                                           const base::Time& creation_time,
+                                           const CookieOptions& options);
+
+
   // Helper function that sets a canonical cookie, deleting equivalents and
   // performing garbage collection.
   bool SetCanonicalCookie(scoped_ptr<CanonicalCookie>* cc,
                           const base::Time& creation_time,
                           const CookieOptions& options);
 
   void InternalUpdateCookieAccessTime(CanonicalCookie* cc);
 
   enum DeletionCause {
     DELETE_COOKIE_EXPLICIT,
@@ skipping 310 matching lines @@
  protected:
   PersistentCookieStore() { }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PersistentCookieStore);
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_COOKIE_MONSTER_H_