Implement Origin cookies.

net/base/cookie_monster_unittest.cc

 // Copyright (c) 2010 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 39 matching lines @@
   //    * Three levels of domain cookie (.b.a, .c.b.a, .d.c.b.a)
   //    * Three levels of host cookie (w.b.a, w.c.b.a, w.d.c.b.a)
   //    * http_only cookie (w.c.b.a)
   //    * Two secure cookies (.c.b.a, w.c.b.a)
   //    * Two domain path cookies (.c.b.a/dir1, .c.b.a/dir1/dir2)
   //    * Two host path cookies (w.c.b.a/dir1, w.c.b.a/dir1/dir2)
 
   // Domain cookies
   EXPECT_TRUE(cm->SetCookieWithDetails(url_top_level_domain_plus_1,
                                        "dom_1", "X", ".harvard.edu", "/",
-                                       base::Time(), false, false));
+                                       base::Time(), false, false, false));
   EXPECT_TRUE(cm->SetCookieWithDetails(url_top_level_domain_plus_2,
                                        "dom_2", "X", ".math.harvard.edu", "/",
-                                       base::Time(), false, false));
+                                       base::Time(), false, false, false));
   EXPECT_TRUE(cm->SetCookieWithDetails(url_top_level_domain_plus_3,
                                        "dom_3", "X",
                                        ".bourbaki.math.harvard.edu", "/",
-                                       base::Time(), false, false));
+                                       base::Time(), false, false, false));
 
   // Host cookies
   EXPECT_TRUE(cm->SetCookieWithDetails(url_top_level_domain_plus_1,
                                        "host_1", "X", "", "/",
-                                       base::Time(), false, false));
+                                       base::Time(), false, false, false));
   EXPECT_TRUE(cm->SetCookieWithDetails(url_top_level_domain_plus_2,
                                        "host_2", "X", "", "/",
-                                       base::Time(), false, false));
+                                       base::Time(), false, false, false));
   EXPECT_TRUE(cm->SetCookieWithDetails(url_top_level_domain_plus_3,
                                        "host_3", "X", "", "/",
-                                       base::Time(), false, false));
+                                       base::Time(), false, false, false));
 
   // Http_only cookie
   EXPECT_TRUE(cm->SetCookieWithDetails(url_top_level_domain_plus_2,
                                        "httpo_check", "X", "", "/",
-                                       base::Time(), false, true));
+                                       base::Time(), false, true, false));
 
   // Secure cookies
   EXPECT_TRUE(cm->SetCookieWithDetails(url_top_level_domain_plus_2_secure,
                                        "sec_dom", "X", ".math.harvard.edu",
                                        "/", base::Time(), true, false));
   EXPECT_TRUE(cm->SetCookieWithDetails(url_top_level_domain_plus_2_secure,
                                        "sec_host", "X", "", "/",
-                                       base::Time(), true, false));
+                                       base::Time(), true, false, false));
 
   // Domain path cookies
   EXPECT_TRUE(cm->SetCookieWithDetails(url_top_level_domain_plus_2,
                                        "dom_path_1", "X",
                                        ".math.harvard.edu", "/dir1",
-                                       base::Time(), false, false));
+                                       base::Time(), false, false, false));
   EXPECT_TRUE(cm->SetCookieWithDetails(url_top_level_domain_plus_2,
                                        "dom_path_2", "X",
                                        ".math.harvard.edu", "/dir1/dir2",
-                                       base::Time(), false, false));
+                                       base::Time(), false, false, false));
 
   // Host path cookies
   EXPECT_TRUE(cm->SetCookieWithDetails(url_top_level_domain_plus_2,
                                        "host_path_1", "X",
                                        "", "/dir1",
-                                       base::Time(), false, false));
+                                       base::Time(), false, false, false));
   EXPECT_TRUE(cm->SetCookieWithDetails(url_top_level_domain_plus_2,
                                        "host_path_2", "X",
                                        "", "/dir1/dir2",
-                                       base::Time(), false, false));
+                                       base::Time(), false, false, false));
 
   EXPECT_EQ(13U, cm->GetAllCookies().size());
 }
 
 }  // namespace
 
 TEST(ParsedCookieTest, TestBasic) {
   net::CookieMonster::ParsedCookie pc("a=b");
   EXPECT_TRUE(pc.IsValid());
   EXPECT_FALSE(pc.IsSecure());
@@ skipping 27 matching lines @@
 
   for (size_t i = 0; i < arraysize(values); i += 2) {
     std::string input(values[i]);
     std::string expected(values[i + 1]);
 
     net::CookieMonster::ParsedCookie pc(
         "aBc=" + input + " ; path=\"/\"  ; httponly ");
     EXPECT_TRUE(pc.IsValid());
     EXPECT_FALSE(pc.IsSecure());
     EXPECT_TRUE(pc.IsHttpOnly());
+    EXPECT_FALSE(pc.IsOrigin());
     EXPECT_TRUE(pc.HasPath());
     EXPECT_EQ("aBc", pc.Name());
     EXPECT_EQ(expected, pc.Value());
 
     // If a path was quoted, the path attribute keeps the quotes.  This will
     // make the cookie effectively useless, but path parameters aren't supposed
     // to be quoted.  Bug 1261605.
     EXPECT_EQ("\"/\"", pc.Path());
   }
 }
 
 TEST(ParsedCookieTest, TestNameless) {
   net::CookieMonster::ParsedCookie pc("BLAHHH; path=/; secure;");
   EXPECT_TRUE(pc.IsValid());
   EXPECT_TRUE(pc.IsSecure());
   EXPECT_TRUE(pc.HasPath());
   EXPECT_EQ("/", pc.Path());
   EXPECT_EQ("", pc.Name());
   EXPECT_EQ("BLAHHH", pc.Value());
 }
 
 TEST(ParsedCookieTest, TestAttributeCase) {
   net::CookieMonster::ParsedCookie pc("BLAHHH; Path=/; sECuRe; httpONLY");
   EXPECT_TRUE(pc.IsValid());
   EXPECT_TRUE(pc.IsSecure());
   EXPECT_TRUE(pc.IsHttpOnly());
+  EXPECT_FALSE(pc.IsOrigin());
   EXPECT_TRUE(pc.HasPath());
   EXPECT_EQ("/", pc.Path());
   EXPECT_EQ("", pc.Name());
   EXPECT_EQ("BLAHHH", pc.Value());
   EXPECT_EQ(3U, pc.NumberOfAttributes());
 }
 
 TEST(ParsedCookieTest, TestDoubleQuotedNameless) {
   net::CookieMonster::ParsedCookie pc("\"BLA\\\"HHH\"; path=/; secure;");
   EXPECT_TRUE(pc.IsValid());
@@ skipping 33 matching lines @@
 
 TEST(ParsedCookieTest, Whitespace) {
   net::CookieMonster::ParsedCookie pc("  A  = BC  ;secure;;;   httponly");
   EXPECT_TRUE(pc.IsValid());
   EXPECT_EQ("A", pc.Name());
   EXPECT_EQ("BC", pc.Value());
   EXPECT_FALSE(pc.HasPath());
   EXPECT_FALSE(pc.HasDomain());
   EXPECT_TRUE(pc.IsSecure());
   EXPECT_TRUE(pc.IsHttpOnly());
+  EXPECT_FALSE(pc.IsOrigin());
   // We parse anything between ; as attributes, so we end up with two
   // attributes with an empty string name and value.
   EXPECT_EQ(4U, pc.NumberOfAttributes());
 }
 TEST(ParsedCookieTest, MultipleEquals) {
   net::CookieMonster::ParsedCookie pc("  A=== BC  ;secure;;;   httponly");
   EXPECT_TRUE(pc.IsValid());
   EXPECT_EQ("A", pc.Name());
   EXPECT_EQ("== BC", pc.Value());
   EXPECT_FALSE(pc.HasPath());
   EXPECT_FALSE(pc.HasDomain());
   EXPECT_TRUE(pc.IsSecure());
   EXPECT_TRUE(pc.IsHttpOnly());
+  EXPECT_FALSE(pc.IsOrigin());
   EXPECT_EQ(4U, pc.NumberOfAttributes());
 }
 
 TEST(ParsedCookieTest, QuotedTrailingWhitespace) {
   net::CookieMonster::ParsedCookie pc("ANCUUID=\"zohNumRKgI0oxyhSsV3Z7D\"  ; "
                                       "expires=Sun, 18-Apr-2027 21:06:29 GMT ; "
                                       "path=/  ;  ");
   EXPECT_TRUE(pc.IsValid());
   EXPECT_EQ("ANCUUID", pc.Name());
   // Stripping whitespace after the quotes matches all other major browsers.
@@ skipping 1324 matching lines @@
 TEST(CookieMonsterTest, SetCookieWithDetails) {
   GURL url_google(kUrlGoogle);
   GURL url_google_foo("http://www.google.izzle/foo");
   GURL url_google_bar("http://www.google.izzle/bar");
   GURL url_google_secure(kUrlGoogleSecure);
 
   scoped_refptr<net::CookieMonster> cm(new net::CookieMonster(NULL, NULL));
 
   EXPECT_TRUE(cm->SetCookieWithDetails(
       url_google_foo, "A", "B", std::string(), "/foo", base::Time(),
-      false, false));
+      false, false, false));
   EXPECT_TRUE(cm->SetCookieWithDetails(
       url_google_bar, "C", "D", "google.izzle", "/bar", base::Time(),
-      false, true));
+      false, true, false));
   EXPECT_TRUE(cm->SetCookieWithDetails(
       url_google, "E", "F", std::string(), std::string(), base::Time(),
-      true, false));
+      true, false, false));
 
   // Test that malformed attributes fail to set the cookie.
   EXPECT_FALSE(cm->SetCookieWithDetails(
       url_google_foo, " A", "B", std::string(), "/foo", base::Time(),
-      false, false));
+      false, false, false));
   EXPECT_FALSE(cm->SetCookieWithDetails(
       url_google_foo, "A;", "B", std::string(), "/foo", base::Time(),
-      false, false));
+      false, false, false));
   EXPECT_FALSE(cm->SetCookieWithDetails(
       url_google_foo, "A=", "B", std::string(), "/foo", base::Time(),
-      false, false));
+      false, false, false));
   EXPECT_FALSE(cm->SetCookieWithDetails(
       url_google_foo, "A", "B", "google.ozzzzzzle", "foo", base::Time(),
-      false, false));
+      false, false, false));
   EXPECT_FALSE(cm->SetCookieWithDetails(
       url_google_foo, "A=", "B", std::string(), "foo", base::Time(),
-      false, false));
+      false, false, false));
 
   net::CookieMonster::CookieList cookies =
       cm->GetAllCookiesForURL(url_google_foo);
   net::CookieMonster::CookieList::iterator it = cookies.begin();
 
   ASSERT_TRUE(it != cookies.end());
   EXPECT_EQ("A", it->Name());
   EXPECT_EQ("B", it->Value());
   EXPECT_EQ("www.google.izzle", it->Domain());
   EXPECT_EQ("/foo", it->Path());
   EXPECT_FALSE(it->DoesExpire());
   EXPECT_FALSE(it->IsSecure());
   EXPECT_FALSE(it->IsHttpOnly());
+  EXPECT_FALSE(it->IsOrigin());
 
   ASSERT_TRUE(++it == cookies.end());
 
   cookies = cm->GetAllCookiesForURL(url_google_bar);
   it = cookies.begin();
 
   ASSERT_TRUE(it != cookies.end());
   EXPECT_EQ("C", it->Name());
   EXPECT_EQ("D", it->Value());
   EXPECT_EQ(".google.izzle", it->Domain());
   EXPECT_EQ("/bar", it->Path());
   EXPECT_FALSE(it->IsSecure());
   EXPECT_TRUE(it->IsHttpOnly());
+  EXPECT_FALSE(it->IsOrigin());
 
   ASSERT_TRUE(++it == cookies.end());
 
   cookies = cm->GetAllCookiesForURL(url_google_secure);
   it = cookies.begin();
 
   ASSERT_TRUE(it != cookies.end());
   EXPECT_EQ("E", it->Name());
   EXPECT_EQ("F", it->Value());
   EXPECT_EQ("/", it->Path());
   EXPECT_EQ("www.google.izzle", it->Domain());
   EXPECT_TRUE(it->IsSecure());
   EXPECT_FALSE(it->IsHttpOnly());
+  EXPECT_FALSE(it->IsOrigin());
 
   ASSERT_TRUE(++it == cookies.end());
 }
 
 TEST(CookieMonsterTest, DeleteAllForHost) {
   scoped_refptr<net::CookieMonster> cm(new net::CookieMonster(NULL, NULL));
 
   // Test probes:
   //    * Non-secure URL, mid-level (http://w.c.b.a)
   //    * Secure URL, mid-level (https://w.c.b.a)
@@ skipping 89 matching lines @@
     cookie_lines.push_back("setCookiesWithOptions3=A");
 
     cm->SetCookiesWithOptions(url_google, cookie_lines, options);
   }
 
   cm->SetCookieWithOptions(url_google, "setCookieWithOptions1=A", options);
   cm->SetCookieWithOptions(url_google, "setCookieWithOptions2=A", options);
   cm->SetCookieWithOptions(url_google, "setCookieWithOptions3=A", options);
 
   cm->SetCookieWithDetails(url_google, "setCookieWithDetails1", "A",
-                           ".google.com", "/", Time(), false, false);
+                           ".google.com", "/", Time(), false, false, false);
   cm->SetCookieWithDetails(url_google, "setCookieWithDetails2", "A",
-                           ".google.com", "/", Time(), false, false);
+                           ".google.com", "/", Time(), false, false, false);
   cm->SetCookieWithDetails(url_google, "setCookieWithDetails3", "A",
-                           ".google.com", "/", Time(), false, false);
+                           ".google.com", "/", Time(), false, false, false);
 
   // Now we check
   net::CookieMonster::CookieList cookie_list(cm->GetAllCookies());
   typedef std::map<int64, net::CookieMonster::CanonicalCookie> TimeCookieMap;
   TimeCookieMap check_map;
   for (net::CookieMonster::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));
@@ skipping 49 matching lines @@
 
   struct CookiesInputInfo {
     std::string gurl;
     std::string name;
     std::string value;
     std::string domain;
     std::string path;
     base::Time expires;
     bool secure;
     bool http_only;
+    bool origin;
   };
   const CookiesInputInfo input_info[] = {
     {"http://a.b.google.com", "a", "1", "", "/path/to/cookie", expires,
-     false, false},
+     false, false, false},
     {"https://www.google.com", "b", "2", ".google.com", "/path/from/cookie",
-     expires + TimeDelta::FromSeconds(10), true, true},
+     expires + TimeDelta::FromSeconds(10), true, true, false},
     {"https://google.com", "c", "3", "", "/another/path/to/cookie",
      base::Time::Now() + base::TimeDelta::FromSeconds(100),
-     true, false}
+     true, false, false}
   };
   const int INPUT_DELETE = 1;
 
   // Create new cookies and flush them to the store.
   {
     scoped_refptr<net::CookieMonster> cmout(new CookieMonster(store, NULL));
     for (const CookiesInputInfo* p = input_info;
          p < &input_info[ARRAYSIZE_UNSAFE(input_info)]; p++) {
       EXPECT_TRUE(cmout->SetCookieWithDetails(GURL(p->gurl), p->name, p->value,
                                               p->domain, p->path, p->expires,
-                                              p->secure, p->http_only));
+                                              p->secure, p->http_only,
+                                              p->origin));
     }
     cmout->DeleteCookie(GURL(std::string(input_info[INPUT_DELETE].gurl) +
                              input_info[INPUT_DELETE].path),
                         input_info[INPUT_DELETE].name);
   }
 
   // Create a new cookie monster and make sure that everything is correct
   {
     scoped_refptr<net::CookieMonster> cmin(new CookieMonster(store, NULL));
     CookieMonster::CookieList cookies(cmin->GetAllCookies());
     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];
 
       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_EQ(input->origin, output->IsOrigin());
       EXPECT_TRUE(output->IsPersistent());
       EXPECT_EQ(input->expires.ToInternalValue(),
                 output->ExpiryDate().ToInternalValue());
     }
   }
 }
 
 TEST(CookieMonsterTest, CookieOrdering) {
   // Put a random set of cookies into a monster and make sure
   // they're returned in the right order.
@@ skipping 129 matching lines @@
       // Will trigger GC
       cm->SetCookie(GURL("http://newdomain.com"), "b=2");
       EXPECT_EQ(test_case->expected_cookies_after_set[recent_scheme],
                 static_cast<int>((cm->GetAllCookies().size())))
           << "For test case (" << ci << ", " << recent_scheme << ")";
     }
   }
 }
 
 }  // namespace