Adding Priority field to cookies.

net/cookies/canonical_cookie_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.

[erikwright (departed), 2013/04/15 19:00:37]

Add tests that the cookie stores and returns the provided priority. Also add
tests that verify that the priority does not affect equivalence.

[huangs, 2013/04/15 21:29:40]

Done.

 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/cookies/canonical_cookie.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "googleurl/src/gurl.h"
+#include "net/cookies/cookie_constants.h"
 #include "net/cookies/cookie_options.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 TEST(CanonicalCookieTest, GetCookieSourceFromURL) {
   EXPECT_EQ("http://example.com/",
             CanonicalCookie::GetCookieSourceFromURL(
                 GURL("http://example.com")));
   EXPECT_EQ("http://example.com/",
@@ skipping 20 matching lines @@
   EXPECT_EQ("http://example.com/",
             CanonicalCookie::GetCookieSourceFromURL(
                 GURL("http://example.com/test#foo")));
 }
 
 TEST(CanonicalCookieTest, Constructor) {
   GURL url("http://www.example.com/test");
   base::Time current_time = base::Time::Now();
 
   CanonicalCookie cookie(url, "A", "2", "www.example.com", "/test",
-                         current_time, base::Time(), current_time, false,
-                         false);
+                         current_time, base::Time(), current_time, false, false,
+                         PRIORITY_DEFAULT);
   EXPECT_EQ(url.GetOrigin().spec(), cookie.Source());
   EXPECT_EQ("A", cookie.Name());
   EXPECT_EQ("2", cookie.Value());
   EXPECT_EQ("www.example.com", cookie.Domain());
   EXPECT_EQ("/test", cookie.Path());
   EXPECT_FALSE(cookie.IsSecure());
 
   CanonicalCookie cookie2(url,
                           "A",
                           "2",
                           std::string(),
                           std::string(),
                           current_time,
                           base::Time(),
                           current_time,
                           false,
-                          false);
+                          false,
+                          PRIORITY_DEFAULT);
   EXPECT_EQ(url.GetOrigin().spec(), cookie.Source());
   EXPECT_EQ("A", cookie2.Name());
   EXPECT_EQ("2", cookie2.Value());
   EXPECT_EQ("", cookie2.Domain());
   EXPECT_EQ("", cookie2.Path());
   EXPECT_FALSE(cookie2.IsSecure());
 
 }
 
 TEST(CanonicalCookieTest, Create) {
@@ skipping 35 matching lines @@
   httponly_options.set_include_httponly();
   cookie.reset(
       CanonicalCookie::Create(url, "A=2; HttpOnly", creation_time,
                               httponly_options));
   EXPECT_TRUE(cookie->IsHttpOnly());
 
   // Test the creating cookies using specific parameter instead of a cookie
   // string.
   cookie.reset(CanonicalCookie::Create(
       url, "A", "2", "www.example.com", "/test", creation_time, base::Time(),
-      false, false));
+      false, false, PRIORITY_DEFAULT));
   EXPECT_EQ(url.GetOrigin().spec(), cookie->Source());
   EXPECT_EQ("A", cookie->Name());
   EXPECT_EQ("2", cookie->Value());
   EXPECT_EQ(".www.example.com", cookie->Domain());
   EXPECT_EQ("/test", cookie->Path());
   EXPECT_FALSE(cookie->IsSecure());
 
   cookie.reset(CanonicalCookie::Create(
       url, "A", "2", ".www.example.com", "/test", creation_time, base::Time(),
-      false, false));
+      false, false, PRIORITY_DEFAULT));
   EXPECT_EQ(url.GetOrigin().spec(), cookie->Source());
   EXPECT_EQ("A", cookie->Name());
   EXPECT_EQ("2", cookie->Value());
   EXPECT_EQ(".www.example.com", cookie->Domain());
   EXPECT_EQ("/test", cookie->Path());
   EXPECT_FALSE(cookie->IsSecure());
 }
 
 TEST(CanonicalCookieTest, EmptyExpiry) {
   GURL url("http://www7.ipdl.inpit.go.jp/Tokujitu/tjkta.ipdl?N0000=108");
@@ skipping 37 matching lines @@
   base::Time creation_time = base::Time::Now();
   base::Time last_access_time = creation_time;
   base::Time expiration_time = creation_time + base::TimeDelta::FromDays(2);
   bool secure(false);
   bool httponly(false);
 
   // Test that a cookie is equivalent to itself.
   scoped_ptr<CanonicalCookie> cookie(
       new CanonicalCookie(url, cookie_name, cookie_value, cookie_domain,
                           cookie_path, creation_time, expiration_time,
-                          last_access_time, secure, httponly));
+                          last_access_time, secure, httponly, PRIORITY_MEDIUM));
   EXPECT_TRUE(cookie->IsEquivalent(*cookie));
 
   // Test that two identical cookies are equivalent.
   scoped_ptr<CanonicalCookie> other_cookie(
       new CanonicalCookie(url, cookie_name, cookie_value, cookie_domain,
                           cookie_path, creation_time, expiration_time,
-                          last_access_time, secure, httponly));
+                          last_access_time, secure, httponly, PRIORITY_MEDIUM));
   EXPECT_TRUE(cookie->IsEquivalent(*other_cookie));
 
   // Tests that use different variations of attribute values that
   // DON'T affect cookie equivalence.
   other_cookie.reset(new CanonicalCookie(url, cookie_name, "2", cookie_domain,
                                          cookie_path, creation_time,
                                          expiration_time, last_access_time,
-                                         secure, httponly));
+                                         secure, httponly, PRIORITY_HIGH));
   EXPECT_TRUE(cookie->IsEquivalent(*other_cookie));
 
   base::Time other_creation_time =
       creation_time + base::TimeDelta::FromMinutes(2);
   other_cookie.reset(new CanonicalCookie(url, cookie_name, "2", cookie_domain,
                                          cookie_path, other_creation_time,
                                          expiration_time, last_access_time,
-                                         secure, httponly));
+                                         secure, httponly, PRIORITY_MEDIUM));
   EXPECT_TRUE(cookie->IsEquivalent(*other_cookie));
 
   other_cookie.reset(new CanonicalCookie(url, cookie_name, cookie_name,
                                          cookie_domain, cookie_path,
                                          creation_time, expiration_time,
-                                         last_access_time, true, httponly));
+                                         last_access_time, true, httponly,
+                                         PRIORITY_LOW));
   EXPECT_TRUE(cookie->IsEquivalent(*other_cookie));
 
   // Tests that use different variations of attribute values that
   // DO affect cookie equivalence.
   other_cookie.reset(new CanonicalCookie(url, "B", cookie_value, cookie_domain,
                                          cookie_path, creation_time,
                                          expiration_time, last_access_time,
-                                         secure, httponly));
+                                         secure, httponly, PRIORITY_MEDIUM));
   EXPECT_FALSE(cookie->IsEquivalent(*other_cookie));
 
   other_cookie.reset(new CanonicalCookie(url, cookie_name, cookie_value,
                                          "www.example.com", cookie_path,
                                          creation_time, expiration_time,
-                                         last_access_time, secure, httponly));
+                                         last_access_time, secure, httponly,
+                                         PRIORITY_MEDIUM));
   EXPECT_TRUE(cookie->IsDomainCookie());
   EXPECT_FALSE(other_cookie->IsDomainCookie());
   EXPECT_FALSE(cookie->IsEquivalent(*other_cookie));
 
   other_cookie.reset(new CanonicalCookie(url, cookie_name, cookie_value,
                                          ".example.com", cookie_path,
                                          creation_time, expiration_time,
-                                         last_access_time, secure, httponly));
+                                         last_access_time, secure, httponly,
+                                         PRIORITY_MEDIUM));
   EXPECT_FALSE(cookie->IsEquivalent(*other_cookie));
 
   other_cookie.reset(new CanonicalCookie(url, cookie_name, cookie_value,
                                          cookie_domain, "/test/0",
                                          creation_time, expiration_time,
-                                         last_access_time, secure, httponly));
+                                         last_access_time, secure, httponly,
+                                         PRIORITY_MEDIUM));
   EXPECT_FALSE(cookie->IsEquivalent(*other_cookie));
 }
 
 TEST(CanonicalCookieTest, IsDomainMatch) {
   GURL url("http://www.example.com/test/foo.html");
   base::Time creation_time = base::Time::Now();
   CookieOptions options;
 
   scoped_ptr<CanonicalCookie> cookie(
       CanonicalCookie::Create(url, "A=2", creation_time, options));
@@ skipping 85 matching lines @@
   options.set_include_httponly();
   cookie.reset(
       CanonicalCookie::Create(url, "A=2; HttpOnly", creation_time, options));
   EXPECT_TRUE(cookie->IsHttpOnly());
   EXPECT_TRUE(cookie->IncludeForRequestURL(url, options));
   options.set_exclude_httponly();
   EXPECT_FALSE(cookie->IncludeForRequestURL(url, options));
 }
 
 }  // namespace net