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