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 "storage/browser/database/database_tracker.h" 6 7 #include <algorithm> 8 #include <vector> 9 10 #include "base/basictypes.h" 11 #include "base/bind.h" 12 #include "base/files/file.h" 13 #include "base/files/file_enumerator.h" 14 #include "base/files/file_util.h" 15 #include "base/message_loop/message_loop_proxy.h" 16 #include "base/strings/string_number_conversions.h" 17 #include "base/strings/utf_string_conversions.h" 18 #include "net/base/net_errors.h" 19 #include "sql/connection.h" 20 #include "sql/meta_table.h" 21 #include "sql/transaction.h" 22 #include "storage/browser/database/database_quota_client.h" 23 #include "storage/browser/database/database_util.h" 24 #include "storage/browser/database/databases_table.h" 25 #include "storage/browser/quota/quota_manager_proxy.h" 26 #include "storage/browser/quota/special_storage_policy.h" 27 #include "storage/common/database/database_identifier.h" 28 #include "third_party/sqlite/sqlite3.h" 29 30 namespace storage { 31 32 const base::FilePath::CharType kDatabaseDirectoryName[] = 33 FILE_PATH_LITERAL("databases"); 34 const base::FilePath::CharType kIncognitoDatabaseDirectoryName[] = 35 FILE_PATH_LITERAL("databases-incognito"); 36 const base::FilePath::CharType kTrackerDatabaseFileName[] = 37 FILE_PATH_LITERAL("Databases.db"); 38 static const int kCurrentVersion = 2; 39 static const int kCompatibleVersion = 1; 40 41 const base::FilePath::CharType kTemporaryDirectoryPrefix[] = 42 FILE_PATH_LITERAL("DeleteMe"); 43 const base::FilePath::CharType kTemporaryDirectoryPattern[] = 44 FILE_PATH_LITERAL("DeleteMe*"); 45 46 OriginInfo::OriginInfo() 47 : total_size_(0) {} 48 49 OriginInfo::OriginInfo(const OriginInfo& origin_info) 50 : origin_identifier_(origin_info.origin_identifier_), 51 total_size_(origin_info.total_size_), 52 database_info_(origin_info.database_info_) {} 53 54 OriginInfo::~OriginInfo() {} 55 56 void OriginInfo::GetAllDatabaseNames( 57 std::vector<base::string16>* databases) const { 58 for (DatabaseInfoMap::const_iterator it = database_info_.begin(); 59 it != database_info_.end(); it++) { 60 databases->push_back(it->first); 61 } 62 } 63 64 int64 OriginInfo::GetDatabaseSize(const base::string16& database_name) const { 65 DatabaseInfoMap::const_iterator it = database_info_.find(database_name); 66 if (it != database_info_.end()) 67 return it->second.first; 68 return 0; 69 } 70 71 base::string16 OriginInfo::GetDatabaseDescription( 72 const base::string16& database_name) const { 73 DatabaseInfoMap::const_iterator it = database_info_.find(database_name); 74 if (it != database_info_.end()) 75 return it->second.second; 76 return base::string16(); 77 } 78 79 OriginInfo::OriginInfo(const std::string& origin_identifier, int64 total_size) 80 : origin_identifier_(origin_identifier), total_size_(total_size) {} 81 82 DatabaseTracker::DatabaseTracker( 83 const base::FilePath& profile_path, 84 bool is_incognito, 85 storage::SpecialStoragePolicy* special_storage_policy, 86 storage::QuotaManagerProxy* quota_manager_proxy, 87 base::MessageLoopProxy* db_tracker_thread) 88 : is_initialized_(false), 89 is_incognito_(is_incognito), 90 force_keep_session_state_(false), 91 shutting_down_(false), 92 profile_path_(profile_path), 93 db_dir_(is_incognito_ 94 ? profile_path_.Append(kIncognitoDatabaseDirectoryName) 95 : profile_path_.Append(kDatabaseDirectoryName)), 96 db_(new sql::Connection()), 97 special_storage_policy_(special_storage_policy), 98 quota_manager_proxy_(quota_manager_proxy), 99 db_tracker_thread_(db_tracker_thread), 100 incognito_origin_directories_generator_(0) { 101 if (quota_manager_proxy) { 102 quota_manager_proxy->RegisterClient( 103 new DatabaseQuotaClient(db_tracker_thread, this)); 104 } 105 } 106 107 DatabaseTracker::~DatabaseTracker() { 108 DCHECK(dbs_to_be_deleted_.empty()); 109 DCHECK(deletion_callbacks_.empty()); 110 } 111 112 void DatabaseTracker::DatabaseOpened(const std::string& origin_identifier, 113 const base::string16& database_name, 114 const base::string16& database_description, 115 int64 estimated_size, 116 int64* database_size) { 117 if (shutting_down_ || !LazyInit()) { 118 *database_size = 0; 119 return; 120 } 121 122 if (quota_manager_proxy_.get()) 123 quota_manager_proxy_->NotifyStorageAccessed( 124 storage::QuotaClient::kDatabase, 125 storage::GetOriginFromIdentifier(origin_identifier), 126 storage::kStorageTypeTemporary); 127 128 InsertOrUpdateDatabaseDetails(origin_identifier, database_name, 129 database_description, estimated_size); 130 if (database_connections_.AddConnection(origin_identifier, database_name)) { 131 *database_size = SeedOpenDatabaseInfo(origin_identifier, 132 database_name, 133 database_description); 134 return; 135 } 136 *database_size = UpdateOpenDatabaseInfoAndNotify(origin_identifier, 137 database_name, 138 &database_description); 139 } 140 141 void DatabaseTracker::DatabaseModified(const std::string& origin_identifier, 142 const base::string16& database_name) { 143 if (!LazyInit()) 144 return; 145 UpdateOpenDatabaseSizeAndNotify(origin_identifier, database_name); 146 } 147 148 void DatabaseTracker::DatabaseClosed(const std::string& origin_identifier, 149 const base::string16& database_name) { 150 if (database_connections_.IsEmpty()) { 151 DCHECK(!is_initialized_); 152 return; 153 } 154 155 // We call NotifiyStorageAccessed when a db is opened and also when 156 // closed because we don't call it for read while open. 157 if (quota_manager_proxy_.get()) 158 quota_manager_proxy_->NotifyStorageAccessed( 159 storage::QuotaClient::kDatabase, 160 storage::GetOriginFromIdentifier(origin_identifier), 161 storage::kStorageTypeTemporary); 162 163 UpdateOpenDatabaseSizeAndNotify(origin_identifier, database_name); 164 if (database_connections_.RemoveConnection(origin_identifier, database_name)) 165 DeleteDatabaseIfNeeded(origin_identifier, database_name); 166 } 167 168 void DatabaseTracker::HandleSqliteError( 169 const std::string& origin_identifier, 170 const base::string16& database_name, 171 int error) { 172 // We only handle errors that indicate corruption and we 173 // do so with a heavy hand, we delete it. Any renderers/workers 174 // with this database open will receive a message to close it 175 // immediately, once all have closed, the files will be deleted. 176 // In the interim, all attempts to open a new connection to that 177 // database will fail. 178 // Note: the client-side filters out all but these two errors as 179 // a small optimization, see WebDatabaseObserverImpl::HandleSqliteError. 180 if (error == SQLITE_CORRUPT || error == SQLITE_NOTADB) { 181 DeleteDatabase(origin_identifier, database_name, 182 net::CompletionCallback()); 183 } 184 } 185 186 void DatabaseTracker::CloseDatabases(const DatabaseConnections& connections) { 187 if (database_connections_.IsEmpty()) { 188 DCHECK(!is_initialized_ || connections.IsEmpty()); 189 return; 190 } 191 192 // When being closed by this route, there's a chance that 193 // the tracker missed some DatabseModified calls. This method is used 194 // when a renderer crashes to cleanup its open resources. 195 // We need to examine what we have in connections for the 196 // size of each open databases and notify any differences between the 197 // actual file sizes now. 198 std::vector<std::pair<std::string, base::string16> > open_dbs; 199 connections.ListConnections(&open_dbs); 200 for (std::vector<std::pair<std::string, base::string16> >::iterator it = 201 open_dbs.begin(); it != open_dbs.end(); ++it) 202 UpdateOpenDatabaseSizeAndNotify(it->first, it->second); 203 204 std::vector<std::pair<std::string, base::string16> > closed_dbs; 205 database_connections_.RemoveConnections(connections, &closed_dbs); 206 for (std::vector<std::pair<std::string, base::string16> >::iterator it = 207 closed_dbs.begin(); it != closed_dbs.end(); ++it) { 208 DeleteDatabaseIfNeeded(it->first, it->second); 209 } 210 } 211 212 void DatabaseTracker::DeleteDatabaseIfNeeded( 213 const std::string& origin_identifier, 214 const base::string16& database_name) { 215 DCHECK(!database_connections_.IsDatabaseOpened(origin_identifier, 216 database_name)); 217 if (IsDatabaseScheduledForDeletion(origin_identifier, database_name)) { 218 DeleteClosedDatabase(origin_identifier, database_name); 219 dbs_to_be_deleted_[origin_identifier].erase(database_name); 220 if (dbs_to_be_deleted_[origin_identifier].empty()) 221 dbs_to_be_deleted_.erase(origin_identifier); 222 223 PendingDeletionCallbacks::iterator callback = deletion_callbacks_.begin(); 224 while (callback != deletion_callbacks_.end()) { 225 DatabaseSet::iterator found_origin = 226 callback->second.find(origin_identifier); 227 if (found_origin != callback->second.end()) { 228 std::set<base::string16>& databases = found_origin->second; 229 databases.erase(database_name); 230 if (databases.empty()) { 231 callback->second.erase(found_origin); 232 if (callback->second.empty()) { 233 net::CompletionCallback cb = callback->first; 234 cb.Run(net::OK); 235 callback = deletion_callbacks_.erase(callback); 236 continue; 237 } 238 } 239 } 240 241 ++callback; 242 } 243 } 244 } 245 246 void DatabaseTracker::AddObserver(Observer* observer) { 247 observers_.AddObserver(observer); 248 } 249 250 void DatabaseTracker::RemoveObserver(Observer* observer) { 251 // When we remove a listener, we do not know which cached information 252 // is still needed and which information can be discarded. So we just 253 // clear all caches and re-populate them as needed. 254 observers_.RemoveObserver(observer); 255 ClearAllCachedOriginInfo(); 256 } 257 258 void DatabaseTracker::CloseTrackerDatabaseAndClearCaches() { 259 ClearAllCachedOriginInfo(); 260 261 if (!is_incognito_) { 262 meta_table_.reset(NULL); 263 databases_table_.reset(NULL); 264 db_->Close(); 265 is_initialized_ = false; 266 } 267 } 268 269 base::string16 DatabaseTracker::GetOriginDirectory( 270 const std::string& origin_identifier) { 271 if (!is_incognito_) 272 return base::UTF8ToUTF16(origin_identifier); 273 274 OriginDirectoriesMap::const_iterator it = 275 incognito_origin_directories_.find(origin_identifier); 276 if (it != incognito_origin_directories_.end()) 277 return it->second; 278 279 base::string16 origin_directory = 280 base::IntToString16(incognito_origin_directories_generator_++); 281 incognito_origin_directories_[origin_identifier] = origin_directory; 282 return origin_directory; 283 } 284 285 base::FilePath DatabaseTracker::GetFullDBFilePath( 286 const std::string& origin_identifier, 287 const base::string16& database_name) { 288 DCHECK(!origin_identifier.empty()); 289 if (!LazyInit()) 290 return base::FilePath(); 291 292 int64 id = databases_table_->GetDatabaseID(origin_identifier, database_name); 293 if (id < 0) 294 return base::FilePath(); 295 296 return db_dir_.Append(base::FilePath::FromUTF16Unsafe( 297 GetOriginDirectory(origin_identifier))).AppendASCII( 298 base::Int64ToString(id)); 299 } 300 301 bool DatabaseTracker::GetOriginInfo(const std::string& origin_identifier, 302 OriginInfo* info) { 303 DCHECK(info); 304 CachedOriginInfo* cached_info = GetCachedOriginInfo(origin_identifier); 305 if (!cached_info) 306 return false; 307 *info = OriginInfo(*cached_info); 308 return true; 309 } 310 311 bool DatabaseTracker::GetAllOriginIdentifiers( 312 std::vector<std::string>* origin_identifiers) { 313 DCHECK(origin_identifiers); 314 DCHECK(origin_identifiers->empty()); 315 if (!LazyInit()) 316 return false; 317 return databases_table_->GetAllOriginIdentifiers(origin_identifiers); 318 } 319 320 bool DatabaseTracker::GetAllOriginsInfo( 321 std::vector<OriginInfo>* origins_info) { 322 DCHECK(origins_info); 323 DCHECK(origins_info->empty()); 324 325 std::vector<std::string> origins; 326 if (!GetAllOriginIdentifiers(&origins)) 327 return false; 328 329 for (std::vector<std::string>::const_iterator it = origins.begin(); 330 it != origins.end(); it++) { 331 CachedOriginInfo* origin_info = GetCachedOriginInfo(*it); 332 if (!origin_info) { 333 // Restore 'origins_info' to its initial state. 334 origins_info->clear(); 335 return false; 336 } 337 origins_info->push_back(OriginInfo(*origin_info)); 338 } 339 340 return true; 341 } 342 343 bool DatabaseTracker::DeleteClosedDatabase( 344 const std::string& origin_identifier, 345 const base::string16& database_name) { 346 if (!LazyInit()) 347 return false; 348 349 // Check if the database is opened by any renderer. 350 if (database_connections_.IsDatabaseOpened(origin_identifier, database_name)) 351 return false; 352 353 int64 db_file_size = quota_manager_proxy_.get() 354 ? GetDBFileSize(origin_identifier, database_name) 355 : 0; 356 357 // Try to delete the file on the hard drive. 358 base::FilePath db_file = GetFullDBFilePath(origin_identifier, database_name); 359 if (!sql::Connection::Delete(db_file)) 360 return false; 361 362 if (quota_manager_proxy_.get() && db_file_size) 363 quota_manager_proxy_->NotifyStorageModified( 364 storage::QuotaClient::kDatabase, 365 storage::GetOriginFromIdentifier(origin_identifier), 366 storage::kStorageTypeTemporary, 367 -db_file_size); 368 369 // Clean up the main database and invalidate the cached record. 370 databases_table_->DeleteDatabaseDetails(origin_identifier, database_name); 371 origins_info_map_.erase(origin_identifier); 372 373 std::vector<DatabaseDetails> details; 374 if (databases_table_->GetAllDatabaseDetailsForOriginIdentifier( 375 origin_identifier, &details) && details.empty()) { 376 // Try to delete the origin in case this was the last database. 377 DeleteOrigin(origin_identifier, false); 378 } 379 return true; 380 } 381 382 bool DatabaseTracker::DeleteOrigin(const std::string& origin_identifier, 383 bool force) { 384 if (!LazyInit()) 385 return false; 386 387 // Check if any database in this origin is opened by any renderer. 388 if (database_connections_.IsOriginUsed(origin_identifier) && !force) 389 return false; 390 391 int64 deleted_size = 0; 392 if (quota_manager_proxy_.get()) { 393 CachedOriginInfo* origin_info = GetCachedOriginInfo(origin_identifier); 394 if (origin_info) 395 deleted_size = origin_info->TotalSize(); 396 } 397 398 origins_info_map_.erase(origin_identifier); 399 base::FilePath origin_dir = db_dir_.AppendASCII(origin_identifier); 400 401 // Create a temporary directory to move possibly still existing databases to, 402 // as we can't delete the origin directory on windows if it contains opened 403 // files. 404 base::FilePath new_origin_dir; 405 base::CreateTemporaryDirInDir(db_dir_, 406 kTemporaryDirectoryPrefix, 407 &new_origin_dir); 408 base::FileEnumerator databases( 409 origin_dir, 410 false, 411 base::FileEnumerator::FILES); 412 for (base::FilePath database = databases.Next(); !database.empty(); 413 database = databases.Next()) { 414 base::FilePath new_file = new_origin_dir.Append(database.BaseName()); 415 base::Move(database, new_file); 416 } 417 base::DeleteFile(origin_dir, true); 418 base::DeleteFile(new_origin_dir, true); // might fail on windows. 419 420 databases_table_->DeleteOriginIdentifier(origin_identifier); 421 422 if (quota_manager_proxy_.get() && deleted_size) { 423 quota_manager_proxy_->NotifyStorageModified( 424 storage::QuotaClient::kDatabase, 425 storage::GetOriginFromIdentifier(origin_identifier), 426 storage::kStorageTypeTemporary, 427 -deleted_size); 428 } 429 430 return true; 431 } 432 433 bool DatabaseTracker::IsDatabaseScheduledForDeletion( 434 const std::string& origin_identifier, 435 const base::string16& database_name) { 436 DatabaseSet::iterator it = dbs_to_be_deleted_.find(origin_identifier); 437 if (it == dbs_to_be_deleted_.end()) 438 return false; 439 440 std::set<base::string16>& databases = it->second; 441 return (databases.find(database_name) != databases.end()); 442 } 443 444 bool DatabaseTracker::LazyInit() { 445 if (!is_initialized_ && !shutting_down_) { 446 DCHECK(!db_->is_open()); 447 DCHECK(!databases_table_.get()); 448 DCHECK(!meta_table_.get()); 449 450 // If there are left-over directories from failed deletion attempts, clean 451 // them up. 452 if (base::DirectoryExists(db_dir_)) { 453 base::FileEnumerator directories( 454 db_dir_, 455 false, 456 base::FileEnumerator::DIRECTORIES, 457 kTemporaryDirectoryPattern); 458 for (base::FilePath directory = directories.Next(); !directory.empty(); 459 directory = directories.Next()) { 460 base::DeleteFile(directory, true); 461 } 462 } 463 464 // If the tracker database exists, but it's corrupt or doesn't 465 // have a meta table, delete the database directory. 466 const base::FilePath kTrackerDatabaseFullPath = 467 db_dir_.Append(base::FilePath(kTrackerDatabaseFileName)); 468 if (base::DirectoryExists(db_dir_) && 469 base::PathExists(kTrackerDatabaseFullPath) && 470 (!db_->Open(kTrackerDatabaseFullPath) || 471 !sql::MetaTable::DoesTableExist(db_.get()))) { 472 db_->Close(); 473 if (!base::DeleteFile(db_dir_, true)) 474 return false; 475 } 476 477 db_->set_histogram_tag("DatabaseTracker"); 478 479 databases_table_.reset(new DatabasesTable(db_.get())); 480 meta_table_.reset(new sql::MetaTable()); 481 482 is_initialized_ = 483 base::CreateDirectory(db_dir_) && 484 (db_->is_open() || 485 (is_incognito_ ? db_->OpenInMemory() : 486 db_->Open(kTrackerDatabaseFullPath))) && 487 UpgradeToCurrentVersion(); 488 if (!is_initialized_) { 489 databases_table_.reset(NULL); 490 meta_table_.reset(NULL); 491 db_->Close(); 492 } 493 } 494 return is_initialized_; 495 } 496 497 bool DatabaseTracker::UpgradeToCurrentVersion() { 498 sql::Transaction transaction(db_.get()); 499 if (!transaction.Begin() || 500 !meta_table_->Init(db_.get(), kCurrentVersion, kCompatibleVersion) || 501 (meta_table_->GetCompatibleVersionNumber() > kCurrentVersion) || 502 !databases_table_->Init()) 503 return false; 504 505 if (meta_table_->GetVersionNumber() < kCurrentVersion) 506 meta_table_->SetVersionNumber(kCurrentVersion); 507 508 return transaction.Commit(); 509 } 510 511 void DatabaseTracker::InsertOrUpdateDatabaseDetails( 512 const std::string& origin_identifier, 513 const base::string16& database_name, 514 const base::string16& database_description, 515 int64 estimated_size) { 516 DatabaseDetails details; 517 if (!databases_table_->GetDatabaseDetails( 518 origin_identifier, database_name, &details)) { 519 details.origin_identifier = origin_identifier; 520 details.database_name = database_name; 521 details.description = database_description; 522 details.estimated_size = estimated_size; 523 databases_table_->InsertDatabaseDetails(details); 524 } else if ((details.description != database_description) || 525 (details.estimated_size != estimated_size)) { 526 details.description = database_description; 527 details.estimated_size = estimated_size; 528 databases_table_->UpdateDatabaseDetails(details); 529 } 530 } 531 532 void DatabaseTracker::ClearAllCachedOriginInfo() { 533 origins_info_map_.clear(); 534 } 535 536 DatabaseTracker::CachedOriginInfo* DatabaseTracker::MaybeGetCachedOriginInfo( 537 const std::string& origin_identifier, bool create_if_needed) { 538 if (!LazyInit()) 539 return NULL; 540 541 // Populate the cache with data for this origin if needed. 542 if (origins_info_map_.find(origin_identifier) == origins_info_map_.end()) { 543 if (!create_if_needed) 544 return NULL; 545 546 std::vector<DatabaseDetails> details; 547 if (!databases_table_->GetAllDatabaseDetailsForOriginIdentifier( 548 origin_identifier, &details)) { 549 return NULL; 550 } 551 552 CachedOriginInfo& origin_info = origins_info_map_[origin_identifier]; 553 origin_info.SetOriginIdentifier(origin_identifier); 554 for (std::vector<DatabaseDetails>::const_iterator it = details.begin(); 555 it != details.end(); it++) { 556 int64 db_file_size; 557 if (database_connections_.IsDatabaseOpened( 558 origin_identifier, it->database_name)) { 559 db_file_size = database_connections_.GetOpenDatabaseSize( 560 origin_identifier, it->database_name); 561 } else { 562 db_file_size = GetDBFileSize(origin_identifier, it->database_name); 563 } 564 origin_info.SetDatabaseSize(it->database_name, db_file_size); 565 origin_info.SetDatabaseDescription(it->database_name, it->description); 566 } 567 } 568 569 return &origins_info_map_[origin_identifier]; 570 } 571 572 int64 DatabaseTracker::GetDBFileSize(const std::string& origin_identifier, 573 const base::string16& database_name) { 574 base::FilePath db_file_name = GetFullDBFilePath(origin_identifier, 575 database_name); 576 int64 db_file_size = 0; 577 if (!base::GetFileSize(db_file_name, &db_file_size)) 578 db_file_size = 0; 579 return db_file_size; 580 } 581 582 int64 DatabaseTracker::SeedOpenDatabaseInfo( 583 const std::string& origin_id, const base::string16& name, 584 const base::string16& description) { 585 DCHECK(database_connections_.IsDatabaseOpened(origin_id, name)); 586 int64 size = GetDBFileSize(origin_id, name); 587 database_connections_.SetOpenDatabaseSize(origin_id, name, size); 588 CachedOriginInfo* info = MaybeGetCachedOriginInfo(origin_id, false); 589 if (info) { 590 info->SetDatabaseSize(name, size); 591 info->SetDatabaseDescription(name, description); 592 } 593 return size; 594 } 595 596 int64 DatabaseTracker::UpdateOpenDatabaseInfoAndNotify( 597 const std::string& origin_id, const base::string16& name, 598 const base::string16* opt_description) { 599 DCHECK(database_connections_.IsDatabaseOpened(origin_id, name)); 600 int64 new_size = GetDBFileSize(origin_id, name); 601 int64 old_size = database_connections_.GetOpenDatabaseSize(origin_id, name); 602 CachedOriginInfo* info = MaybeGetCachedOriginInfo(origin_id, false); 603 if (info && opt_description) 604 info->SetDatabaseDescription(name, *opt_description); 605 if (old_size != new_size) { 606 database_connections_.SetOpenDatabaseSize(origin_id, name, new_size); 607 if (info) 608 info->SetDatabaseSize(name, new_size); 609 if (quota_manager_proxy_.get()) 610 quota_manager_proxy_->NotifyStorageModified( 611 storage::QuotaClient::kDatabase, 612 storage::GetOriginFromIdentifier(origin_id), 613 storage::kStorageTypeTemporary, 614 new_size - old_size); 615 FOR_EACH_OBSERVER(Observer, observers_, OnDatabaseSizeChanged( 616 origin_id, name, new_size)); 617 } 618 return new_size; 619 } 620 621 void DatabaseTracker::ScheduleDatabaseForDeletion( 622 const std::string& origin_identifier, 623 const base::string16& database_name) { 624 DCHECK(database_connections_.IsDatabaseOpened(origin_identifier, 625 database_name)); 626 dbs_to_be_deleted_[origin_identifier].insert(database_name); 627 FOR_EACH_OBSERVER(Observer, observers_, OnDatabaseScheduledForDeletion( 628 origin_identifier, database_name)); 629 } 630 631 void DatabaseTracker::ScheduleDatabasesForDeletion( 632 const DatabaseSet& databases, 633 const net::CompletionCallback& callback) { 634 DCHECK(!databases.empty()); 635 636 if (!callback.is_null()) 637 deletion_callbacks_.push_back(std::make_pair(callback, databases)); 638 for (DatabaseSet::const_iterator ori = databases.begin(); 639 ori != databases.end(); ++ori) { 640 for (std::set<base::string16>::const_iterator db = ori->second.begin(); 641 db != ori->second.end(); ++db) 642 ScheduleDatabaseForDeletion(ori->first, *db); 643 } 644 } 645 646 int DatabaseTracker::DeleteDatabase(const std::string& origin_identifier, 647 const base::string16& database_name, 648 const net::CompletionCallback& callback) { 649 if (!LazyInit()) 650 return net::ERR_FAILED; 651 652 if (database_connections_.IsDatabaseOpened(origin_identifier, 653 database_name)) { 654 if (!callback.is_null()) { 655 DatabaseSet set; 656 set[origin_identifier].insert(database_name); 657 deletion_callbacks_.push_back(std::make_pair(callback, set)); 658 } 659 ScheduleDatabaseForDeletion(origin_identifier, database_name); 660 return net::ERR_IO_PENDING; 661 } 662 DeleteClosedDatabase(origin_identifier, database_name); 663 return net::OK; 664 } 665 666 int DatabaseTracker::DeleteDataModifiedSince( 667 const base::Time& cutoff, 668 const net::CompletionCallback& callback) { 669 if (!LazyInit()) 670 return net::ERR_FAILED; 671 672 DatabaseSet to_be_deleted; 673 674 std::vector<std::string> origins_identifiers; 675 if (!databases_table_->GetAllOriginIdentifiers(&origins_identifiers)) 676 return net::ERR_FAILED; 677 int rv = net::OK; 678 for (std::vector<std::string>::const_iterator ori = 679 origins_identifiers.begin(); 680 ori != origins_identifiers.end(); ++ori) { 681 if (special_storage_policy_.get() && 682 special_storage_policy_->IsStorageProtected( 683 storage::GetOriginFromIdentifier(*ori))) { 684 continue; 685 } 686 687 std::vector<DatabaseDetails> details; 688 if (!databases_table_-> 689 GetAllDatabaseDetailsForOriginIdentifier(*ori, &details)) 690 rv = net::ERR_FAILED; 691 for (std::vector<DatabaseDetails>::const_iterator db = details.begin(); 692 db != details.end(); ++db) { 693 base::FilePath db_file = GetFullDBFilePath(*ori, db->database_name); 694 base::File::Info file_info; 695 base::GetFileInfo(db_file, &file_info); 696 if (file_info.last_modified < cutoff) 697 continue; 698 699 // Check if the database is opened by any renderer. 700 if (database_connections_.IsDatabaseOpened(*ori, db->database_name)) 701 to_be_deleted[*ori].insert(db->database_name); 702 else 703 DeleteClosedDatabase(*ori, db->database_name); 704 } 705 } 706 707 if (rv != net::OK) 708 return rv; 709 710 if (!to_be_deleted.empty()) { 711 ScheduleDatabasesForDeletion(to_be_deleted, callback); 712 return net::ERR_IO_PENDING; 713 } 714 return net::OK; 715 } 716 717 int DatabaseTracker::DeleteDataForOrigin( 718 const std::string& origin, const net::CompletionCallback& callback) { 719 if (!LazyInit()) 720 return net::ERR_FAILED; 721 722 DatabaseSet to_be_deleted; 723 724 std::vector<DatabaseDetails> details; 725 if (!databases_table_-> 726 GetAllDatabaseDetailsForOriginIdentifier(origin, &details)) 727 return net::ERR_FAILED; 728 for (std::vector<DatabaseDetails>::const_iterator db = details.begin(); 729 db != details.end(); ++db) { 730 // Check if the database is opened by any renderer. 731 if (database_connections_.IsDatabaseOpened(origin, db->database_name)) 732 to_be_deleted[origin].insert(db->database_name); 733 else 734 DeleteClosedDatabase(origin, db->database_name); 735 } 736 737 if (!to_be_deleted.empty()) { 738 ScheduleDatabasesForDeletion(to_be_deleted, callback); 739 return net::ERR_IO_PENDING; 740 } 741 return net::OK; 742 } 743 744 const base::File* DatabaseTracker::GetIncognitoFile( 745 const base::string16& vfs_file_name) const { 746 DCHECK(is_incognito_); 747 FileHandlesMap::const_iterator it = 748 incognito_file_handles_.find(vfs_file_name); 749 if (it != incognito_file_handles_.end()) 750 return it->second; 751 752 return NULL; 753 } 754 755 const base::File* DatabaseTracker::SaveIncognitoFile( 756 const base::string16& vfs_file_name, 757 base::File file) { 758 DCHECK(is_incognito_); 759 if (!file.IsValid()) 760 return NULL; 761 762 base::File* to_insert = new base::File(file.Pass()); 763 std::pair<FileHandlesMap::iterator, bool> rv = 764 incognito_file_handles_.insert(std::make_pair(vfs_file_name, to_insert)); 765 DCHECK(rv.second); 766 return rv.first->second; 767 } 768 769 void DatabaseTracker::CloseIncognitoFileHandle( 770 const base::string16& vfs_file_name) { 771 DCHECK(is_incognito_); 772 DCHECK(incognito_file_handles_.find(vfs_file_name) != 773 incognito_file_handles_.end()); 774 775 FileHandlesMap::iterator it = incognito_file_handles_.find(vfs_file_name); 776 if (it != incognito_file_handles_.end()) { 777 delete it->second; 778 incognito_file_handles_.erase(it); 779 } 780 } 781 782 bool DatabaseTracker::HasSavedIncognitoFileHandle( 783 const base::string16& vfs_file_name) const { 784 return (incognito_file_handles_.find(vfs_file_name) != 785 incognito_file_handles_.end()); 786 } 787 788 void DatabaseTracker::DeleteIncognitoDBDirectory() { 789 is_initialized_ = false; 790 791 for (FileHandlesMap::iterator it = incognito_file_handles_.begin(); 792 it != incognito_file_handles_.end(); it++) { 793 delete it->second; 794 } 795 796 base::FilePath incognito_db_dir = 797 profile_path_.Append(kIncognitoDatabaseDirectoryName); 798 if (base::DirectoryExists(incognito_db_dir)) 799 base::DeleteFile(incognito_db_dir, true); 800 } 801 802 void DatabaseTracker::ClearSessionOnlyOrigins() { 803 bool has_session_only_databases = 804 special_storage_policy_.get() && 805 special_storage_policy_->HasSessionOnlyOrigins(); 806 807 // Clearing only session-only databases, and there are none. 808 if (!has_session_only_databases) 809 return; 810 811 if (!LazyInit()) 812 return; 813 814 std::vector<std::string> origin_identifiers; 815 GetAllOriginIdentifiers(&origin_identifiers); 816 817 for (std::vector<std::string>::iterator origin = 818 origin_identifiers.begin(); 819 origin != origin_identifiers.end(); ++origin) { 820 GURL origin_url = storage::GetOriginFromIdentifier(*origin); 821 if (!special_storage_policy_->IsStorageSessionOnly(origin_url)) 822 continue; 823 if (special_storage_policy_->IsStorageProtected(origin_url)) 824 continue; 825 storage::OriginInfo origin_info; 826 std::vector<base::string16> databases; 827 GetOriginInfo(*origin, &origin_info); 828 origin_info.GetAllDatabaseNames(&databases); 829 830 for (std::vector<base::string16>::iterator database = databases.begin(); 831 database != databases.end(); ++database) { 832 base::File file(GetFullDBFilePath(*origin, *database), 833 base::File::FLAG_OPEN_ALWAYS | 834 base::File::FLAG_SHARE_DELETE | 835 base::File::FLAG_DELETE_ON_CLOSE | 836 base::File::FLAG_READ); 837 } 838 DeleteOrigin(*origin, true); 839 } 840 } 841 842 843 void DatabaseTracker::Shutdown() { 844 DCHECK(db_tracker_thread_.get()); 845 DCHECK(db_tracker_thread_->BelongsToCurrentThread()); 846 if (shutting_down_) { 847 NOTREACHED(); 848 return; 849 } 850 shutting_down_ = true; 851 if (is_incognito_) 852 DeleteIncognitoDBDirectory(); 853 else if (!force_keep_session_state_) 854 ClearSessionOnlyOrigins(); 855 CloseTrackerDatabaseAndClearCaches(); 856 } 857 858 void DatabaseTracker::SetForceKeepSessionState() { 859 DCHECK(db_tracker_thread_.get()); 860 if (!db_tracker_thread_->BelongsToCurrentThread()) { 861 db_tracker_thread_->PostTask( 862 FROM_HERE, 863 base::Bind(&DatabaseTracker::SetForceKeepSessionState, this)); 864 return; 865 } 866 force_keep_session_state_ = true; 867 } 868 869 } // namespace storage 870
