1// Copyright 2014 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "chrome/browser/prerender/prerender_cookie_store.h"
6
7#include "base/logging.h"
8#include "base/stl_util.h"
9#include "content/public/browser/browser_thread.h"
10
11using content::BrowserThread;
12
13namespace prerender {
14
15PrerenderCookieStore::PrerenderCookieStore(
16    scoped_refptr<net::CookieMonster> default_cookie_monster,
17    const base::Closure& cookie_conflict_cb)
18    : in_forwarding_mode_(false),
19      default_cookie_monster_(default_cookie_monster),
20      changes_cookie_monster_(new net::CookieMonster(NULL, NULL)),
21      cookie_conflict_cb_(cookie_conflict_cb),
22      cookie_conflict_(false) {
23  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
24  DCHECK(default_cookie_monster_.get() != NULL);
25  DCHECK(default_cookie_monster_->loaded());
26}
27
28PrerenderCookieStore::~PrerenderCookieStore() {
29}
30
31void PrerenderCookieStore::SetCookieWithOptionsAsync(
32    const GURL& url,
33    const std::string& cookie_line,
34    const net::CookieOptions& options,
35    const SetCookiesCallback& callback) {
36  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
37
38  CookieOperation op;
39  op.op = COOKIE_OP_SET_COOKIE_WITH_OPTIONS_ASYNC;
40  op.url = url;
41  op.cookie_line = cookie_line;
42  op.options = options;
43
44  GetCookieStoreForCookieOpAndLog(op)->
45      SetCookieWithOptionsAsync(url, cookie_line, options, callback);
46}
47
48void PrerenderCookieStore::GetCookiesWithOptionsAsync(
49    const GURL& url,
50    const net::CookieOptions& options,
51    const GetCookiesCallback& callback) {
52  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
53  CookieOperation op;
54  op.op = COOKIE_OP_GET_COOKIES_WITH_OPTIONS_ASYNC;
55  op.url = url;
56  op.options = options;
57
58  GetCookieStoreForCookieOpAndLog(op)->
59      GetCookiesWithOptionsAsync(url, options, callback);
60}
61
62void PrerenderCookieStore::GetAllCookiesForURLAsync(
63    const GURL& url,
64    const GetCookieListCallback& callback) {
65  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
66
67  CookieOperation op;
68  op.op = COOKIE_OP_GET_ALL_COOKIES_FOR_URL_ASYNC;
69  op.url = url;
70
71  GetCookieStoreForCookieOpAndLog(op)->GetAllCookiesForURLAsync(url, callback);
72}
73
74
75void PrerenderCookieStore::DeleteCookieAsync(const GURL& url,
76                                             const std::string& cookie_name,
77                                             const base::Closure& callback) {
78  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
79
80  CookieOperation op;
81  op.op = COOKIE_OP_DELETE_COOKIE_ASYNC;
82  op.url = url;
83  op.cookie_name = cookie_name;
84
85  GetCookieStoreForCookieOpAndLog(op)->DeleteCookieAsync(url, cookie_name,
86                                                         callback);
87}
88
89void PrerenderCookieStore::DeleteAllCreatedBetweenAsync(
90    const base::Time& delete_begin,
91    const base::Time& delete_end,
92    const DeleteCallback& callback) {
93  NOTREACHED();
94}
95
96void PrerenderCookieStore::DeleteAllCreatedBetweenForHostAsync(
97    const base::Time delete_begin,
98    const base::Time delete_end,
99    const GURL& url,
100    const DeleteCallback& callback) {
101  NOTREACHED();
102}
103
104void PrerenderCookieStore::DeleteSessionCookiesAsync(const DeleteCallback&) {
105  NOTREACHED();
106}
107
108net::CookieMonster* PrerenderCookieStore::GetCookieMonster() {
109  NOTREACHED();
110  return NULL;
111}
112
113net::CookieStore* PrerenderCookieStore::GetCookieStoreForCookieOpAndLog(
114    const CookieOperation& op) {
115  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
116
117  std::string key = default_cookie_monster_->GetKey(op.url.host());
118  bool is_read_only = (op.op == COOKIE_OP_GET_COOKIES_WITH_OPTIONS_ASYNC ||
119                       op.op == COOKIE_OP_GET_ALL_COOKIES_FOR_URL_ASYNC);
120
121  if (in_forwarding_mode_)
122    return default_cookie_monster_.get();
123
124  DCHECK(changes_cookie_monster_.get() != NULL);
125
126  cookie_ops_.push_back(op);
127
128  bool key_copied = ContainsKey(copied_keys_, key);
129
130  if (key_copied)
131    return changes_cookie_monster_.get();
132
133  if (is_read_only) {
134    // Insert this key into the set of read keys, if it doesn't exist yet.
135    if (!ContainsKey(read_keys_, key))
136      read_keys_.insert(key);
137    return default_cookie_monster_.get();
138  }
139
140  // If this method hasn't returned yet, the key has not been copied yet,
141  // and we must copy it due to the requested write operation.
142
143  bool copy_success =
144      default_cookie_monster_->CopyCookiesForKeyToOtherCookieMonster(
145          key, changes_cookie_monster_.get());
146
147  // The copy must succeed.
148  DCHECK(copy_success);
149
150  copied_keys_.insert(key);
151
152  return changes_cookie_monster_.get();
153}
154
155void PrerenderCookieStore::ApplyChanges(std::vector<GURL>* cookie_change_urls) {
156  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
157
158  if (in_forwarding_mode_)
159    return;
160
161  // Apply all changes to the underlying cookie store.
162  for (std::vector<CookieOperation>::const_iterator it = cookie_ops_.begin();
163       it != cookie_ops_.end();
164       ++it) {
165    switch (it->op) {
166      case COOKIE_OP_SET_COOKIE_WITH_OPTIONS_ASYNC:
167        cookie_change_urls->push_back(it->url);
168        default_cookie_monster_->SetCookieWithOptionsAsync(
169            it->url, it->cookie_line, it->options, SetCookiesCallback());
170        break;
171      case COOKIE_OP_GET_COOKIES_WITH_OPTIONS_ASYNC:
172        default_cookie_monster_->GetCookiesWithOptionsAsync(
173            it->url, it->options, GetCookiesCallback());
174        break;
175      case COOKIE_OP_GET_ALL_COOKIES_FOR_URL_ASYNC:
176        default_cookie_monster_->GetAllCookiesForURLAsync(
177            it->url, GetCookieListCallback());
178        break;
179      case COOKIE_OP_DELETE_COOKIE_ASYNC:
180        cookie_change_urls->push_back(it->url);
181        default_cookie_monster_->DeleteCookieAsync(
182            it->url, it->cookie_name, base::Closure());
183        break;
184      case COOKIE_OP_MAX:
185        NOTREACHED();
186    }
187  }
188
189  in_forwarding_mode_ = true;
190  copied_keys_.clear();
191  cookie_ops_.clear();
192  changes_cookie_monster_ = NULL;
193}
194
195void PrerenderCookieStore::OnCookieChangedForURL(
196    net::CookieMonster* cookie_monster,
197    const GURL& url) {
198  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
199
200  // If the cookie was changed in a different cookie monster than the one
201  // being decorated, there is nothing to do).
202  if (cookie_monster != default_cookie_monster_.get())
203    return;
204
205  if (in_forwarding_mode_)
206    return;
207
208  // If we have encountered a conflict before, it has already been recorded
209  // and the cb has been issued, so nothing to do.
210  if (cookie_conflict_)
211    return;
212
213  std::string key = default_cookie_monster_->GetKey(url.host());
214
215  // If the key for the cookie which was modified was neither read nor written,
216  // nothing to do.
217  if ((!ContainsKey(read_keys_, key)) && (!ContainsKey(copied_keys_, key)))
218    return;
219
220  // There was a conflict in cookies. Call the conflict callback, which should
221  // cancel the prerender if necessary (i.e. if it hasn't already been
222  // cancelled for some other reason).
223  // Notice that there is a race here with swapping in the prerender, but this
224  // is the same issue that occurs when two tabs modify cookies for the
225  // same domain concurrently. Therefore, there is no need to do anything
226  // special to prevent this race condition.
227  cookie_conflict_ = true;
228  if (!cookie_conflict_cb_.is_null()) {
229    BrowserThread::PostTask(
230        BrowserThread::UI,
231        FROM_HERE,
232        cookie_conflict_cb_);
233  }
234}
235
236PrerenderCookieStore::CookieOperation::CookieOperation() {
237}
238
239PrerenderCookieStore::CookieOperation::~CookieOperation() {
240}
241
242}  // namespace prerender
243