Move CanonicalCookie into separate files

net/cookies/cookie_monster_unittest.cc

 // Copyright (c) 2012 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 "net/cookies/cookie_store_unittest.h"
 
-#include <time.h>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/stringprintf.h"
 #include "base/string_tokenizer.h"
 #include "base/threading/thread.h"
 #include "base/time.h"
 #include "googleurl/src/gurl.h"
+#include "net/cookies/canonical_cookie.h"
 #include "net/cookies/cookie_monster.h"
 #include "net/cookies/cookie_monster_store_test.h"  // For CookieStore mock
 #include "net/cookies/cookie_util.h"
 #include "net/cookies/parsed_cookie.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 using base::Time;
 using base::TimeDelta;
 
 namespace {
 
 // TODO(erikwright): Replace the pre-existing MockPersistentCookieStore (and
 // brethren) with this one, and remove the 'New' prefix.
 class NewMockPersistentCookieStore
     : public CookieMonster::PersistentCookieStore {
  public:
   MOCK_METHOD1(Load, void(const LoadedCallback& loaded_callback));
   MOCK_METHOD2(LoadCookiesForKey, void(const std::string& key,
                                        const LoadedCallback& loaded_callback));
-  MOCK_METHOD1(AddCookie, void(const CookieMonster::CanonicalCookie& cc));
-  MOCK_METHOD1(UpdateCookieAccessTime,
-               void(const CookieMonster::CanonicalCookie& cc));
-  MOCK_METHOD1(DeleteCookie, void(const CookieMonster::CanonicalCookie& cc));
+  MOCK_METHOD1(AddCookie, void(const CanonicalCookie& cc));
+  MOCK_METHOD1(UpdateCookieAccessTime, void(const CanonicalCookie& cc));
+  MOCK_METHOD1(DeleteCookie, void(const CanonicalCookie& cc));
   MOCK_METHOD1(Flush, void(const base::Closure& callback));
   MOCK_METHOD0(SetForceKeepSessionState, void());
 
  private:
   virtual ~NewMockPersistentCookieStore() {}
 };
 
 const char* kTopLevelDomainPlus1 = "http://www.harvard.edu";
 const char* kTopLevelDomainPlus2 = "http://www.math.harvard.edu";
 const char* kTopLevelDomainPlus2Secure = "https://www.math.harvard.edu";
@@ skipping 126 matching lines @@
                        const GURL& url) {
     DCHECK(cm);
     DeleteCallback callback;
     cm->DeleteAllForHostAsync(
         url, base::Bind(&DeleteCallback::Run, base::Unretained(&callback)));
     RunFor(kTimeout);
     EXPECT_TRUE(callback.did_run());
     return callback.num_deleted();
   }
 
-  bool DeleteCanonicalCookie(CookieMonster*cm,
-                             const CookieMonster::CanonicalCookie& cookie) {
+  bool DeleteCanonicalCookie(CookieMonster*cm, const CanonicalCookie& cookie) {
     DCHECK(cm);
     SetCookieCallback callback;
     cm->DeleteCanonicalCookieAsync(
         cookie,
         base::Bind(&SetCookieCallback::Run, base::Unretained(&callback)));
     RunFor(kTimeout);
     EXPECT_TRUE(callback.did_run());
     return callback.result();
   }
 
@@ skipping 374 matching lines @@
   MOCK_METHOD0(Begin, void(void));
 
   // Returns the CookieMonster instance under test.
   CookieMonster& cookie_monster() { return *cookie_monster_; }
 
  private:
   // Declares that mock expectations in this test suite are strictly ordered.
   testing::InSequence in_sequence_;
   // Holds cookies to be returned from PersistentCookieStore::Load or
   // PersistentCookieStore::LoadCookiesForKey.
-  std::vector<CookieMonster::CanonicalCookie*> loaded_cookies_;
+  std::vector<CanonicalCookie*> loaded_cookies_;
   // Stores the callback passed from the CookieMonster to the
   // PersistentCookieStore::Load
   CookieMonster::PersistentCookieStore::LoadedCallback loaded_callback_;
   // Stores the callback passed from the CookieMonster to the
   // PersistentCookieStore::LoadCookiesForKey
   std::queue<CookieMonster::PersistentCookieStore::LoadedCallback>
     loaded_for_key_callbacks_;
 
   // Stores the CookieMonster under test.
   scoped_refptr<CookieMonster> cookie_monster_;
@@ skipping 202 matching lines @@
   EXPECT_CALL(delete_callback, Invoke(false)).WillOnce(
       DeleteAllForHostAction(
           &cookie_monster(), url_google_, &delete_callback));
   EXPECT_CALL(delete_callback, Invoke(false)).WillOnce(
       QuitCurrentMessageLoop());
 
   CompleteLoadingAndWait();
 }
 
 TEST_F(DeferredCookieTaskTest, DeferredDeleteCanonicalCookie) {
-  std::vector<CookieMonster::CanonicalCookie*> cookies;
-  CookieMonster::CanonicalCookie cookie = BuildCanonicalCookie(
+  std::vector<CanonicalCookie*> cookies;
+  CanonicalCookie cookie = BuildCanonicalCookie(
       "www.google.com", "X=1; path=/", base::Time::Now());
 
   MockDeleteCookieCallback delete_cookie_callback;
 
   BeginWith(DeleteCanonicalCookieAction(
       &cookie_monster(), cookie, &delete_cookie_callback));
 
   WaitForLoadCall();
 
   EXPECT_CALL(delete_cookie_callback, Invoke(false)).WillOnce(
@@ skipping 50 matching lines @@
       GetCookiesWithInfoAction(
           &cookie_monster(), url_google_, &get_cookie_info_callback));
   EXPECT_CALL(get_cookie_info_callback, Invoke("X=1", testing::_)).WillOnce(
       QuitCurrentMessageLoop());
   EXPECT_CALL(set_cookies_callback, Invoke(true));
   EXPECT_CALL(delete_cookie_callback, Invoke());
 
   CompleteLoadingAndWait();
 }
 
-TEST_F(CookieMonsterTest, TestCookieDateParsing) {
-  const struct {
-    const char* str;
-    const bool valid;
-    const time_t epoch;
-  } tests[] = {
-    { "Sat, 15-Apr-17 21:01:22 GMT",           true, 1492290082 },
-    { "Thu, 19-Apr-2007 16:00:00 GMT",         true, 1176998400 },
-    { "Wed, 25 Apr 2007 21:02:13 GMT",         true, 1177534933 },
-    { "Thu, 19/Apr\\2007 16:00:00 GMT",        true, 1176998400 },
-    { "Fri, 1 Jan 2010 01:01:50 GMT",          true, 1262307710 },
-    { "Wednesday, 1-Jan-2003 00:00:00 GMT",    true, 1041379200 },
-    { ", 1-Jan-2003 00:00:00 GMT",             true, 1041379200 },
-    { " 1-Jan-2003 00:00:00 GMT",              true, 1041379200 },
-    { "1-Jan-2003 00:00:00 GMT",               true, 1041379200 },
-    { "Wed,18-Apr-07 22:50:12 GMT",            true, 1176936612 },
-    { "WillyWonka  , 18-Apr-07 22:50:12 GMT",  true, 1176936612 },
-    { "WillyWonka  , 18-Apr-07 22:50:12",      true, 1176936612 },
-    { "WillyWonka  ,  18-apr-07   22:50:12",   true, 1176936612 },
-    { "Mon, 18-Apr-1977 22:50:13 GMT",         true, 230251813 },
-    { "Mon, 18-Apr-77 22:50:13 GMT",           true, 230251813 },
-    // If the cookie came in with the expiration quoted (which in terms of
-    // the RFC you shouldn't do), we will get string quoted.  Bug 1261605.
-    { "\"Sat, 15-Apr-17\\\"21:01:22\\\"GMT\"", true, 1492290082 },
-    // Test with full month names and partial names.
-    { "Partyday, 18- April-07 22:50:12",       true, 1176936612 },
-    { "Partyday, 18 - Apri-07 22:50:12",       true, 1176936612 },
-    { "Wednes, 1-Januar-2003 00:00:00 GMT",    true, 1041379200 },
-    // Test that we always take GMT even with other time zones or bogus
-    // values.  The RFC says everything should be GMT, and in the worst case
-    // we are 24 hours off because of zone issues.
-    { "Sat, 15-Apr-17 21:01:22",               true, 1492290082 },
-    { "Sat, 15-Apr-17 21:01:22 GMT-2",         true, 1492290082 },
-    { "Sat, 15-Apr-17 21:01:22 GMT BLAH",      true, 1492290082 },
-    { "Sat, 15-Apr-17 21:01:22 GMT-0400",      true, 1492290082 },
-    { "Sat, 15-Apr-17 21:01:22 GMT-0400 (EDT)",true, 1492290082 },
-    { "Sat, 15-Apr-17 21:01:22 DST",           true, 1492290082 },
-    { "Sat, 15-Apr-17 21:01:22 -0400",         true, 1492290082 },
-    { "Sat, 15-Apr-17 21:01:22 (hello there)", true, 1492290082 },
-    // Test that if we encounter multiple : fields, that we take the first
-    // that correctly parses.
-    { "Sat, 15-Apr-17 21:01:22 11:22:33",      true, 1492290082 },
-    { "Sat, 15-Apr-17 ::00 21:01:22",          true, 1492290082 },
-    { "Sat, 15-Apr-17 boink:z 21:01:22",       true, 1492290082 },
-    // We take the first, which in this case is invalid.
-    { "Sat, 15-Apr-17 91:22:33 21:01:22",      false, 0 },
-    // amazon.com formats their cookie expiration like this.
-    { "Thu Apr 18 22:50:12 2007 GMT",          true, 1176936612 },
-    // Test that hh:mm:ss can occur anywhere.
-    { "22:50:12 Thu Apr 18 2007 GMT",          true, 1176936612 },
-    { "Thu 22:50:12 Apr 18 2007 GMT",          true, 1176936612 },
-    { "Thu Apr 22:50:12 18 2007 GMT",          true, 1176936612 },
-    { "Thu Apr 18 22:50:12 2007 GMT",          true, 1176936612 },
-    { "Thu Apr 18 2007 22:50:12 GMT",          true, 1176936612 },
-    { "Thu Apr 18 2007 GMT 22:50:12",          true, 1176936612 },
-    // Test that the day and year can be anywhere if they are unambigious.
-    { "Sat, 15-Apr-17 21:01:22 GMT",           true, 1492290082 },
-    { "15-Sat, Apr-17 21:01:22 GMT",           true, 1492290082 },
-    { "15-Sat, Apr 21:01:22 GMT 17",           true, 1492290082 },
-    { "15-Sat, Apr 21:01:22 GMT 2017",         true, 1492290082 },
-    { "15 Apr 21:01:22 2017",                  true, 1492290082 },
-    { "15 17 Apr 21:01:22",                    true, 1492290082 },
-    { "Apr 15 17 21:01:22",                    true, 1492290082 },
-    { "Apr 15 21:01:22 17",                    true, 1492290082 },
-    { "2017 April 15 21:01:22",                true, 1492290082 },
-    { "15 April 2017 21:01:22",                true, 1492290082 },
-    // Some invalid dates
-    { "98 April 17 21:01:22",                    false, 0 },
-    { "Thu, 012-Aug-2008 20:49:07 GMT",          false, 0 },
-    { "Thu, 12-Aug-31841 20:49:07 GMT",          false, 0 },
-    { "Thu, 12-Aug-9999999999 20:49:07 GMT",     false, 0 },
-    { "Thu, 999999999999-Aug-2007 20:49:07 GMT", false, 0 },
-    { "Thu, 12-Aug-2007 20:61:99999999999 GMT",  false, 0 },
-    { "IAintNoDateFool",                         false, 0 },
-  };
-
-  Time parsed_time;
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
-    parsed_time = CookieMonster::ParseCookieTime(tests[i].str);
-    if (!tests[i].valid) {
-      EXPECT_FALSE(!parsed_time.is_null()) << tests[i].str;
-      continue;
-    }
-    EXPECT_TRUE(!parsed_time.is_null()) << tests[i].str;
-    EXPECT_EQ(tests[i].epoch, parsed_time.ToTimeT()) << tests[i].str;
-  }
-}
-
 TEST_F(CookieMonsterTest, TestCookieDeleteAll) {
   scoped_refptr<MockPersistentCookieStore> store(
       new MockPersistentCookieStore);
   scoped_refptr<CookieMonster> cm(new CookieMonster(store, NULL));
   CookieOptions options;
   options.set_include_httponly();
 
   EXPECT_TRUE(SetCookie(cm, url_google_, kValidCookieLine));
   EXPECT_EQ("A=B", GetCookies(cm, url_google_));
 
@@ skipping 288 matching lines @@
 // This is a regression test for: http://crbug.com/17855.
 TEST_F(CookieMonsterTest, DontImportDuplicateCookies) {
   scoped_refptr<MockPersistentCookieStore> store(
       new MockPersistentCookieStore);
 
   // We will fill some initial cookies into the PersistentCookieStore,
   // to simulate a database with 4 duplicates.  Note that we need to
   // be careful not to have any duplicate creation times at all (as it's a
   // violation of a CookieMonster invariant) even if Time::Now() doesn't
   // move between calls.
-  std::vector<CookieMonster::CanonicalCookie*> initial_cookies;
+  std::vector<CanonicalCookie*> initial_cookies;
 
   // Insert 4 cookies with name "X" on path "/", with varying creation
   // dates. We expect only the most recent one to be preserved following
   // the import.
 
   AddCookieToList("www.google.com",
                   "X=1; path=/; expires=Mon, 18-Apr-22 22:50:14 GMT",
                   Time::Now() + TimeDelta::FromDays(3),
                   &initial_cookies);
 
@@ skipping 64 matching lines @@
   scoped_refptr<MockPersistentCookieStore> store(
       new MockPersistentCookieStore);
 
   Time now(Time::Now());
   Time earlier(now - TimeDelta::FromDays(1));
 
   // Insert 8 cookies, four with the current time as creation times, and
   // four with the earlier time as creation times.  We should only get
   // two cookies remaining, but which two (other than that there should
   // be one from each set) will be random.
-  std::vector<CookieMonster::CanonicalCookie*> initial_cookies;
+  std::vector<CanonicalCookie*> initial_cookies;
   AddCookieToList("www.google.com", "X=1; path=/", now, &initial_cookies);
   AddCookieToList("www.google.com", "X=2; path=/", now, &initial_cookies);
   AddCookieToList("www.google.com", "X=3; path=/", now, &initial_cookies);
   AddCookieToList("www.google.com", "X=4; path=/", now, &initial_cookies);
 
   AddCookieToList("www.google.com", "Y=1; path=/", earlier, &initial_cookies);
   AddCookieToList("www.google.com", "Y=2; path=/", earlier, &initial_cookies);
   AddCookieToList("www.google.com", "Y=3; path=/", earlier, &initial_cookies);
   AddCookieToList("www.google.com", "Y=4; path=/", earlier, &initial_cookies);
 
@@ skipping 245 matching lines @@
 
   SetCookieWithDetails(cm, url_google_, "setCookieWithDetails1", "A",
                        ".google.com", "/", Time(), false, false);
   SetCookieWithDetails(cm, url_google_, "setCookieWithDetails2", "A",
                        ".google.com", "/", Time(), false, false);
   SetCookieWithDetails(cm, url_google_, "setCookieWithDetails3", "A",
                        ".google.com", "/", Time(), false, false);
 
   // Now we check
   CookieList cookie_list(GetAllCookies(cm));
-  typedef std::map<int64, CookieMonster::CanonicalCookie> TimeCookieMap;
+  typedef std::map<int64, CanonicalCookie> TimeCookieMap;
   TimeCookieMap check_map;
   for (CookieList::const_iterator it = cookie_list.begin();
        it != cookie_list.end(); it++) {
     const int64 creation_date = it->CreationDate().ToInternalValue();
     TimeCookieMap::const_iterator
         existing_cookie_it(check_map.find(creation_date));
     EXPECT_TRUE(existing_cookie_it == check_map.end())
         << "Cookie " << it->Name() << " has same creation date ("
         << it->CreationDate().ToInternalValue()
         << ") as previously entered cookie "
@@ skipping 79 matching lines @@
   {
     scoped_refptr<CookieMonster> cmin(new CookieMonster(store, NULL));
     CookieList cookies(GetAllCookies(cmin));
     ASSERT_EQ(2u, cookies.size());
     // Ordering is path length, then creation time.  So second cookie
     // will come first, and we need to swap them.
     std::swap(cookies[0], cookies[1]);
     for (int output_index = 0; output_index < 2; output_index++) {
       int input_index = output_index * 2;
       const CookiesInputInfo* input = &input_info[input_index];
-      const CookieMonster::CanonicalCookie* output = &cookies[output_index];
+      const CanonicalCookie* output = &cookies[output_index];
 
       EXPECT_EQ(input->name, output->Name());
       EXPECT_EQ(input->value, output->Value());
       EXPECT_EQ(GURL(input->gurl).host(), output->Domain());
       EXPECT_EQ(input->path, output->Path());
       EXPECT_LE(current.ToInternalValue(),
                 output->CreationDate().ToInternalValue());
       EXPECT_EQ(input->secure, output->IsSecure());
       EXPECT_EQ(input->http_only, output->IsHttpOnly());
       EXPECT_TRUE(output->IsPersistent());
@@ skipping 154 matching lines @@
 }
 
 namespace {
 
 // Mock PersistentCookieStore that keeps track of the number of Flush() calls.
 class FlushablePersistentStore : public CookieMonster::PersistentCookieStore {
  public:
   FlushablePersistentStore() : flush_count_(0) {}
 
   void Load(const LoadedCallback& loaded_callback) {
-    std::vector<CookieMonster::CanonicalCookie*> out_cookies;
+    std::vector<CanonicalCookie*> out_cookies;
     MessageLoop::current()->PostTask(FROM_HERE,
       base::Bind(&net::LoadedCallbackTask::Run,
                  new net::LoadedCallbackTask(loaded_callback, out_cookies)));
   }
 
   void LoadCookiesForKey(const std::string& key,
       const LoadedCallback& loaded_callback) {
     Load(loaded_callback);
   }
 
-  void AddCookie(const CookieMonster::CanonicalCookie&) {}
-  void UpdateCookieAccessTime(const CookieMonster::CanonicalCookie&) {}
-  void DeleteCookie(const CookieMonster::CanonicalCookie&) {}
+  void AddCookie(const CanonicalCookie&) {}
+  void UpdateCookieAccessTime(const CanonicalCookie&) {}
+  void DeleteCookie(const CanonicalCookie&) {}
   void SetForceKeepSessionState() {}
 
   void Flush(const base::Closure& callback) {
     ++flush_count_;
     if (!callback.is_null())
       callback.Run();
   }
 
   int flush_count() {
     return flush_count_;
@@ skipping 72 matching lines @@
   MessageLoop::current()->RunAllPending();
 
   ASSERT_EQ(2, counter->callback_count());
 
   cm->FlushStore(base::Bind(&CallbackCounter::Callback, counter.get()));
   MessageLoop::current()->RunAllPending();
 
   ASSERT_EQ(3, counter->callback_count());
 }
 
-TEST_F(CookieMonsterTest, GetCookieSourceFromURL) {
-  EXPECT_EQ("http://example.com/",
-            CookieMonster::CanonicalCookie::GetCookieSourceFromURL(
-                GURL("http://example.com")));
-  EXPECT_EQ("http://example.com/",
-            CookieMonster::CanonicalCookie::GetCookieSourceFromURL(
-                GURL("http://example.com/")));
-  EXPECT_EQ("http://example.com/",
-            CookieMonster::CanonicalCookie::GetCookieSourceFromURL(
-                GURL("http://example.com/test")));
-  EXPECT_EQ("file:///tmp/test.html",
-            CookieMonster::CanonicalCookie::GetCookieSourceFromURL(
-                GURL("file:///tmp/test.html")));
-  EXPECT_EQ("http://example.com/",
-            CookieMonster::CanonicalCookie::GetCookieSourceFromURL(
-                GURL("http://example.com:1234/")));
-  EXPECT_EQ("http://example.com/",
-            CookieMonster::CanonicalCookie::GetCookieSourceFromURL(
-                GURL("https://example.com/")));
-  EXPECT_EQ("http://example.com/",
-            CookieMonster::CanonicalCookie::GetCookieSourceFromURL(
-                GURL("http://user:pwd@example.com/")));
-  EXPECT_EQ("http://example.com/",
-            CookieMonster::CanonicalCookie::GetCookieSourceFromURL(
-                GURL("http://example.com/test?foo")));
-  EXPECT_EQ("http://example.com/",
-            CookieMonster::CanonicalCookie::GetCookieSourceFromURL(
-                GURL("http://example.com/test#foo")));
-}
-
 TEST_F(CookieMonsterTest, HistogramCheck) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
   // Should match call in InitializeHistograms, but doesn't really matter
   // since the histogram should have been initialized by the CM construction
   // above.
   base::Histogram* expired_histogram =
       base::Histogram::FactoryGet(
           "Cookie.ExpirationDurationMinutes", 1, 10 * 365 * 24 * 60, 50,
           base::Histogram::kUmaTargetedHistogramFlag);
 
@@ skipping 76 matching lines @@
 
   void DeleteAllForHostTask(CookieMonster* cm,
                             const GURL& url,
                             DeleteCallback* callback) {
     cm->DeleteAllForHostAsync(
         url,
         base::Bind(&DeleteCallback::Run, base::Unretained(callback)));
   }
 
   void DeleteCanonicalCookieTask(CookieMonster* cm,
-                                 const CookieMonster::CanonicalCookie& cookie,
+                                 const CanonicalCookie& cookie,
                                  SetCookieCallback* callback) {
     cm->DeleteCanonicalCookieAsync(
         cookie,
         base::Bind(&SetCookieCallback::Run, base::Unretained(callback)));
   }
 
  protected:
   void RunOnOtherThread(const base::Closure& task) {
     other_thread_.Start();
     other_thread_.message_loop()->PostTask(FROM_HERE, task);
@@ skipping 145 matching lines @@
       &net::MultiThreadedCookieMonsterTest::DeleteCanonicalCookieTask,
       base::Unretained(this),
       cm, *it, &callback);
   RunOnOtherThread(task);
   EXPECT_TRUE(callback.did_run());
   EXPECT_TRUE(callback.result());
 }
 
 TEST_F(CookieMonsterTest, InvalidExpiryTime) {
   ParsedCookie pc(std::string(kValidCookieLine) + "; expires=Blarg arg arg");
-  scoped_ptr<CookieMonster::CanonicalCookie> cookie(
-      CookieMonster::CanonicalCookie::Create(url_google_, pc));
+  scoped_ptr<CanonicalCookie> cookie(CanonicalCookie::Create(url_google_, pc));
 
   ASSERT_FALSE(cookie->IsPersistent());
 }
 
 // Test that CookieMonster writes session cookies into the underlying
 // CookieStore if the "persist session cookies" option is on.
 TEST_F(CookieMonsterTest, PersistSessionCookies) {
   scoped_refptr<MockPersistentCookieStore> store(
       new MockPersistentCookieStore);
   scoped_refptr<CookieMonster> cm(new CookieMonster(store, NULL));
@@ skipping 62 matching lines @@
   EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[4].type);
 
   // Create some non-persistent cookies and check that they don't go to the
   // persistent storage.
   EXPECT_TRUE(SetCookie(cm, url_google_, "B=Bar"));
   this->MatchCookieLines("A=Foo; B=Bar", GetCookies(cm, url_google_));
   EXPECT_EQ(5u, store->commands().size());
 }
 
 }  // namespace net