Adding Priority field to cookies.

content/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 "content/browser/net/sqlite_persistent_cookie_store.h"
 
 #include <map>
 #include <set>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop.h"
 #include "base/sequenced_task_runner.h"
 #include "base/stl_util.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/sequenced_worker_pool_owner.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/time.h"
 #include "googleurl/src/gurl.h"
 #include "net/cookies/canonical_cookie.h"
+#include "net/cookies/cookie_constants.h"
 #include "sql/connection.h"
 #include "sql/meta_table.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
 
 namespace {
 
 const base::FilePath::CharType kCookieFilename[] = FILE_PATH_LITERAL("Cookies");
 
@@ skipping 79 matching lines @@
   }
 
   // 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(
         net::CanonicalCookie(GURL(), name, value, domain, path, creation,
-                             creation, creation, false, false));
+                             creation, creation, false, false,
+                             net::COOKIE_PRIORITY_DEFAULT));
   }
 
   virtual void SetUp() OVERRIDE {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
   }
 
   virtual void TearDown() OVERRIDE {
     DestroyStore();
     pool_owner_->pool()->Shutdown();
   }
@@ skipping 173 matching lines @@
 }
 
 // Test loading old session cookies from the disk.
 TEST_F(SQLitePersistentCookieStoreTest, TestLoadOldSessionCookies) {
   InitializeStore(true);
 
   // Add a session cookie.
   store_->AddCookie(
       net::CanonicalCookie(
           GURL(), "C", "D", "sessioncookie.com", "/", base::Time::Now(),
-          base::Time(), base::Time::Now(), false, false));
+          base::Time(), base::Time::Now(), false, false,
+          net::COOKIE_PRIORITY_DEFAULT));
 
   // 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(
       net::CanonicalCookie(
           GURL(), "C", "D", "sessioncookie.com", "/", base::Time::Now(),
-          base::Time(), base::Time::Now(), false, false));
+          base::Time(), base::Time::Now(), false, false,
+          net::COOKIE_PRIORITY_DEFAULT));
 
   // 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;
   CreateAndLoad(false, &cookies);
   ASSERT_EQ(0U, cookies.size());
 
   // The store should also delete the session cookie. Wait until that has been
   // done.
   DestroyStore();
 
   // Create a store that loads old session cookies and test that the session
   // cookie is gone.
   CreateAndLoad(true, &cookies);
   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(
       net::CanonicalCookie(
           GURL(), kSessionName, "val", "sessioncookie.com", "/",
-          base::Time::Now(), base::Time(), base::Time::Now(), false, false));
+          base::Time::Now(), base::Time(), base::Time::Now(), false, false,
+          net::COOKIE_PRIORITY_DEFAULT));
   // Add a persistent cookie.
   store_->AddCookie(
       net::CanonicalCookie(
           GURL(), kPersistentName, "val", "sessioncookie.com", "/",
           base::Time::Now() - base::TimeDelta::FromDays(1), base::Time::Now(),
-          base::Time::Now(), false, false));
+          base::Time::Now(), false, false,
+          net::COOKIE_PRIORITY_DEFAULT));
 
   // 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, net::CanonicalCookie*> cookie_map;
   for (CanonicalCookieVector::const_iterator it = cookies.begin();
        it != cookies.end();
        ++it) {
     cookie_map[(*it)->Name()] = *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);
 }
 
 }  // namespace content