1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
|
// 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.
#ifndef NET_COOKIES_CANONICAL_COOKIE_H_
#define NET_COOKIES_CANONICAL_COOKIE_H_
#include <string>
#include <vector>
#include "base/basictypes.h"
#include "base/time/time.h"
#include "net/base/net_export.h"
#include "net/cookies/cookie_constants.h"
#include "net/cookies/cookie_options.h"
class GURL;
namespace net {
class ParsedCookie;
class NET_EXPORT CanonicalCookie {
public:
// These constructors do no validation or canonicalization of their inputs;
// the resulting CanonicalCookies should not be relied on to be canonical
// unless the caller has done appropriate validation and canonicalization
// themselves.
CanonicalCookie();
CanonicalCookie(const GURL& url,
const std::string& name,
const std::string& value,
const std::string& domain,
const std::string& path,
const base::Time& creation,
const base::Time& expiration,
const base::Time& last_access,
bool secure,
bool httponly,
bool firstpartyonly,
CookiePriority priority);
// This constructor does canonicalization but not validation.
// The result of this constructor should not be relied on in contexts
// in which pre-validation of the ParsedCookie has not been done.
CanonicalCookie(const GURL& url, const ParsedCookie& pc);
~CanonicalCookie();
// Supports the default copy constructor.
// Creates a new |CanonicalCookie| from the |cookie_line| and the
// |creation_time|. Canonicalizes and validates inputs. May return NULL if
// an attribut value is invalid.
static CanonicalCookie* Create(const GURL& url,
const std::string& cookie_line,
const base::Time& creation_time,
const CookieOptions& options);
// Creates a canonical cookie from unparsed attribute values.
// Canonicalizes and validates inputs. May return NULL if an attribute
// value is invalid.
static CanonicalCookie* Create(const GURL& url,
const std::string& name,
const std::string& value,
const std::string& domain,
const std::string& path,
const base::Time& creation,
const base::Time& expiration,
bool secure,
bool http_only,
bool first_party_only,
CookiePriority priority);
const GURL& Source() const { return source_; }
const std::string& Name() const { return name_; }
const std::string& Value() const { return value_; }
const std::string& Domain() const { return domain_; }
const std::string& Path() const { return path_; }
const base::Time& CreationDate() const { return creation_date_; }
const base::Time& LastAccessDate() const { return last_access_date_; }
bool IsPersistent() const { return !expiry_date_.is_null(); }
const base::Time& ExpiryDate() const { return expiry_date_; }
bool IsSecure() const { return secure_; }
bool IsHttpOnly() const { return httponly_; }
bool IsFirstPartyOnly() const { return first_party_only_; }
CookiePriority Priority() const { return priority_; }
bool IsDomainCookie() const {
return !domain_.empty() && domain_[0] == '.'; }
bool IsHostCookie() const { return !IsDomainCookie(); }
bool IsExpired(const base::Time& current) const {
return !expiry_date_.is_null() && current >= expiry_date_;
}
// Are the cookies considered equivalent in the eyes of RFC 2965.
// The RFC says that name must match (case-sensitive), domain must
// match (case insensitive), and path must match (case sensitive).
// For the case insensitive domain compare, we rely on the domain
// having been canonicalized (in
// GetCookieDomainWithString->CanonicalizeHost).
bool IsEquivalent(const CanonicalCookie& ecc) const {
// It seems like it would make sense to take secure and httponly into
// account, but the RFC doesn't specify this.
// NOTE: Keep this logic in-sync with TrimDuplicateCookiesForHost().
return (name_ == ecc.Name() && domain_ == ecc.Domain()
&& path_ == ecc.Path());
}
void SetLastAccessDate(const base::Time& date) {
last_access_date_ = date;
}
// Returns true if the given |url_path| path-matches the cookie-path as
// described in section 5.1.4 in RFC 6265.
bool IsOnPath(const std::string& url_path) const;
// Returns true if the cookie domain matches the given |host| as described in
// section 5.1.3 of RFC 6265.
bool IsDomainMatch(const std::string& host) const;
// Returns true if the cookie should be included for the given request |url|.
// HTTP only cookies can be filter by using appropriate cookie |options|.
// PLEASE NOTE that this method does not check whether a cookie is expired or
// not!
bool IncludeForRequestURL(const GURL& url,
const CookieOptions& options) const;
std::string DebugString() const;
static std::string CanonPath(const GURL& url, const ParsedCookie& pc);
static base::Time CanonExpiration(const ParsedCookie& pc,
const base::Time& current,
const base::Time& server_time);
// Cookie ordering methods.
// Returns true if the cookie is less than |other|, considering only name,
// domain and path. In particular, two equivalent cookies (see IsEquivalent())
// are identical for PartialCompare().
bool PartialCompare(const CanonicalCookie& other) const;
// Returns true if the cookie is less than |other|, considering all fields.
// FullCompare() is consistent with PartialCompare(): cookies sorted using
// FullCompare() are also sorted with respect to PartialCompare().
bool FullCompare(const CanonicalCookie& other) const;
private:
// The source member of a canonical cookie is the origin of the URL that tried
// to set this cookie. This field is not persistent though; its only used in
// the in-tab cookies dialog to show the user the source URL. This is used for
// both allowed and blocked cookies.
// When a CanonicalCookie is constructed from the backing store (common case)
// this field will be null. CanonicalCookie consumers should not rely on
// this field unless they guarantee that the creator of those
// CanonicalCookies properly initialized the field.
GURL source_;
std::string name_;
std::string value_;
std::string domain_;
std::string path_;
base::Time creation_date_;
base::Time expiry_date_;
base::Time last_access_date_;
bool secure_;
bool httponly_;
bool first_party_only_;
CookiePriority priority_;
};
typedef std::vector<CanonicalCookie> CookieList;
} // namespace net
#endif // NET_COOKIES_CANONICAL_COOKIE_H_
|
