| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 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 "content/browser/net/sqlite_persistent_cookie_store.h" | |
| 6 | |
| 7 #include <list> | |
| 8 #include <map> | |
| 9 #include <set> | |
| 10 #include <utility> | |
| 11 | |
| 12 #include "base/basictypes.h" | |
| 13 #include "base/bind.h" | |
| 14 #include "base/callback.h" | |
| 15 #include "base/files/file_path.h" | |
| 16 #include "base/files/file_util.h" | |
| 17 #include "base/location.h" | |
| 18 #include "base/logging.h" | |
| 19 #include "base/memory/ref_counted.h" | |
| 20 #include "base/memory/scoped_ptr.h" | |
| 21 #include "base/metrics/field_trial.h" | |
| 22 #include "base/metrics/histogram.h" | |
| 23 #include "base/profiler/scoped_tracker.h" | |
| 24 #include "base/sequenced_task_runner.h" | |
| 25 #include "base/strings/string_util.h" | |
| 26 #include "base/strings/stringprintf.h" | |
| 27 #include "base/synchronization/lock.h" | |
| 28 #include "base/threading/sequenced_worker_pool.h" | |
| 29 #include "base/time/time.h" | |
| 30 #include "content/public/browser/browser_thread.h" | |
| 31 #include "content/public/browser/cookie_store_factory.h" | |
| 32 #include "net/base/registry_controlled_domains/registry_controlled_domain.h" | |
| 33 #include "net/cookies/canonical_cookie.h" | |
| 34 #include "net/cookies/cookie_constants.h" | |
| 35 #include "net/cookies/cookie_util.h" | |
| 36 #include "net/extras/sqlite/cookie_crypto_delegate.h" | |
| 37 #include "sql/error_delegate_util.h" | |
| 38 #include "sql/meta_table.h" | |
| 39 #include "sql/statement.h" | |
| 40 #include "sql/transaction.h" | |
| 41 #include "storage/browser/quota/special_storage_policy.h" | |
| 42 #include "third_party/sqlite/sqlite3.h" | |
| 43 #include "url/gurl.h" | |
| 44 | |
| 45 using base::Time; | |
| 46 | |
| 47 namespace { | |
| 48 | |
| 49 // The persistent cookie store is loaded into memory on eTLD at a time. This | |
| 50 // variable controls the delay between loading eTLDs, so as to not overload the | |
| 51 // CPU or I/O with these low priority requests immediately after start up. | |
| 52 const int kLoadDelayMilliseconds = 0; | |
| 53 | |
| 54 } // namespace | |
| 55 | |
| 56 namespace content { | |
| 57 | |
| 58 // This class is designed to be shared between any client thread and the | |
| 59 // background task runner. It batches operations and commits them on a timer. | |
| 60 // | |
| 61 // SQLitePersistentCookieStore::Load is called to load all cookies. It | |
| 62 // delegates to Backend::Load, which posts a Backend::LoadAndNotifyOnDBThread | |
| 63 // task to the background runner. This task calls Backend::ChainLoadCookies(), | |
| 64 // which repeatedly posts itself to the BG runner to load each eTLD+1's cookies | |
| 65 // in separate tasks. When this is complete, Backend::CompleteLoadOnIOThread is | |
| 66 // posted to the client runner, which notifies the caller of | |
| 67 // SQLitePersistentCookieStore::Load that the load is complete. | |
| 68 // | |
| 69 // If a priority load request is invoked via SQLitePersistentCookieStore:: | |
| 70 // LoadCookiesForKey, it is delegated to Backend::LoadCookiesForKey, which posts | |
| 71 // Backend::LoadKeyAndNotifyOnDBThread to the BG runner. That routine loads just | |
| 72 // that single domain key (eTLD+1)'s cookies, and posts a Backend:: | |
| 73 // CompleteLoadForKeyOnIOThread to the client runner to notify the caller of | |
| 74 // SQLitePersistentCookieStore::LoadCookiesForKey that that load is complete. | |
| 75 // | |
| 76 // Subsequent to loading, mutations may be queued by any thread using | |
| 77 // AddCookie, UpdateCookieAccessTime, and DeleteCookie. These are flushed to | |
| 78 // disk on the BG runner every 30 seconds, 512 operations, or call to Flush(), | |
| 79 // whichever occurs first. | |
| 80 class SQLitePersistentCookieStore::Backend | |
| 81 : public base::RefCountedThreadSafe<SQLitePersistentCookieStore::Backend> { | |
| 82 public: | |
| 83 Backend( | |
| 84 const base::FilePath& path, | |
| 85 const scoped_refptr<base::SequencedTaskRunner>& client_task_runner, | |
| 86 const scoped_refptr<base::SequencedTaskRunner>& background_task_runner, | |
| 87 bool restore_old_session_cookies, | |
| 88 storage::SpecialStoragePolicy* special_storage_policy, | |
| 89 net::CookieCryptoDelegate* crypto_delegate) | |
| 90 : path_(path), | |
| 91 num_pending_(0), | |
| 92 force_keep_session_state_(false), | |
| 93 initialized_(false), | |
| 94 corruption_detected_(false), | |
| 95 restore_old_session_cookies_(restore_old_session_cookies), | |
| 96 special_storage_policy_(special_storage_policy), | |
| 97 num_cookies_read_(0), | |
| 98 client_task_runner_(client_task_runner), | |
| 99 background_task_runner_(background_task_runner), | |
| 100 num_priority_waiting_(0), | |
| 101 total_priority_requests_(0), | |
| 102 crypto_(crypto_delegate) {} | |
| 103 | |
| 104 // Creates or loads the SQLite database. | |
| 105 void Load(const LoadedCallback& loaded_callback); | |
| 106 | |
| 107 // Loads cookies for the domain key (eTLD+1). | |
| 108 void LoadCookiesForKey(const std::string& domain, | |
| 109 const LoadedCallback& loaded_callback); | |
| 110 | |
| 111 // Steps through all results of |smt|, makes a cookie from each, and adds the | |
| 112 // cookie to |cookies|. This method also updates |cookies_per_origin_| and | |
| 113 // |num_cookies_read_|. | |
| 114 void MakeCookiesFromSQLStatement(std::vector<net::CanonicalCookie*>* cookies, | |
| 115 sql::Statement* statement); | |
| 116 | |
| 117 // Batch a cookie addition. | |
| 118 void AddCookie(const net::CanonicalCookie& cc); | |
| 119 | |
| 120 // Batch a cookie access time update. | |
| 121 void UpdateCookieAccessTime(const net::CanonicalCookie& cc); | |
| 122 | |
| 123 // Batch a cookie deletion. | |
| 124 void DeleteCookie(const net::CanonicalCookie& cc); | |
| 125 | |
| 126 // Commit pending operations as soon as possible. | |
| 127 void Flush(const base::Closure& callback); | |
| 128 | |
| 129 // Commit any pending operations and close the database. This must be called | |
| 130 // before the object is destructed. | |
| 131 void Close(); | |
| 132 | |
| 133 void SetForceKeepSessionState(); | |
| 134 | |
| 135 private: | |
| 136 friend class base::RefCountedThreadSafe<SQLitePersistentCookieStore::Backend>; | |
| 137 | |
| 138 // You should call Close() before destructing this object. | |
| 139 ~Backend() { | |
| 140 DCHECK(!db_.get()) << "Close should have already been called."; | |
| 141 DCHECK(num_pending_ == 0 && pending_.empty()); | |
| 142 | |
| 143 for (net::CanonicalCookie* cookie : cookies_) { | |
| 144 delete cookie; | |
| 145 } | |
| 146 } | |
| 147 | |
| 148 // Database upgrade statements. | |
| 149 bool EnsureDatabaseVersion(); | |
| 150 | |
| 151 class PendingOperation { | |
| 152 public: | |
| 153 typedef enum { | |
| 154 COOKIE_ADD, | |
| 155 COOKIE_UPDATEACCESS, | |
| 156 COOKIE_DELETE, | |
| 157 } OperationType; | |
| 158 | |
| 159 PendingOperation(OperationType op, const net::CanonicalCookie& cc) | |
| 160 : op_(op), cc_(cc) { } | |
| 161 | |
| 162 OperationType op() const { return op_; } | |
| 163 const net::CanonicalCookie& cc() const { return cc_; } | |
| 164 | |
| 165 private: | |
| 166 OperationType op_; | |
| 167 net::CanonicalCookie cc_; | |
| 168 }; | |
| 169 | |
| 170 private: | |
| 171 // Creates or loads the SQLite database on background runner. | |
| 172 void LoadAndNotifyInBackground(const LoadedCallback& loaded_callback, | |
| 173 const base::Time& posted_at); | |
| 174 | |
| 175 // Loads cookies for the domain key (eTLD+1) on background runner. | |
| 176 void LoadKeyAndNotifyInBackground(const std::string& domains, | |
| 177 const LoadedCallback& loaded_callback, | |
| 178 const base::Time& posted_at); | |
| 179 | |
| 180 // Notifies the CookieMonster when loading completes for a specific domain key | |
| 181 // or for all domain keys. Triggers the callback and passes it all cookies | |
| 182 // that have been loaded from DB since last IO notification. | |
| 183 void Notify(const LoadedCallback& loaded_callback, bool load_success); | |
| 184 | |
| 185 // Sends notification when the entire store is loaded, and reports metrics | |
| 186 // for the total time to load and aggregated results from any priority loads | |
| 187 // that occurred. | |
| 188 void CompleteLoadInForeground(const LoadedCallback& loaded_callback, | |
| 189 bool load_success); | |
| 190 | |
| 191 // Sends notification when a single priority load completes. Updates priority | |
| 192 // load metric data. The data is sent only after the final load completes. | |
| 193 void CompleteLoadForKeyInForeground(const LoadedCallback& loaded_callback, | |
| 194 bool load_success, | |
| 195 const base::Time& requested_at); | |
| 196 | |
| 197 // Sends all metrics, including posting a ReportMetricsInBackground task. | |
| 198 // Called after all priority and regular loading is complete. | |
| 199 void ReportMetrics(); | |
| 200 | |
| 201 // Sends background-runner owned metrics (i.e., the combined duration of all | |
| 202 // BG-runner tasks). | |
| 203 void ReportMetricsInBackground(); | |
| 204 | |
| 205 // Initialize the data base. | |
| 206 bool InitializeDatabase(); | |
| 207 | |
| 208 // Loads cookies for the next domain key from the DB, then either reschedules | |
| 209 // itself or schedules the provided callback to run on the client runner (if | |
| 210 // all domains are loaded). | |
| 211 void ChainLoadCookies(const LoadedCallback& loaded_callback); | |
| 212 | |
| 213 // Load all cookies for a set of domains/hosts | |
| 214 bool LoadCookiesForDomains(const std::set<std::string>& key); | |
| 215 | |
| 216 // Batch a cookie operation (add or delete) | |
| 217 void BatchOperation(PendingOperation::OperationType op, | |
| 218 const net::CanonicalCookie& cc); | |
| 219 // Commit our pending operations to the database. | |
| 220 void Commit(); | |
| 221 // Close() executed on the background runner. | |
| 222 void InternalBackgroundClose(); | |
| 223 | |
| 224 void DeleteSessionCookiesOnStartup(); | |
| 225 | |
| 226 void DeleteSessionCookiesOnShutdown(); | |
| 227 | |
| 228 void DatabaseErrorCallback(int error, sql::Statement* stmt); | |
| 229 void KillDatabase(); | |
| 230 | |
| 231 void PostBackgroundTask(const tracked_objects::Location& origin, | |
| 232 const base::Closure& task); | |
| 233 void PostClientTask(const tracked_objects::Location& origin, | |
| 234 const base::Closure& task); | |
| 235 | |
| 236 // Shared code between the different load strategies to be used after all | |
| 237 // cookies have been loaded. | |
| 238 void FinishedLoadingCookies(const LoadedCallback& loaded_callback, | |
| 239 bool success); | |
| 240 | |
| 241 base::FilePath path_; | |
| 242 scoped_ptr<sql::Connection> db_; | |
| 243 sql::MetaTable meta_table_; | |
| 244 | |
| 245 typedef std::list<PendingOperation*> PendingOperationsList; | |
| 246 PendingOperationsList pending_; | |
| 247 PendingOperationsList::size_type num_pending_; | |
| 248 // True if the persistent store should skip delete on exit rules. | |
| 249 bool force_keep_session_state_; | |
| 250 // Guard |cookies_|, |pending_|, |num_pending_|, |force_keep_session_state_| | |
| 251 base::Lock lock_; | |
| 252 | |
| 253 // Temporary buffer for cookies loaded from DB. Accumulates cookies to reduce | |
| 254 // the number of messages sent to the client runner. Sent back in response to | |
| 255 // individual load requests for domain keys or when all loading completes. | |
| 256 // Ownership of the cookies in this vector is transferred to the client in | |
| 257 // response to individual load requests or when all loading completes. | |
| 258 std::vector<net::CanonicalCookie*> cookies_; | |
| 259 | |
| 260 // Map of domain keys(eTLD+1) to domains/hosts that are to be loaded from DB. | |
| 261 std::map<std::string, std::set<std::string> > keys_to_load_; | |
| 262 | |
| 263 // Map of (domain keys(eTLD+1), is secure cookie) to number of cookies in the | |
| 264 // database. | |
| 265 typedef std::pair<std::string, bool> CookieOrigin; | |
| 266 typedef std::map<CookieOrigin, int> CookiesPerOriginMap; | |
| 267 CookiesPerOriginMap cookies_per_origin_; | |
| 268 | |
| 269 // Indicates if DB has been initialized. | |
| 270 bool initialized_; | |
| 271 | |
| 272 // Indicates if the kill-database callback has been scheduled. | |
| 273 bool corruption_detected_; | |
| 274 | |
| 275 // If false, we should filter out session cookies when reading the DB. | |
| 276 bool restore_old_session_cookies_; | |
| 277 | |
| 278 // Policy defining what data is deleted on shutdown. | |
| 279 scoped_refptr<storage::SpecialStoragePolicy> special_storage_policy_; | |
| 280 | |
| 281 // The cumulative time spent loading the cookies on the background runner. | |
| 282 // Incremented and reported from the background runner. | |
| 283 base::TimeDelta cookie_load_duration_; | |
| 284 | |
| 285 // The total number of cookies read. Incremented and reported on the | |
| 286 // background runner. | |
| 287 int num_cookies_read_; | |
| 288 | |
| 289 scoped_refptr<base::SequencedTaskRunner> client_task_runner_; | |
| 290 scoped_refptr<base::SequencedTaskRunner> background_task_runner_; | |
| 291 | |
| 292 // Guards the following metrics-related properties (only accessed when | |
| 293 // starting/completing priority loads or completing the total load). | |
| 294 base::Lock metrics_lock_; | |
| 295 int num_priority_waiting_; | |
| 296 // The total number of priority requests. | |
| 297 int total_priority_requests_; | |
| 298 // The time when |num_priority_waiting_| incremented to 1. | |
| 299 base::Time current_priority_wait_start_; | |
| 300 // The cumulative duration of time when |num_priority_waiting_| was greater | |
| 301 // than 1. | |
| 302 base::TimeDelta priority_wait_duration_; | |
| 303 // Class with functions that do cryptographic operations (for protecting | |
| 304 // cookies stored persistently). | |
| 305 // | |
| 306 // Not owned. | |
| 307 net::CookieCryptoDelegate* crypto_; | |
| 308 | |
| 309 DISALLOW_COPY_AND_ASSIGN(Backend); | |
| 310 }; | |
| 311 | |
| 312 namespace { | |
| 313 | |
| 314 // Version number of the database. | |
| 315 // | |
| 316 // Version 9 adds a partial index to track non-persistent cookies. | |
| 317 // Non-persistent cookies sometimes need to be deleted on startup. There are | |
| 318 // frequently few or no non-persistent cookies, so the partial index allows the | |
| 319 // deletion to be sped up or skipped, without having to page in the DB. | |
| 320 // | |
| 321 // Version 8 adds "first-party only" cookies. | |
| 322 // | |
| 323 // Version 7 adds encrypted values. Old values will continue to be used but | |
| 324 // all new values written will be encrypted on selected operating systems. New | |
| 325 // records read by old clients will simply get an empty cookie value while old | |
| 326 // records read by new clients will continue to operate with the unencrypted | |
| 327 // version. New and old clients alike will always write/update records with | |
| 328 // what they support. | |
| 329 // | |
| 330 // Version 6 adds cookie priorities. This allows developers to influence the | |
| 331 // order in which cookies are evicted in order to meet domain cookie limits. | |
| 332 // | |
| 333 // Version 5 adds the columns has_expires and is_persistent, so that the | |
| 334 // database can store session cookies as well as persistent cookies. Databases | |
| 335 // of version 5 are incompatible with older versions of code. If a database of | |
| 336 // version 5 is read by older code, session cookies will be treated as normal | |
| 337 // cookies. Currently, these fields are written, but not read anymore. | |
| 338 // | |
| 339 // In version 4, we migrated the time epoch. If you open the DB with an older | |
| 340 // version on Mac or Linux, the times will look wonky, but the file will likely | |
| 341 // be usable. On Windows version 3 and 4 are the same. | |
| 342 // | |
| 343 // Version 3 updated the database to include the last access time, so we can | |
| 344 // expire them in decreasing order of use when we've reached the maximum | |
| 345 // number of cookies. | |
| 346 const int kCurrentVersionNumber = 9; | |
| 347 const int kCompatibleVersionNumber = 5; | |
| 348 | |
| 349 // Possible values for the 'priority' column. | |
| 350 enum DBCookiePriority { | |
| 351 kCookiePriorityLow = 0, | |
| 352 kCookiePriorityMedium = 1, | |
| 353 kCookiePriorityHigh = 2, | |
| 354 }; | |
| 355 | |
| 356 DBCookiePriority CookiePriorityToDBCookiePriority(net::CookiePriority value) { | |
| 357 switch (value) { | |
| 358 case net::COOKIE_PRIORITY_LOW: | |
| 359 return kCookiePriorityLow; | |
| 360 case net::COOKIE_PRIORITY_MEDIUM: | |
| 361 return kCookiePriorityMedium; | |
| 362 case net::COOKIE_PRIORITY_HIGH: | |
| 363 return kCookiePriorityHigh; | |
| 364 } | |
| 365 | |
| 366 NOTREACHED(); | |
| 367 return kCookiePriorityMedium; | |
| 368 } | |
| 369 | |
| 370 net::CookiePriority DBCookiePriorityToCookiePriority(DBCookiePriority value) { | |
| 371 switch (value) { | |
| 372 case kCookiePriorityLow: | |
| 373 return net::COOKIE_PRIORITY_LOW; | |
| 374 case kCookiePriorityMedium: | |
| 375 return net::COOKIE_PRIORITY_MEDIUM; | |
| 376 case kCookiePriorityHigh: | |
| 377 return net::COOKIE_PRIORITY_HIGH; | |
| 378 } | |
| 379 | |
| 380 NOTREACHED(); | |
| 381 return net::COOKIE_PRIORITY_DEFAULT; | |
| 382 } | |
| 383 | |
| 384 // Increments a specified TimeDelta by the duration between this object's | |
| 385 // constructor and destructor. Not thread safe. Multiple instances may be | |
| 386 // created with the same delta instance as long as their lifetimes are nested. | |
| 387 // The shortest lived instances have no impact. | |
| 388 class IncrementTimeDelta { | |
| 389 public: | |
| 390 explicit IncrementTimeDelta(base::TimeDelta* delta) : | |
| 391 delta_(delta), | |
| 392 original_value_(*delta), | |
| 393 start_(base::Time::Now()) {} | |
| 394 | |
| 395 ~IncrementTimeDelta() { | |
| 396 *delta_ = original_value_ + base::Time::Now() - start_; | |
| 397 } | |
| 398 | |
| 399 private: | |
| 400 base::TimeDelta* delta_; | |
| 401 base::TimeDelta original_value_; | |
| 402 base::Time start_; | |
| 403 | |
| 404 DISALLOW_COPY_AND_ASSIGN(IncrementTimeDelta); | |
| 405 }; | |
| 406 | |
| 407 // Initializes the cookies table, returning true on success. | |
| 408 bool InitTable(sql::Connection* db) { | |
| 409 if (db->DoesTableExist("cookies")) | |
| 410 return true; | |
| 411 | |
| 412 std::string stmt(base::StringPrintf( | |
| 413 "CREATE TABLE cookies (" | |
| 414 "creation_utc INTEGER NOT NULL UNIQUE PRIMARY KEY," | |
| 415 "host_key TEXT NOT NULL," | |
| 416 "name TEXT NOT NULL," | |
| 417 "value TEXT NOT NULL," | |
| 418 "path TEXT NOT NULL," | |
| 419 "expires_utc INTEGER NOT NULL," | |
| 420 "secure INTEGER NOT NULL," | |
| 421 "httponly INTEGER NOT NULL," | |
| 422 "last_access_utc INTEGER NOT NULL, " | |
| 423 "has_expires INTEGER NOT NULL DEFAULT 1, " | |
| 424 "persistent INTEGER NOT NULL DEFAULT 1," | |
| 425 "priority INTEGER NOT NULL DEFAULT %d," | |
| 426 "encrypted_value BLOB DEFAULT ''," | |
| 427 "firstpartyonly INTEGER NOT NULL DEFAULT 0)", | |
| 428 CookiePriorityToDBCookiePriority(net::COOKIE_PRIORITY_DEFAULT))); | |
| 429 if (!db->Execute(stmt.c_str())) | |
| 430 return false; | |
| 431 | |
| 432 if (!db->Execute("CREATE INDEX domain ON cookies(host_key)")) | |
| 433 return false; | |
| 434 | |
| 435 #if defined(OS_IOS) | |
| 436 // iOS 8.1 and older doesn't support partial indices. iOS 8.2 supports | |
| 437 // partial indices. | |
| 438 if (!db->Execute("CREATE INDEX is_transient ON cookies(persistent)")) { | |
| 439 #else | |
| 440 if (!db->Execute( | |
| 441 "CREATE INDEX is_transient ON cookies(persistent) " | |
| 442 "where persistent != 1")) { | |
| 443 #endif | |
| 444 return false; | |
| 445 } | |
| 446 | |
| 447 return true; | |
| 448 } | |
| 449 | |
| 450 } // namespace | |
| 451 | |
| 452 void SQLitePersistentCookieStore::Backend::Load( | |
| 453 const LoadedCallback& loaded_callback) { | |
| 454 PostBackgroundTask(FROM_HERE, base::Bind( | |
| 455 &Backend::LoadAndNotifyInBackground, this, | |
| 456 loaded_callback, base::Time::Now())); | |
| 457 } | |
| 458 | |
| 459 void SQLitePersistentCookieStore::Backend::LoadCookiesForKey( | |
| 460 const std::string& key, | |
| 461 const LoadedCallback& loaded_callback) { | |
| 462 { | |
| 463 base::AutoLock locked(metrics_lock_); | |
| 464 if (num_priority_waiting_ == 0) | |
| 465 current_priority_wait_start_ = base::Time::Now(); | |
| 466 num_priority_waiting_++; | |
| 467 total_priority_requests_++; | |
| 468 } | |
| 469 | |
| 470 PostBackgroundTask(FROM_HERE, base::Bind( | |
| 471 &Backend::LoadKeyAndNotifyInBackground, | |
| 472 this, key, loaded_callback, base::Time::Now())); | |
| 473 } | |
| 474 | |
| 475 void SQLitePersistentCookieStore::Backend::LoadAndNotifyInBackground( | |
| 476 const LoadedCallback& loaded_callback, const base::Time& posted_at) { | |
| 477 DCHECK(background_task_runner_->RunsTasksOnCurrentThread()); | |
| 478 IncrementTimeDelta increment(&cookie_load_duration_); | |
| 479 | |
| 480 UMA_HISTOGRAM_CUSTOM_TIMES( | |
| 481 "Cookie.TimeLoadDBQueueWait", | |
| 482 base::Time::Now() - posted_at, | |
| 483 base::TimeDelta::FromMilliseconds(1), base::TimeDelta::FromMinutes(1), | |
| 484 50); | |
| 485 | |
| 486 if (!InitializeDatabase()) { | |
| 487 PostClientTask(FROM_HERE, base::Bind( | |
| 488 &Backend::CompleteLoadInForeground, this, loaded_callback, false)); | |
| 489 } else { | |
| 490 ChainLoadCookies(loaded_callback); | |
| 491 } | |
| 492 } | |
| 493 | |
| 494 void SQLitePersistentCookieStore::Backend::LoadKeyAndNotifyInBackground( | |
| 495 const std::string& key, | |
| 496 const LoadedCallback& loaded_callback, | |
| 497 const base::Time& posted_at) { | |
| 498 DCHECK(background_task_runner_->RunsTasksOnCurrentThread()); | |
| 499 IncrementTimeDelta increment(&cookie_load_duration_); | |
| 500 | |
| 501 UMA_HISTOGRAM_CUSTOM_TIMES( | |
| 502 "Cookie.TimeKeyLoadDBQueueWait", | |
| 503 base::Time::Now() - posted_at, | |
| 504 base::TimeDelta::FromMilliseconds(1), base::TimeDelta::FromMinutes(1), | |
| 505 50); | |
| 506 | |
| 507 bool success = false; | |
| 508 if (InitializeDatabase()) { | |
| 509 std::map<std::string, std::set<std::string> >::iterator | |
| 510 it = keys_to_load_.find(key); | |
| 511 if (it != keys_to_load_.end()) { | |
| 512 success = LoadCookiesForDomains(it->second); | |
| 513 keys_to_load_.erase(it); | |
| 514 } else { | |
| 515 success = true; | |
| 516 } | |
| 517 } | |
| 518 | |
| 519 PostClientTask(FROM_HERE, base::Bind( | |
| 520 &SQLitePersistentCookieStore::Backend::CompleteLoadForKeyInForeground, | |
| 521 this, loaded_callback, success, posted_at)); | |
| 522 } | |
| 523 | |
| 524 void SQLitePersistentCookieStore::Backend::CompleteLoadForKeyInForeground( | |
| 525 const LoadedCallback& loaded_callback, | |
| 526 bool load_success, | |
| 527 const::Time& requested_at) { | |
| 528 DCHECK(client_task_runner_->RunsTasksOnCurrentThread()); | |
| 529 | |
| 530 UMA_HISTOGRAM_CUSTOM_TIMES( | |
| 531 "Cookie.TimeKeyLoadTotalWait", | |
| 532 base::Time::Now() - requested_at, | |
| 533 base::TimeDelta::FromMilliseconds(1), base::TimeDelta::FromMinutes(1), | |
| 534 50); | |
| 535 | |
| 536 Notify(loaded_callback, load_success); | |
| 537 | |
| 538 { | |
| 539 base::AutoLock locked(metrics_lock_); | |
| 540 num_priority_waiting_--; | |
| 541 if (num_priority_waiting_ == 0) { | |
| 542 priority_wait_duration_ += | |
| 543 base::Time::Now() - current_priority_wait_start_; | |
| 544 } | |
| 545 } | |
| 546 | |
| 547 } | |
| 548 | |
| 549 void SQLitePersistentCookieStore::Backend::ReportMetricsInBackground() { | |
| 550 UMA_HISTOGRAM_CUSTOM_TIMES( | |
| 551 "Cookie.TimeLoad", | |
| 552 cookie_load_duration_, | |
| 553 base::TimeDelta::FromMilliseconds(1), base::TimeDelta::FromMinutes(1), | |
| 554 50); | |
| 555 } | |
| 556 | |
| 557 void SQLitePersistentCookieStore::Backend::ReportMetrics() { | |
| 558 PostBackgroundTask(FROM_HERE, base::Bind( | |
| 559 &SQLitePersistentCookieStore::Backend::ReportMetricsInBackground, this)); | |
| 560 | |
| 561 { | |
| 562 base::AutoLock locked(metrics_lock_); | |
| 563 UMA_HISTOGRAM_CUSTOM_TIMES( | |
| 564 "Cookie.PriorityBlockingTime", | |
| 565 priority_wait_duration_, | |
| 566 base::TimeDelta::FromMilliseconds(1), base::TimeDelta::FromMinutes(1), | |
| 567 50); | |
| 568 | |
| 569 UMA_HISTOGRAM_COUNTS_100( | |
| 570 "Cookie.PriorityLoadCount", | |
| 571 total_priority_requests_); | |
| 572 | |
| 573 UMA_HISTOGRAM_COUNTS_10000( | |
| 574 "Cookie.NumberOfLoadedCookies", | |
| 575 num_cookies_read_); | |
| 576 } | |
| 577 } | |
| 578 | |
| 579 void SQLitePersistentCookieStore::Backend::CompleteLoadInForeground( | |
| 580 const LoadedCallback& loaded_callback, bool load_success) { | |
| 581 Notify(loaded_callback, load_success); | |
| 582 | |
| 583 if (load_success) | |
| 584 ReportMetrics(); | |
| 585 } | |
| 586 | |
| 587 void SQLitePersistentCookieStore::Backend::Notify( | |
| 588 const LoadedCallback& loaded_callback, | |
| 589 bool load_success) { | |
| 590 DCHECK(client_task_runner_->RunsTasksOnCurrentThread()); | |
| 591 | |
| 592 std::vector<net::CanonicalCookie*> cookies; | |
| 593 { | |
| 594 base::AutoLock locked(lock_); | |
| 595 cookies.swap(cookies_); | |
| 596 } | |
| 597 | |
| 598 loaded_callback.Run(cookies); | |
| 599 } | |
| 600 | |
| 601 bool SQLitePersistentCookieStore::Backend::InitializeDatabase() { | |
| 602 DCHECK(background_task_runner_->RunsTasksOnCurrentThread()); | |
| 603 | |
| 604 if (initialized_ || corruption_detected_) { | |
| 605 // Return false if we were previously initialized but the DB has since been | |
| 606 // closed, or if corruption caused a database reset during initialization. | |
| 607 return db_ != NULL; | |
| 608 } | |
| 609 | |
| 610 base::Time start = base::Time::Now(); | |
| 611 | |
| 612 const base::FilePath dir = path_.DirName(); | |
| 613 if (!base::PathExists(dir) && !base::CreateDirectory(dir)) { | |
| 614 return false; | |
| 615 } | |
| 616 | |
| 617 int64 db_size = 0; | |
| 618 if (base::GetFileSize(path_, &db_size)) | |
| 619 UMA_HISTOGRAM_COUNTS("Cookie.DBSizeInKB", db_size / 1024 ); | |
| 620 | |
| 621 db_.reset(new sql::Connection); | |
| 622 db_->set_histogram_tag("Cookie"); | |
| 623 | |
| 624 // Unretained to avoid a ref loop with |db_|. | |
| 625 db_->set_error_callback( | |
| 626 base::Bind(&SQLitePersistentCookieStore::Backend::DatabaseErrorCallback, | |
| 627 base::Unretained(this))); | |
| 628 | |
| 629 if (!db_->Open(path_)) { | |
| 630 NOTREACHED() << "Unable to open cookie DB."; | |
| 631 if (corruption_detected_) | |
| 632 db_->Raze(); | |
| 633 meta_table_.Reset(); | |
| 634 db_.reset(); | |
| 635 return false; | |
| 636 } | |
| 637 | |
| 638 if (!EnsureDatabaseVersion() || !InitTable(db_.get())) { | |
| 639 NOTREACHED() << "Unable to open cookie DB."; | |
| 640 if (corruption_detected_) | |
| 641 db_->Raze(); | |
| 642 meta_table_.Reset(); | |
| 643 db_.reset(); | |
| 644 return false; | |
| 645 } | |
| 646 | |
| 647 UMA_HISTOGRAM_CUSTOM_TIMES( | |
| 648 "Cookie.TimeInitializeDB", | |
| 649 base::Time::Now() - start, | |
| 650 base::TimeDelta::FromMilliseconds(1), base::TimeDelta::FromMinutes(1), | |
| 651 50); | |
| 652 | |
| 653 start = base::Time::Now(); | |
| 654 | |
| 655 // Retrieve all the domains | |
| 656 sql::Statement smt(db_->GetUniqueStatement( | |
| 657 "SELECT DISTINCT host_key FROM cookies")); | |
| 658 | |
| 659 if (!smt.is_valid()) { | |
| 660 if (corruption_detected_) | |
| 661 db_->Raze(); | |
| 662 meta_table_.Reset(); | |
| 663 db_.reset(); | |
| 664 return false; | |
| 665 } | |
| 666 | |
| 667 std::vector<std::string> host_keys; | |
| 668 while (smt.Step()) | |
| 669 host_keys.push_back(smt.ColumnString(0)); | |
| 670 | |
| 671 UMA_HISTOGRAM_CUSTOM_TIMES( | |
| 672 "Cookie.TimeLoadDomains", | |
| 673 base::Time::Now() - start, | |
| 674 base::TimeDelta::FromMilliseconds(1), base::TimeDelta::FromMinutes(1), | |
| 675 50); | |
| 676 | |
| 677 base::Time start_parse = base::Time::Now(); | |
| 678 | |
| 679 // Build a map of domain keys (always eTLD+1) to domains. | |
| 680 for (size_t idx = 0; idx < host_keys.size(); ++idx) { | |
| 681 const std::string& domain = host_keys[idx]; | |
| 682 std::string key = | |
| 683 net::registry_controlled_domains::GetDomainAndRegistry( | |
| 684 domain, | |
| 685 net::registry_controlled_domains::INCLUDE_PRIVATE_REGISTRIES); | |
| 686 | |
| 687 keys_to_load_[key].insert(domain); | |
| 688 } | |
| 689 | |
| 690 UMA_HISTOGRAM_CUSTOM_TIMES( | |
| 691 "Cookie.TimeParseDomains", | |
| 692 base::Time::Now() - start_parse, | |
| 693 base::TimeDelta::FromMilliseconds(1), base::TimeDelta::FromMinutes(1), | |
| 694 50); | |
| 695 | |
| 696 UMA_HISTOGRAM_CUSTOM_TIMES( | |
| 697 "Cookie.TimeInitializeDomainMap", | |
| 698 base::Time::Now() - start, | |
| 699 base::TimeDelta::FromMilliseconds(1), base::TimeDelta::FromMinutes(1), | |
| 700 50); | |
| 701 | |
| 702 initialized_ = true; | |
| 703 | |
| 704 if (!restore_old_session_cookies_) | |
| 705 DeleteSessionCookiesOnStartup(); | |
| 706 return true; | |
| 707 } | |
| 708 | |
| 709 void SQLitePersistentCookieStore::Backend::ChainLoadCookies( | |
| 710 const LoadedCallback& loaded_callback) { | |
| 711 DCHECK(background_task_runner_->RunsTasksOnCurrentThread()); | |
| 712 IncrementTimeDelta increment(&cookie_load_duration_); | |
| 713 | |
| 714 bool load_success = true; | |
| 715 | |
| 716 if (!db_) { | |
| 717 // Close() has been called on this store. | |
| 718 load_success = false; | |
| 719 } else if (keys_to_load_.size() > 0) { | |
| 720 // Load cookies for the first domain key. | |
| 721 std::map<std::string, std::set<std::string> >::iterator | |
| 722 it = keys_to_load_.begin(); | |
| 723 load_success = LoadCookiesForDomains(it->second); | |
| 724 keys_to_load_.erase(it); | |
| 725 } | |
| 726 | |
| 727 // If load is successful and there are more domain keys to be loaded, | |
| 728 // then post a background task to continue chain-load; | |
| 729 // Otherwise notify on client runner. | |
| 730 if (load_success && keys_to_load_.size() > 0) { | |
| 731 bool success = background_task_runner_->PostDelayedTask( | |
| 732 FROM_HERE, | |
| 733 base::Bind(&Backend::ChainLoadCookies, this, loaded_callback), | |
| 734 base::TimeDelta::FromMilliseconds(kLoadDelayMilliseconds)); | |
| 735 if (!success) { | |
| 736 LOG(WARNING) << "Failed to post task from " << FROM_HERE.ToString() | |
| 737 << " to background_task_runner_."; | |
| 738 } | |
| 739 } else { | |
| 740 FinishedLoadingCookies(loaded_callback, load_success); | |
| 741 } | |
| 742 } | |
| 743 | |
| 744 bool SQLitePersistentCookieStore::Backend::LoadCookiesForDomains( | |
| 745 const std::set<std::string>& domains) { | |
| 746 DCHECK(background_task_runner_->RunsTasksOnCurrentThread()); | |
| 747 | |
| 748 sql::Statement smt; | |
| 749 if (restore_old_session_cookies_) { | |
| 750 smt.Assign(db_->GetCachedStatement( | |
| 751 SQL_FROM_HERE, | |
| 752 "SELECT creation_utc, host_key, name, value, encrypted_value, path, " | |
| 753 "expires_utc, secure, httponly, firstpartyonly, last_access_utc, " | |
| 754 "has_expires, persistent, priority FROM cookies WHERE host_key = ?")); | |
| 755 } else { | |
| 756 smt.Assign(db_->GetCachedStatement( | |
| 757 SQL_FROM_HERE, | |
| 758 "SELECT creation_utc, host_key, name, value, encrypted_value, path, " | |
| 759 "expires_utc, secure, httponly, firstpartyonly, last_access_utc, " | |
| 760 "has_expires, persistent, priority FROM cookies WHERE host_key = ? " | |
| 761 "AND persistent = 1")); | |
| 762 } | |
| 763 if (!smt.is_valid()) { | |
| 764 smt.Clear(); // Disconnect smt_ref from db_. | |
| 765 meta_table_.Reset(); | |
| 766 db_.reset(); | |
| 767 return false; | |
| 768 } | |
| 769 | |
| 770 std::vector<net::CanonicalCookie*> cookies; | |
| 771 std::set<std::string>::const_iterator it = domains.begin(); | |
| 772 for (; it != domains.end(); ++it) { | |
| 773 smt.BindString(0, *it); | |
| 774 MakeCookiesFromSQLStatement(&cookies, &smt); | |
| 775 smt.Reset(true); | |
| 776 } | |
| 777 { | |
| 778 base::AutoLock locked(lock_); | |
| 779 cookies_.insert(cookies_.end(), cookies.begin(), cookies.end()); | |
| 780 } | |
| 781 return true; | |
| 782 } | |
| 783 | |
| 784 void SQLitePersistentCookieStore::Backend::MakeCookiesFromSQLStatement( | |
| 785 std::vector<net::CanonicalCookie*>* cookies, | |
| 786 sql::Statement* statement) { | |
| 787 sql::Statement& smt = *statement; | |
| 788 while (smt.Step()) { | |
| 789 std::string value; | |
| 790 std::string encrypted_value = smt.ColumnString(4); | |
| 791 if (!encrypted_value.empty() && crypto_) { | |
| 792 crypto_->DecryptString(encrypted_value, &value); | |
| 793 } else { | |
| 794 DCHECK(encrypted_value.empty()); | |
| 795 value = smt.ColumnString(3); | |
| 796 } | |
| 797 scoped_ptr<net::CanonicalCookie> cc(new net::CanonicalCookie( | |
| 798 // The "source" URL is not used with persisted cookies. | |
| 799 GURL(), // Source | |
| 800 smt.ColumnString(2), // name | |
| 801 value, // value | |
| 802 smt.ColumnString(1), // domain | |
| 803 smt.ColumnString(5), // path | |
| 804 Time::FromInternalValue(smt.ColumnInt64(0)), // creation_utc | |
| 805 Time::FromInternalValue(smt.ColumnInt64(6)), // expires_utc | |
| 806 Time::FromInternalValue(smt.ColumnInt64(10)), // last_access_utc | |
| 807 smt.ColumnInt(7) != 0, // secure | |
| 808 smt.ColumnInt(8) != 0, // httponly | |
| 809 smt.ColumnInt(9) != 0, // firstpartyonly | |
| 810 DBCookiePriorityToCookiePriority( | |
| 811 static_cast<DBCookiePriority>(smt.ColumnInt(13))))); // priority | |
| 812 DLOG_IF(WARNING, cc->CreationDate() > Time::Now()) | |
| 813 << L"CreationDate too recent"; | |
| 814 cookies_per_origin_[CookieOrigin(cc->Domain(), cc->IsSecure())]++; | |
| 815 cookies->push_back(cc.release()); | |
| 816 ++num_cookies_read_; | |
| 817 } | |
| 818 } | |
| 819 | |
| 820 bool SQLitePersistentCookieStore::Backend::EnsureDatabaseVersion() { | |
| 821 // Version check. | |
| 822 if (!meta_table_.Init( | |
| 823 db_.get(), kCurrentVersionNumber, kCompatibleVersionNumber)) { | |
| 824 return false; | |
| 825 } | |
| 826 | |
| 827 if (meta_table_.GetCompatibleVersionNumber() > kCurrentVersionNumber) { | |
| 828 LOG(WARNING) << "Cookie database is too new."; | |
| 829 return false; | |
| 830 } | |
| 831 | |
| 832 int cur_version = meta_table_.GetVersionNumber(); | |
| 833 if (cur_version == 2) { | |
| 834 sql::Transaction transaction(db_.get()); | |
| 835 if (!transaction.Begin()) | |
| 836 return false; | |
| 837 if (!db_->Execute("ALTER TABLE cookies ADD COLUMN last_access_utc " | |
| 838 "INTEGER DEFAULT 0") || | |
| 839 !db_->Execute("UPDATE cookies SET last_access_utc = creation_utc")) { | |
| 840 LOG(WARNING) << "Unable to update cookie database to version 3."; | |
| 841 return false; | |
| 842 } | |
| 843 ++cur_version; | |
| 844 meta_table_.SetVersionNumber(cur_version); | |
| 845 meta_table_.SetCompatibleVersionNumber( | |
| 846 std::min(cur_version, kCompatibleVersionNumber)); | |
| 847 transaction.Commit(); | |
| 848 } | |
| 849 | |
| 850 if (cur_version == 3) { | |
| 851 // The time epoch changed for Mac & Linux in this version to match Windows. | |
| 852 // This patch came after the main epoch change happened, so some | |
| 853 // developers have "good" times for cookies added by the more recent | |
| 854 // versions. So we have to be careful to only update times that are under | |
| 855 // the old system (which will appear to be from before 1970 in the new | |
| 856 // system). The magic number used below is 1970 in our time units. | |
| 857 sql::Transaction transaction(db_.get()); | |
| 858 transaction.Begin(); | |
| 859 #if !defined(OS_WIN) | |
| 860 ignore_result(db_->Execute( | |
| 861 "UPDATE cookies " | |
| 862 "SET creation_utc = creation_utc + 11644473600000000 " | |
| 863 "WHERE rowid IN " | |
| 864 "(SELECT rowid FROM cookies WHERE " | |
| 865 "creation_utc > 0 AND creation_utc < 11644473600000000)")); | |
| 866 ignore_result(db_->Execute( | |
| 867 "UPDATE cookies " | |
| 868 "SET expires_utc = expires_utc + 11644473600000000 " | |
| 869 "WHERE rowid IN " | |
| 870 "(SELECT rowid FROM cookies WHERE " | |
| 871 "expires_utc > 0 AND expires_utc < 11644473600000000)")); | |
| 872 ignore_result(db_->Execute( | |
| 873 "UPDATE cookies " | |
| 874 "SET last_access_utc = last_access_utc + 11644473600000000 " | |
| 875 "WHERE rowid IN " | |
| 876 "(SELECT rowid FROM cookies WHERE " | |
| 877 "last_access_utc > 0 AND last_access_utc < 11644473600000000)")); | |
| 878 #endif | |
| 879 ++cur_version; | |
| 880 meta_table_.SetVersionNumber(cur_version); | |
| 881 transaction.Commit(); | |
| 882 } | |
| 883 | |
| 884 if (cur_version == 4) { | |
| 885 const base::TimeTicks start_time = base::TimeTicks::Now(); | |
| 886 sql::Transaction transaction(db_.get()); | |
| 887 if (!transaction.Begin()) | |
| 888 return false; | |
| 889 if (!db_->Execute("ALTER TABLE cookies " | |
| 890 "ADD COLUMN has_expires INTEGER DEFAULT 1") || | |
| 891 !db_->Execute("ALTER TABLE cookies " | |
| 892 "ADD COLUMN persistent INTEGER DEFAULT 1")) { | |
| 893 LOG(WARNING) << "Unable to update cookie database to version 5."; | |
| 894 return false; | |
| 895 } | |
| 896 ++cur_version; | |
| 897 meta_table_.SetVersionNumber(cur_version); | |
| 898 meta_table_.SetCompatibleVersionNumber( | |
| 899 std::min(cur_version, kCompatibleVersionNumber)); | |
| 900 transaction.Commit(); | |
| 901 UMA_HISTOGRAM_TIMES("Cookie.TimeDatabaseMigrationToV5", | |
| 902 base::TimeTicks::Now() - start_time); | |
| 903 } | |
| 904 | |
| 905 if (cur_version == 5) { | |
| 906 const base::TimeTicks start_time = base::TimeTicks::Now(); | |
| 907 sql::Transaction transaction(db_.get()); | |
| 908 if (!transaction.Begin()) | |
| 909 return false; | |
| 910 // Alter the table to add the priority column with a default value. | |
| 911 std::string stmt(base::StringPrintf( | |
| 912 "ALTER TABLE cookies ADD COLUMN priority INTEGER DEFAULT %d", | |
| 913 CookiePriorityToDBCookiePriority(net::COOKIE_PRIORITY_DEFAULT))); | |
| 914 if (!db_->Execute(stmt.c_str())) { | |
| 915 LOG(WARNING) << "Unable to update cookie database to version 6."; | |
| 916 return false; | |
| 917 } | |
| 918 ++cur_version; | |
| 919 meta_table_.SetVersionNumber(cur_version); | |
| 920 meta_table_.SetCompatibleVersionNumber( | |
| 921 std::min(cur_version, kCompatibleVersionNumber)); | |
| 922 transaction.Commit(); | |
| 923 UMA_HISTOGRAM_TIMES("Cookie.TimeDatabaseMigrationToV6", | |
| 924 base::TimeTicks::Now() - start_time); | |
| 925 } | |
| 926 | |
| 927 if (cur_version == 6) { | |
| 928 const base::TimeTicks start_time = base::TimeTicks::Now(); | |
| 929 sql::Transaction transaction(db_.get()); | |
| 930 if (!transaction.Begin()) | |
| 931 return false; | |
| 932 // Alter the table to add empty "encrypted value" column. | |
| 933 if (!db_->Execute("ALTER TABLE cookies " | |
| 934 "ADD COLUMN encrypted_value BLOB DEFAULT ''")) { | |
| 935 LOG(WARNING) << "Unable to update cookie database to version 7."; | |
| 936 return false; | |
| 937 } | |
| 938 ++cur_version; | |
| 939 meta_table_.SetVersionNumber(cur_version); | |
| 940 meta_table_.SetCompatibleVersionNumber( | |
| 941 std::min(cur_version, kCompatibleVersionNumber)); | |
| 942 transaction.Commit(); | |
| 943 UMA_HISTOGRAM_TIMES("Cookie.TimeDatabaseMigrationToV7", | |
| 944 base::TimeTicks::Now() - start_time); | |
| 945 } | |
| 946 | |
| 947 if (cur_version == 7) { | |
| 948 const base::TimeTicks start_time = base::TimeTicks::Now(); | |
| 949 sql::Transaction transaction(db_.get()); | |
| 950 if (!transaction.Begin()) | |
| 951 return false; | |
| 952 // Alter the table to add a 'firstpartyonly' column. | |
| 953 if (!db_->Execute( | |
| 954 "ALTER TABLE cookies " | |
| 955 "ADD COLUMN firstpartyonly INTEGER DEFAULT 0")) { | |
| 956 LOG(WARNING) << "Unable to update cookie database to version 8."; | |
| 957 return false; | |
| 958 } | |
| 959 ++cur_version; | |
| 960 meta_table_.SetVersionNumber(cur_version); | |
| 961 meta_table_.SetCompatibleVersionNumber( | |
| 962 std::min(cur_version, kCompatibleVersionNumber)); | |
| 963 transaction.Commit(); | |
| 964 UMA_HISTOGRAM_TIMES("Cookie.TimeDatabaseMigrationToV8", | |
| 965 base::TimeTicks::Now() - start_time); | |
| 966 } | |
| 967 | |
| 968 if (cur_version == 8) { | |
| 969 const base::TimeTicks start_time = base::TimeTicks::Now(); | |
| 970 sql::Transaction transaction(db_.get()); | |
| 971 if (!transaction.Begin()) | |
| 972 return false; | |
| 973 | |
| 974 if (!db_->Execute("DROP INDEX IF EXISTS cookie_times")) { | |
| 975 LOG(WARNING) | |
| 976 << "Unable to drop table cookie_times in update to version 9."; | |
| 977 return false; | |
| 978 } | |
| 979 | |
| 980 if (!db_->Execute( | |
| 981 "CREATE INDEX IF NOT EXISTS domain ON cookies(host_key)")) { | |
| 982 LOG(WARNING) << "Unable to create index domain in update to version 9."; | |
| 983 return false; | |
| 984 } | |
| 985 | |
| 986 #if defined(OS_IOS) | |
| 987 // iOS 8.1 and older doesn't support partial indices. iOS 8.2 supports | |
| 988 // partial indices. | |
| 989 if (!db_->Execute( | |
| 990 "CREATE INDEX IF NOT EXISTS is_transient ON cookies(persistent)")) { | |
| 991 #else | |
| 992 if (!db_->Execute( | |
| 993 "CREATE INDEX IF NOT EXISTS is_transient ON cookies(persistent) " | |
| 994 "where persistent != 1")) { | |
| 995 #endif | |
| 996 LOG(WARNING) | |
| 997 << "Unable to create index is_transient in update to version 9."; | |
| 998 return false; | |
| 999 } | |
| 1000 ++cur_version; | |
| 1001 meta_table_.SetVersionNumber(cur_version); | |
| 1002 meta_table_.SetCompatibleVersionNumber( | |
| 1003 std::min(cur_version, kCompatibleVersionNumber)); | |
| 1004 transaction.Commit(); | |
| 1005 UMA_HISTOGRAM_TIMES("Cookie.TimeDatabaseMigrationToV9", | |
| 1006 base::TimeTicks::Now() - start_time); | |
| 1007 } | |
| 1008 | |
| 1009 // Put future migration cases here. | |
| 1010 | |
| 1011 if (cur_version < kCurrentVersionNumber) { | |
| 1012 UMA_HISTOGRAM_COUNTS_100("Cookie.CorruptMetaTable", 1); | |
| 1013 | |
| 1014 meta_table_.Reset(); | |
| 1015 db_.reset(new sql::Connection); | |
| 1016 if (!sql::Connection::Delete(path_) || | |
| 1017 !db_->Open(path_) || | |
| 1018 !meta_table_.Init( | |
| 1019 db_.get(), kCurrentVersionNumber, kCompatibleVersionNumber)) { | |
| 1020 UMA_HISTOGRAM_COUNTS_100("Cookie.CorruptMetaTableRecoveryFailed", 1); | |
| 1021 NOTREACHED() << "Unable to reset the cookie DB."; | |
| 1022 meta_table_.Reset(); | |
| 1023 db_.reset(); | |
| 1024 return false; | |
| 1025 } | |
| 1026 } | |
| 1027 | |
| 1028 return true; | |
| 1029 } | |
| 1030 | |
| 1031 void SQLitePersistentCookieStore::Backend::AddCookie( | |
| 1032 const net::CanonicalCookie& cc) { | |
| 1033 BatchOperation(PendingOperation::COOKIE_ADD, cc); | |
| 1034 } | |
| 1035 | |
| 1036 void SQLitePersistentCookieStore::Backend::UpdateCookieAccessTime( | |
| 1037 const net::CanonicalCookie& cc) { | |
| 1038 BatchOperation(PendingOperation::COOKIE_UPDATEACCESS, cc); | |
| 1039 } | |
| 1040 | |
| 1041 void SQLitePersistentCookieStore::Backend::DeleteCookie( | |
| 1042 const net::CanonicalCookie& cc) { | |
| 1043 BatchOperation(PendingOperation::COOKIE_DELETE, cc); | |
| 1044 } | |
| 1045 | |
| 1046 void SQLitePersistentCookieStore::Backend::BatchOperation( | |
| 1047 PendingOperation::OperationType op, | |
| 1048 const net::CanonicalCookie& cc) { | |
| 1049 // Commit every 30 seconds. | |
| 1050 static const int kCommitIntervalMs = 30 * 1000; | |
| 1051 // Commit right away if we have more than 512 outstanding operations. | |
| 1052 static const size_t kCommitAfterBatchSize = 512; | |
| 1053 DCHECK(!background_task_runner_->RunsTasksOnCurrentThread()); | |
| 1054 | |
| 1055 // We do a full copy of the cookie here, and hopefully just here. | |
| 1056 scoped_ptr<PendingOperation> po(new PendingOperation(op, cc)); | |
| 1057 | |
| 1058 PendingOperationsList::size_type num_pending; | |
| 1059 { | |
| 1060 base::AutoLock locked(lock_); | |
| 1061 pending_.push_back(po.release()); | |
| 1062 num_pending = ++num_pending_; | |
| 1063 } | |
| 1064 | |
| 1065 if (num_pending == 1) { | |
| 1066 // We've gotten our first entry for this batch, fire off the timer. | |
| 1067 if (!background_task_runner_->PostDelayedTask( | |
| 1068 FROM_HERE, base::Bind(&Backend::Commit, this), | |
| 1069 base::TimeDelta::FromMilliseconds(kCommitIntervalMs))) { | |
| 1070 NOTREACHED() << "background_task_runner_ is not running."; | |
| 1071 } | |
| 1072 } else if (num_pending == kCommitAfterBatchSize) { | |
| 1073 // We've reached a big enough batch, fire off a commit now. | |
| 1074 PostBackgroundTask(FROM_HERE, base::Bind(&Backend::Commit, this)); | |
| 1075 } | |
| 1076 } | |
| 1077 | |
| 1078 void SQLitePersistentCookieStore::Backend::Commit() { | |
| 1079 DCHECK(background_task_runner_->RunsTasksOnCurrentThread()); | |
| 1080 | |
| 1081 PendingOperationsList ops; | |
| 1082 { | |
| 1083 base::AutoLock locked(lock_); | |
| 1084 pending_.swap(ops); | |
| 1085 num_pending_ = 0; | |
| 1086 } | |
| 1087 | |
| 1088 // Maybe an old timer fired or we are already Close()'ed. | |
| 1089 if (!db_.get() || ops.empty()) | |
| 1090 return; | |
| 1091 | |
| 1092 sql::Statement add_smt(db_->GetCachedStatement( | |
| 1093 SQL_FROM_HERE, | |
| 1094 "INSERT INTO cookies (creation_utc, host_key, name, value, " | |
| 1095 "encrypted_value, path, expires_utc, secure, httponly, firstpartyonly, " | |
| 1096 "last_access_utc, has_expires, persistent, priority) " | |
| 1097 "VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?)")); | |
| 1098 if (!add_smt.is_valid()) | |
| 1099 return; | |
| 1100 | |
| 1101 sql::Statement update_access_smt(db_->GetCachedStatement(SQL_FROM_HERE, | |
| 1102 "UPDATE cookies SET last_access_utc=? WHERE creation_utc=?")); | |
| 1103 if (!update_access_smt.is_valid()) | |
| 1104 return; | |
| 1105 | |
| 1106 sql::Statement del_smt(db_->GetCachedStatement(SQL_FROM_HERE, | |
| 1107 "DELETE FROM cookies WHERE creation_utc=?")); | |
| 1108 if (!del_smt.is_valid()) | |
| 1109 return; | |
| 1110 | |
| 1111 sql::Transaction transaction(db_.get()); | |
| 1112 if (!transaction.Begin()) | |
| 1113 return; | |
| 1114 | |
| 1115 for (PendingOperationsList::iterator it = ops.begin(); | |
| 1116 it != ops.end(); ++it) { | |
| 1117 // Free the cookies as we commit them to the database. | |
| 1118 scoped_ptr<PendingOperation> po(*it); | |
| 1119 switch (po->op()) { | |
| 1120 case PendingOperation::COOKIE_ADD: | |
| 1121 cookies_per_origin_[ | |
| 1122 CookieOrigin(po->cc().Domain(), po->cc().IsSecure())]++; | |
| 1123 add_smt.Reset(true); | |
| 1124 add_smt.BindInt64(0, po->cc().CreationDate().ToInternalValue()); | |
| 1125 add_smt.BindString(1, po->cc().Domain()); | |
| 1126 add_smt.BindString(2, po->cc().Name()); | |
| 1127 if (crypto_) { | |
| 1128 std::string encrypted_value; | |
| 1129 add_smt.BindCString(3, ""); // value | |
| 1130 crypto_->EncryptString(po->cc().Value(), &encrypted_value); | |
| 1131 // BindBlob() immediately makes an internal copy of the data. | |
| 1132 add_smt.BindBlob(4, encrypted_value.data(), | |
| 1133 static_cast<int>(encrypted_value.length())); | |
| 1134 } else { | |
| 1135 add_smt.BindString(3, po->cc().Value()); | |
| 1136 add_smt.BindBlob(4, "", 0); // encrypted_value | |
| 1137 } | |
| 1138 add_smt.BindString(5, po->cc().Path()); | |
| 1139 add_smt.BindInt64(6, po->cc().ExpiryDate().ToInternalValue()); | |
| 1140 add_smt.BindInt(7, po->cc().IsSecure()); | |
| 1141 add_smt.BindInt(8, po->cc().IsHttpOnly()); | |
| 1142 add_smt.BindInt(9, po->cc().IsFirstPartyOnly()); | |
| 1143 add_smt.BindInt64(10, po->cc().LastAccessDate().ToInternalValue()); | |
| 1144 add_smt.BindInt(11, po->cc().IsPersistent()); | |
| 1145 add_smt.BindInt(12, po->cc().IsPersistent()); | |
| 1146 add_smt.BindInt(13, | |
| 1147 CookiePriorityToDBCookiePriority(po->cc().Priority())); | |
| 1148 if (!add_smt.Run()) | |
| 1149 NOTREACHED() << "Could not add a cookie to the DB."; | |
| 1150 break; | |
| 1151 | |
| 1152 case PendingOperation::COOKIE_UPDATEACCESS: | |
| 1153 update_access_smt.Reset(true); | |
| 1154 update_access_smt.BindInt64(0, | |
| 1155 po->cc().LastAccessDate().ToInternalValue()); | |
| 1156 update_access_smt.BindInt64(1, | |
| 1157 po->cc().CreationDate().ToInternalValue()); | |
| 1158 if (!update_access_smt.Run()) | |
| 1159 NOTREACHED() << "Could not update cookie last access time in the DB."; | |
| 1160 break; | |
| 1161 | |
| 1162 case PendingOperation::COOKIE_DELETE: | |
| 1163 cookies_per_origin_[ | |
| 1164 CookieOrigin(po->cc().Domain(), po->cc().IsSecure())]--; | |
| 1165 del_smt.Reset(true); | |
| 1166 del_smt.BindInt64(0, po->cc().CreationDate().ToInternalValue()); | |
| 1167 if (!del_smt.Run()) | |
| 1168 NOTREACHED() << "Could not delete a cookie from the DB."; | |
| 1169 break; | |
| 1170 | |
| 1171 default: | |
| 1172 NOTREACHED(); | |
| 1173 break; | |
| 1174 } | |
| 1175 } | |
| 1176 bool succeeded = transaction.Commit(); | |
| 1177 UMA_HISTOGRAM_ENUMERATION("Cookie.BackingStoreUpdateResults", | |
| 1178 succeeded ? 0 : 1, 2); | |
| 1179 } | |
| 1180 | |
| 1181 void SQLitePersistentCookieStore::Backend::Flush( | |
| 1182 const base::Closure& callback) { | |
| 1183 DCHECK(!background_task_runner_->RunsTasksOnCurrentThread()); | |
| 1184 PostBackgroundTask(FROM_HERE, base::Bind(&Backend::Commit, this)); | |
| 1185 | |
| 1186 if (!callback.is_null()) { | |
| 1187 // We want the completion task to run immediately after Commit() returns. | |
| 1188 // Posting it from here means there is less chance of another task getting | |
| 1189 // onto the message queue first, than if we posted it from Commit() itself. | |
| 1190 PostBackgroundTask(FROM_HERE, callback); | |
| 1191 } | |
| 1192 } | |
| 1193 | |
| 1194 // Fire off a close message to the background runner. We could still have a | |
| 1195 // pending commit timer or Load operations holding references on us, but if/when | |
| 1196 // this fires we will already have been cleaned up and it will be ignored. | |
| 1197 void SQLitePersistentCookieStore::Backend::Close() { | |
| 1198 if (background_task_runner_->RunsTasksOnCurrentThread()) { | |
| 1199 InternalBackgroundClose(); | |
| 1200 } else { | |
| 1201 // Must close the backend on the background runner. | |
| 1202 PostBackgroundTask(FROM_HERE, | |
| 1203 base::Bind(&Backend::InternalBackgroundClose, this)); | |
| 1204 } | |
| 1205 } | |
| 1206 | |
| 1207 void SQLitePersistentCookieStore::Backend::InternalBackgroundClose() { | |
| 1208 DCHECK(background_task_runner_->RunsTasksOnCurrentThread()); | |
| 1209 // Commit any pending operations | |
| 1210 Commit(); | |
| 1211 | |
| 1212 if (!force_keep_session_state_ && special_storage_policy_.get() && | |
| 1213 special_storage_policy_->HasSessionOnlyOrigins()) { | |
| 1214 DeleteSessionCookiesOnShutdown(); | |
| 1215 } | |
| 1216 | |
| 1217 meta_table_.Reset(); | |
| 1218 db_.reset(); | |
| 1219 } | |
| 1220 | |
| 1221 void SQLitePersistentCookieStore::Backend::DeleteSessionCookiesOnShutdown() { | |
| 1222 DCHECK(background_task_runner_->RunsTasksOnCurrentThread()); | |
| 1223 | |
| 1224 if (!db_) | |
| 1225 return; | |
| 1226 | |
| 1227 if (!special_storage_policy_.get()) | |
| 1228 return; | |
| 1229 | |
| 1230 sql::Statement del_smt(db_->GetCachedStatement( | |
| 1231 SQL_FROM_HERE, "DELETE FROM cookies WHERE host_key=? AND secure=?")); | |
| 1232 if (!del_smt.is_valid()) { | |
| 1233 LOG(WARNING) << "Unable to delete cookies on shutdown."; | |
| 1234 return; | |
| 1235 } | |
| 1236 | |
| 1237 sql::Transaction transaction(db_.get()); | |
| 1238 if (!transaction.Begin()) { | |
| 1239 LOG(WARNING) << "Unable to delete cookies on shutdown."; | |
| 1240 return; | |
| 1241 } | |
| 1242 | |
| 1243 for (CookiesPerOriginMap::iterator it = cookies_per_origin_.begin(); | |
| 1244 it != cookies_per_origin_.end(); ++it) { | |
| 1245 if (it->second <= 0) { | |
| 1246 DCHECK_EQ(0, it->second); | |
| 1247 continue; | |
| 1248 } | |
| 1249 const GURL url(net::cookie_util::CookieOriginToURL(it->first.first, | |
| 1250 it->first.second)); | |
| 1251 if (!url.is_valid() || !special_storage_policy_->IsStorageSessionOnly(url)) | |
| 1252 continue; | |
| 1253 | |
| 1254 del_smt.Reset(true); | |
| 1255 del_smt.BindString(0, it->first.first); | |
| 1256 del_smt.BindInt(1, it->first.second); | |
| 1257 if (!del_smt.Run()) | |
| 1258 NOTREACHED() << "Could not delete a cookie from the DB."; | |
| 1259 } | |
| 1260 | |
| 1261 if (!transaction.Commit()) | |
| 1262 LOG(WARNING) << "Unable to delete cookies on shutdown."; | |
| 1263 } | |
| 1264 | |
| 1265 void SQLitePersistentCookieStore::Backend::DatabaseErrorCallback( | |
| 1266 int error, | |
| 1267 sql::Statement* stmt) { | |
| 1268 DCHECK(background_task_runner_->RunsTasksOnCurrentThread()); | |
| 1269 | |
| 1270 if (!sql::IsErrorCatastrophic(error)) | |
| 1271 return; | |
| 1272 | |
| 1273 // TODO(shess): Running KillDatabase() multiple times should be | |
| 1274 // safe. | |
| 1275 if (corruption_detected_) | |
| 1276 return; | |
| 1277 | |
| 1278 corruption_detected_ = true; | |
| 1279 | |
| 1280 // Don't just do the close/delete here, as we are being called by |db| and | |
| 1281 // that seems dangerous. | |
| 1282 // TODO(shess): Consider just calling RazeAndClose() immediately. | |
| 1283 // db_ may not be safe to reset at this point, but RazeAndClose() | |
| 1284 // would cause the stack to unwind safely with errors. | |
| 1285 PostBackgroundTask(FROM_HERE, base::Bind(&Backend::KillDatabase, this)); | |
| 1286 } | |
| 1287 | |
| 1288 void SQLitePersistentCookieStore::Backend::KillDatabase() { | |
| 1289 DCHECK(background_task_runner_->RunsTasksOnCurrentThread()); | |
| 1290 | |
| 1291 if (db_) { | |
| 1292 // This Backend will now be in-memory only. In a future run we will recreate | |
| 1293 // the database. Hopefully things go better then! | |
| 1294 bool success = db_->RazeAndClose(); | |
| 1295 UMA_HISTOGRAM_BOOLEAN("Cookie.KillDatabaseResult", success); | |
| 1296 meta_table_.Reset(); | |
| 1297 db_.reset(); | |
| 1298 } | |
| 1299 } | |
| 1300 | |
| 1301 void SQLitePersistentCookieStore::Backend::SetForceKeepSessionState() { | |
| 1302 base::AutoLock locked(lock_); | |
| 1303 force_keep_session_state_ = true; | |
| 1304 } | |
| 1305 | |
| 1306 void SQLitePersistentCookieStore::Backend::DeleteSessionCookiesOnStartup() { | |
| 1307 DCHECK(background_task_runner_->RunsTasksOnCurrentThread()); | |
| 1308 if (!db_->Execute("DELETE FROM cookies WHERE persistent != 1")) | |
| 1309 LOG(WARNING) << "Unable to delete session cookies."; | |
| 1310 } | |
| 1311 | |
| 1312 void SQLitePersistentCookieStore::Backend::PostBackgroundTask( | |
| 1313 const tracked_objects::Location& origin, const base::Closure& task) { | |
| 1314 if (!background_task_runner_->PostTask(origin, task)) { | |
| 1315 LOG(WARNING) << "Failed to post task from " << origin.ToString() | |
| 1316 << " to background_task_runner_."; | |
| 1317 } | |
| 1318 } | |
| 1319 | |
| 1320 void SQLitePersistentCookieStore::Backend::PostClientTask( | |
| 1321 const tracked_objects::Location& origin, const base::Closure& task) { | |
| 1322 if (!client_task_runner_->PostTask(origin, task)) { | |
| 1323 LOG(WARNING) << "Failed to post task from " << origin.ToString() | |
| 1324 << " to client_task_runner_."; | |
| 1325 } | |
| 1326 } | |
| 1327 | |
| 1328 void SQLitePersistentCookieStore::Backend::FinishedLoadingCookies( | |
| 1329 const LoadedCallback& loaded_callback, | |
| 1330 bool success) { | |
| 1331 PostClientTask(FROM_HERE, base::Bind(&Backend::CompleteLoadInForeground, this, | |
| 1332 loaded_callback, success)); | |
| 1333 } | |
| 1334 | |
| 1335 SQLitePersistentCookieStore::SQLitePersistentCookieStore( | |
| 1336 const base::FilePath& path, | |
| 1337 const scoped_refptr<base::SequencedTaskRunner>& client_task_runner, | |
| 1338 const scoped_refptr<base::SequencedTaskRunner>& background_task_runner, | |
| 1339 bool restore_old_session_cookies, | |
| 1340 storage::SpecialStoragePolicy* special_storage_policy, | |
| 1341 net::CookieCryptoDelegate* crypto_delegate) | |
| 1342 : backend_(new Backend(path, | |
| 1343 client_task_runner, | |
| 1344 background_task_runner, | |
| 1345 restore_old_session_cookies, | |
| 1346 special_storage_policy, | |
| 1347 crypto_delegate)) { | |
| 1348 } | |
| 1349 | |
| 1350 void SQLitePersistentCookieStore::Load(const LoadedCallback& loaded_callback) { | |
| 1351 backend_->Load(loaded_callback); | |
| 1352 } | |
| 1353 | |
| 1354 void SQLitePersistentCookieStore::LoadCookiesForKey( | |
| 1355 const std::string& key, | |
| 1356 const LoadedCallback& loaded_callback) { | |
| 1357 backend_->LoadCookiesForKey(key, loaded_callback); | |
| 1358 } | |
| 1359 | |
| 1360 void SQLitePersistentCookieStore::AddCookie(const net::CanonicalCookie& cc) { | |
| 1361 backend_->AddCookie(cc); | |
| 1362 } | |
| 1363 | |
| 1364 void SQLitePersistentCookieStore::UpdateCookieAccessTime( | |
| 1365 const net::CanonicalCookie& cc) { | |
| 1366 backend_->UpdateCookieAccessTime(cc); | |
| 1367 } | |
| 1368 | |
| 1369 void SQLitePersistentCookieStore::DeleteCookie(const net::CanonicalCookie& cc) { | |
| 1370 backend_->DeleteCookie(cc); | |
| 1371 } | |
| 1372 | |
| 1373 void SQLitePersistentCookieStore::SetForceKeepSessionState() { | |
| 1374 backend_->SetForceKeepSessionState(); | |
| 1375 } | |
| 1376 | |
| 1377 void SQLitePersistentCookieStore::Flush(const base::Closure& callback) { | |
| 1378 backend_->Flush(callback); | |
| 1379 } | |
| 1380 | |
| 1381 SQLitePersistentCookieStore::~SQLitePersistentCookieStore() { | |
| 1382 backend_->Close(); | |
| 1383 // We release our reference to the Backend, though it will probably still have | |
| 1384 // a reference if the background runner has not run Close() yet. | |
| 1385 } | |
| 1386 | |
| 1387 CookieStoreConfig::CookieStoreConfig() | |
| 1388 : session_cookie_mode(EPHEMERAL_SESSION_COOKIES), | |
| 1389 crypto_delegate(NULL) { | |
| 1390 // Default to an in-memory cookie store. | |
| 1391 } | |
| 1392 | |
| 1393 CookieStoreConfig::CookieStoreConfig( | |
| 1394 const base::FilePath& path, | |
| 1395 SessionCookieMode session_cookie_mode, | |
| 1396 storage::SpecialStoragePolicy* storage_policy, | |
| 1397 net::CookieMonsterDelegate* cookie_delegate) | |
| 1398 : path(path), | |
| 1399 session_cookie_mode(session_cookie_mode), | |
| 1400 storage_policy(storage_policy), | |
| 1401 cookie_delegate(cookie_delegate), | |
| 1402 crypto_delegate(NULL) { | |
| 1403 CHECK(!path.empty() || session_cookie_mode == EPHEMERAL_SESSION_COOKIES); | |
| 1404 } | |
| 1405 | |
| 1406 CookieStoreConfig::~CookieStoreConfig() { | |
| 1407 } | |
| 1408 | |
| 1409 net::CookieStore* CreateCookieStore(const CookieStoreConfig& config) { | |
| 1410 // TODO(bcwhite): Remove ScopedTracker below once crbug.com/483686 is fixed. | |
| 1411 tracked_objects::ScopedTracker tracking_profile( | |
| 1412 FROM_HERE_WITH_EXPLICIT_FUNCTION("483686 content::CreateCookieStore")); | |
| 1413 | |
| 1414 net::CookieMonster* cookie_monster = NULL; | |
| 1415 | |
| 1416 if (config.path.empty()) { | |
| 1417 // Empty path means in-memory store. | |
| 1418 cookie_monster = new net::CookieMonster(NULL, config.cookie_delegate.get()); | |
| 1419 } else { | |
| 1420 scoped_refptr<base::SequencedTaskRunner> client_task_runner = | |
| 1421 config.client_task_runner; | |
| 1422 scoped_refptr<base::SequencedTaskRunner> background_task_runner = | |
| 1423 config.background_task_runner; | |
| 1424 | |
| 1425 if (!client_task_runner.get()) { | |
| 1426 client_task_runner = | |
| 1427 BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO); | |
| 1428 } | |
| 1429 | |
| 1430 if (!background_task_runner.get()) { | |
| 1431 background_task_runner = | |
| 1432 BrowserThread::GetBlockingPool()->GetSequencedTaskRunner( | |
| 1433 BrowserThread::GetBlockingPool()->GetSequenceToken()); | |
| 1434 } | |
| 1435 | |
| 1436 SQLitePersistentCookieStore* persistent_store = | |
| 1437 new SQLitePersistentCookieStore( | |
| 1438 config.path, | |
| 1439 client_task_runner, | |
| 1440 background_task_runner, | |
| 1441 (config.session_cookie_mode == | |
| 1442 CookieStoreConfig::RESTORED_SESSION_COOKIES), | |
| 1443 config.storage_policy.get(), | |
| 1444 config.crypto_delegate); | |
| 1445 | |
| 1446 cookie_monster = | |
| 1447 new net::CookieMonster(persistent_store, config.cookie_delegate.get()); | |
| 1448 if ((config.session_cookie_mode == | |
| 1449 CookieStoreConfig::PERSISTANT_SESSION_COOKIES) || | |
| 1450 (config.session_cookie_mode == | |
| 1451 CookieStoreConfig::RESTORED_SESSION_COOKIES)) { | |
| 1452 cookie_monster->SetPersistSessionCookies(true); | |
| 1453 } | |
| 1454 } | |
| 1455 | |
| 1456 return cookie_monster; | |
| 1457 } | |
| 1458 | |
| 1459 } // namespace content | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1016643004:
Moves SQLitePersistentCookieStore to net/extras/sqlite. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@cookies