Move CanonicalCookie into separate files

chrome/browser/net/sqlite_persistent_cookie_store_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 <map>
 #include <set>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/file_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop.h"
 #include "base/scoped_temp_dir.h"
 #include "base/stl_util.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/thread_test_helper.h"
 #include "base/time.h"
 #include "chrome/browser/net/clear_on_exit_policy.h"
 #include "chrome/browser/net/sqlite_persistent_cookie_store.h"
 #include "chrome/common/chrome_constants.h"
 #include "content/public/test/test_browser_thread.h"
 #include "googleurl/src/gurl.h"
+#include "net/cookies/canonical_cookie.h"
 #include "sql/connection.h"
 #include "sql/meta_table.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/quota/mock_special_storage_policy.h"
 
 using content::BrowserThread;
-using net::CookieMonster;
 
-typedef std::vector<CookieMonster::CanonicalCookie*> CanonicalCookieVector;
+typedef std::vector<net::CanonicalCookie*> CanonicalCookieVector;
 
 class SQLitePersistentCookieStoreTest : public testing::Test {
  public:
   SQLitePersistentCookieStoreTest()
       : ui_thread_(BrowserThread::UI),
         db_thread_(BrowserThread::DB),
         io_thread_(BrowserThread::IO),
         loaded_event_(false, false),
         key_loaded_event_(false, false),
         db_thread_event_(false, false) {
@@ skipping 47 matching lines @@
     db_thread_event_.Wait();
   }
 
   // Adds a persistent cookie to store_.
   void AddCookie(const std::string& name,
                  const std::string& value,
                  const std::string& domain,
                  const std::string& path,
                  const base::Time& creation) {
     store_->AddCookie(
-        CookieMonster::CanonicalCookie(GURL(), name, value, domain, path,
-                                       std::string(), std::string(),
-                                       creation, creation, creation,
-                                       false, false));
+        net::CanonicalCookie(GURL(), name, value, domain, path, std::string(),
+                             std::string(), creation, creation, creation, false,
+                             false));
   }
 
   virtual void SetUp() {
     ui_thread_.Start();
     db_thread_.Start();
     io_thread_.Start();
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
   }
 
  protected:
@@ skipping 213 matching lines @@
 
   ASSERT_EQ(1, counter->callback_count());
 }
 
 // Test loading old session cookies from the disk.
 TEST_F(SQLitePersistentCookieStoreTest, TestLoadOldSessionCookies) {
   InitializeStore(true);
 
   // Add a session cookie.
   store_->AddCookie(
-      CookieMonster::CanonicalCookie(
+      net::CanonicalCookie(
           GURL(), "C", "D", "sessioncookie.com", "/", std::string(),
           std::string(), base::Time::Now(), base::Time(),
           base::Time::Now(), false, false));
 
   // Force the store to write its data to the disk.
   DestroyStore();
 
   // Create a store that loads session cookies and test that the session cookie
   // was loaded.
   CanonicalCookieVector cookies;
   CreateAndLoad(true, &cookies);
 
   ASSERT_EQ(1U, cookies.size());
   ASSERT_STREQ("sessioncookie.com", cookies[0]->Domain().c_str());
   ASSERT_STREQ("C", cookies[0]->Name().c_str());
   ASSERT_STREQ("D", cookies[0]->Value().c_str());
 
   STLDeleteElements(&cookies);
 }
 
 // Test loading old session cookies from the disk.
 TEST_F(SQLitePersistentCookieStoreTest, TestDontLoadOldSessionCookies) {
   InitializeStore(true);
 
   // Add a session cookie.
   store_->AddCookie(
-      CookieMonster::CanonicalCookie(
+      net::CanonicalCookie(
           GURL(), "C", "D", "sessioncookie.com", "/", std::string(),
           std::string(), base::Time::Now(), base::Time(),
           base::Time::Now(), false, false));
 
   // Force the store to write its data to the disk.
   DestroyStore();
 
   // Create a store that doesn't load old session cookies and test that the
   // session cookie was not loaded.
   CanonicalCookieVector cookies;
@@ skipping 10 matching lines @@
   ASSERT_EQ(0U, cookies.size());
 }
 
 TEST_F(SQLitePersistentCookieStoreTest, PersistIsPersistent) {
   InitializeStore(true);
   static const char kSessionName[] = "session";
   static const char kPersistentName[] = "persistent";
 
   // Add a session cookie.
   store_->AddCookie(
-      CookieMonster::CanonicalCookie(
+      net::CanonicalCookie(
           GURL(), kSessionName, "val", "sessioncookie.com", "/",
           std::string(), std::string(),
           base::Time::Now(), base::Time(), base::Time::Now(),
           false, false));
   // Add a persistent cookie.
   store_->AddCookie(
-      CookieMonster::CanonicalCookie(
+      net::CanonicalCookie(
           GURL(), kPersistentName, "val", "sessioncookie.com", "/",
           std::string(), std::string(),
           base::Time::Now() - base::TimeDelta::FromDays(1), base::Time::Now(),
           base::Time::Now(), false, false));
 
   // Create a store that loads session cookie and test that the the IsPersistent
   // attribute is restored.
   CanonicalCookieVector cookies;
   CreateAndLoad(true, &cookies);
   ASSERT_EQ(2U, cookies.size());
 
-  std::map<std::string, CookieMonster::CanonicalCookie*> cookie_map;
+  std::map<std::string, net::CanonicalCookie*> cookie_map;
   for (CanonicalCookieVector::const_iterator it = cookies.begin();
        it != cookies.end();
        ++it) {
     cookie_map[(*it)->Name()] = *it;
   }
 
-  std::map<std::string, CookieMonster::CanonicalCookie*>::const_iterator it =
+  std::map<std::string, net::CanonicalCookie*>::const_iterator it =
       cookie_map.find(kSessionName);
   ASSERT_TRUE(it != cookie_map.end());
   EXPECT_FALSE(cookie_map[kSessionName]->IsPersistent());
 
   it = cookie_map.find(kPersistentName);
   ASSERT_TRUE(it != cookie_map.end());
   EXPECT_TRUE(cookie_map[kPersistentName]->IsPersistent());
 
   STLDeleteElements(&cookies);
 }
@@ skipping 44 matching lines @@
   // Add some cookies.
   base::Time t = base::Time::Now();
   AddCookie("A", "1", protected_origin, "/", t);
   t += base::TimeDelta::FromInternalValue(10);
   AddCookie("B", "2", session_origin, "/", t);
   t += base::TimeDelta::FromInternalValue(10);
   AddCookie("C", "3", other_origin, "/", t);
   // A secure cookie on session_origin.
   t += base::TimeDelta::FromInternalValue(10);
   store_->AddCookie(
-      CookieMonster::CanonicalCookie(GURL(), "D", "4", session_origin, "/",
-                                     std::string(), std::string(),
-                                     t, t, t,
-                                     true, false));
+      net::CanonicalCookie(GURL(), "D", "4", session_origin, "/", std::string(),
+                           std::string(), t, t, t, true, false));
 
   // First, check that we can override the policy.
   store_->SetForceKeepSessionState();
 
   // Force the store to write its data to the disk.
   DestroyStore();
 
   // Create a store test that the cookie on session_origin does not exist.
   store_ = new SQLitePersistentCookieStore(
       temp_dir_.path().Append(chrome::kCookieFilename),
@@ skipping 19 matching lines @@
   Load(&cookies);
 
   EXPECT_EQ(3U, cookies.size());
   EXPECT_TRUE(IsCookiePresent(cookies, protected_origin, "A", "1", false));
   EXPECT_TRUE(IsCookiePresent(cookies, other_origin, "C", "3", false));
   EXPECT_TRUE(IsCookiePresent(cookies, session_origin, "D", "4", true));
 
   DestroyStore();
   STLDeleteElements(&cookies);
 }