Change update threshold in CookieMonster for testing from 1s to 20ms.

net/base/cookie_monster_unittest.cc

 // Copyright (c) 2006-2008 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.
 
 #include <time.h>
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/platform_thread.h"
@@ skipping 799 matching lines @@
   // The non-secure should overwrite the secure.
   EXPECT_EQ("A=B", cm->GetCookies(url_google));
   EXPECT_EQ("D=E; A=B", cm->GetCookies(url_google_secure));
 }
 
 static Time GetFirstCookieAccessDate(net::CookieMonster* cm) {
   const net::CookieMonster::CookieList all_cookies(cm->GetAllCookies());
   return all_cookies.front().second.LastAccessDate();
 }
 
-static const int kLastAccessThresholdSeconds = 1;
+static const int kLastAccessThresholdMilliseconds = 20;
 
 TEST(CookieMonsterTest, TestLastAccess) {
   GURL url_google(kUrlGoogle);
   scoped_refptr<net::CookieMonster> cm(
-      new net::CookieMonster(kLastAccessThresholdSeconds));
+      new net::CookieMonster(kLastAccessThresholdMilliseconds));
 
   EXPECT_TRUE(cm->SetCookie(url_google, "A=B"));
   const Time last_access_date(GetFirstCookieAccessDate(cm));
 
   // Reading the cookie again immediately shouldn't update the access date,
   // since we're inside the threshold.
   EXPECT_EQ("A=B", cm->GetCookies(url_google));
   EXPECT_TRUE(last_access_date == GetFirstCookieAccessDate(cm));
 
   // Reading after a short wait should update the access date.
-  PlatformThread::Sleep(1500);
+  PlatformThread::Sleep(kLastAccessThresholdMilliseconds + 10);

[Peter Kasting, 2009/10/28 20:43:42]

For safety due to Windows' low timer resolution, I'd make this "+ 20" rather
than "+ 10".  (2 places)

   EXPECT_EQ("A=B", cm->GetCookies(url_google));
   EXPECT_FALSE(last_access_date == GetFirstCookieAccessDate(cm));
 }
 
 static int CountInString(const std::string& str, char c) {
   int count = 0;
   for (std::string::const_iterator it = str.begin();
        it != str.end(); ++it) {
     if (*it == c)
       ++count;
@@ skipping 11 matching lines @@
     std::string cookies = cm->GetCookies(url_google);
     // Make sure we find it in the cookies.
     EXPECT_TRUE(cookies.find(cookie) != std::string::npos);
     // Count the number of cookies.
     EXPECT_LE(CountInString(cookies, '='), 70);
   }
 }
 
 TEST(CookieMonsterTest, TestTotalGarbageCollection) {
   scoped_refptr<net::CookieMonster> cm(
-      new net::CookieMonster(kLastAccessThresholdSeconds));
+      new net::CookieMonster(kLastAccessThresholdMilliseconds));
 
   // Add a bunch of cookies on a bunch of host, some should get purged.
   const GURL sticky_cookie("http://a0000.izzle");
   for (int i = 0; i < 4000; ++i) {
     GURL url(StringPrintf("http://a%04d.izzle", i));
     EXPECT_TRUE(cm->SetCookie(url, "a=b"));
     EXPECT_EQ("a=b", cm->GetCookies(url));
 
     // Keep touching the first cookie to ensure it's not purged (since it will
     // always have the most recent access time).
     if (!(i % 500)) {
-      PlatformThread::Sleep(1500);  // Ensure the timestamps will be different
-                                    // enough to update.
+      // Ensure the timestamps will be different enough to update.
+      PlatformThread::Sleep(kLastAccessThresholdMilliseconds + 10);
       EXPECT_EQ("a=b", cm->GetCookies(sticky_cookie));
     }
   }
 
   // Check that cookies that still exist.
   for (int i = 0; i < 4000; ++i) {
     GURL url(StringPrintf("http://a%04d.izzle", i));
     if ((i == 0) || (i > 1001)) {
       // Cookies should still be around.
       EXPECT_FALSE(cm->GetCookies(url).empty());
@@ skipping 63 matching lines @@
   GURL foo_url("foo://host/path");
   GURL http_url("http://host/path");
 
   EXPECT_TRUE(cm->SetCookie(http_url, "x=1"));
   EXPECT_FALSE(cm->SetCookie(foo_url, "x=1"));
   EXPECT_TRUE(cm_foo->SetCookie(foo_url, "x=1"));
   EXPECT_FALSE(cm_foo->SetCookie(http_url, "x=1"));
 }
 
 // TODO test overwrite cookie