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/dom_storage/dom_storage_context_impl.h" 6 7 #include "base/bind.h" 8 #include "base/bind_helpers.h" 9 #include "base/file_util.h" 10 #include "base/files/file_enumerator.h" 11 #include "base/guid.h" 12 #include "base/location.h" 13 #include "base/time/time.h" 14 #include "content/browser/dom_storage/dom_storage_area.h" 15 #include "content/browser/dom_storage/dom_storage_database.h" 16 #include "content/browser/dom_storage/dom_storage_namespace.h" 17 #include "content/browser/dom_storage/dom_storage_task_runner.h" 18 #include "content/browser/dom_storage/session_storage_database.h" 19 #include "content/common/dom_storage/dom_storage_types.h" 20 #include "content/public/browser/dom_storage_context.h" 21 #include "content/public/browser/local_storage_usage_info.h" 22 #include "content/public/browser/session_storage_usage_info.h" 23 #include "webkit/browser/quota/special_storage_policy.h" 24 25 namespace content { 26 27 static const int kSessionStoraceScavengingSeconds = 60; 28 29 DOMStorageContextImpl::DOMStorageContextImpl( 30 const base::FilePath& localstorage_directory, 31 const base::FilePath& sessionstorage_directory, 32 quota::SpecialStoragePolicy* special_storage_policy, 33 DOMStorageTaskRunner* task_runner) 34 : localstorage_directory_(localstorage_directory), 35 sessionstorage_directory_(sessionstorage_directory), 36 task_runner_(task_runner), 37 is_shutdown_(false), 38 force_keep_session_state_(false), 39 special_storage_policy_(special_storage_policy), 40 scavenging_started_(false) { 41 // AtomicSequenceNum starts at 0 but we want to start session 42 // namespace ids at one since zero is reserved for the 43 // kLocalStorageNamespaceId. 44 session_id_sequence_.GetNext(); 45 } 46 47 DOMStorageContextImpl::~DOMStorageContextImpl() { 48 if (session_storage_database_.get()) { 49 // SessionStorageDatabase shouldn't be deleted right away: deleting it will 50 // potentially involve waiting in leveldb::DBImpl::~DBImpl, and waiting 51 // shouldn't happen on this thread. 52 SessionStorageDatabase* to_release = session_storage_database_.get(); 53 to_release->AddRef(); 54 session_storage_database_ = NULL; 55 task_runner_->PostShutdownBlockingTask( 56 FROM_HERE, 57 DOMStorageTaskRunner::COMMIT_SEQUENCE, 58 base::Bind(&SessionStorageDatabase::Release, 59 base::Unretained(to_release))); 60 } 61 } 62 63 DOMStorageNamespace* DOMStorageContextImpl::GetStorageNamespace( 64 int64 namespace_id) { 65 if (is_shutdown_) 66 return NULL; 67 StorageNamespaceMap::iterator found = namespaces_.find(namespace_id); 68 if (found == namespaces_.end()) { 69 if (namespace_id == kLocalStorageNamespaceId) { 70 if (!localstorage_directory_.empty()) { 71 if (!base::CreateDirectory(localstorage_directory_)) { 72 LOG(ERROR) << "Failed to create 'Local Storage' directory," 73 " falling back to in-memory only."; 74 localstorage_directory_ = base::FilePath(); 75 } 76 } 77 DOMStorageNamespace* local = 78 new DOMStorageNamespace(localstorage_directory_, task_runner_.get()); 79 namespaces_[kLocalStorageNamespaceId] = local; 80 return local; 81 } 82 return NULL; 83 } 84 return found->second.get(); 85 } 86 87 void DOMStorageContextImpl::GetLocalStorageUsage( 88 std::vector<LocalStorageUsageInfo>* infos, 89 bool include_file_info) { 90 if (localstorage_directory_.empty()) 91 return; 92 base::FileEnumerator enumerator(localstorage_directory_, false, 93 base::FileEnumerator::FILES); 94 for (base::FilePath path = enumerator.Next(); !path.empty(); 95 path = enumerator.Next()) { 96 if (path.MatchesExtension(DOMStorageArea::kDatabaseFileExtension)) { 97 LocalStorageUsageInfo info; 98 info.origin = DOMStorageArea::OriginFromDatabaseFileName(path); 99 if (include_file_info) { 100 base::FileEnumerator::FileInfo find_info = enumerator.GetInfo(); 101 info.data_size = find_info.GetSize(); 102 info.last_modified = find_info.GetLastModifiedTime(); 103 } 104 infos->push_back(info); 105 } 106 } 107 } 108 109 void DOMStorageContextImpl::GetSessionStorageUsage( 110 std::vector<SessionStorageUsageInfo>* infos) { 111 if (!session_storage_database_.get()) 112 return; 113 std::map<std::string, std::vector<GURL> > namespaces_and_origins; 114 session_storage_database_->ReadNamespacesAndOrigins( 115 &namespaces_and_origins); 116 for (std::map<std::string, std::vector<GURL> >::const_iterator it = 117 namespaces_and_origins.begin(); 118 it != namespaces_and_origins.end(); ++it) { 119 for (std::vector<GURL>::const_iterator origin_it = it->second.begin(); 120 origin_it != it->second.end(); ++origin_it) { 121 SessionStorageUsageInfo info; 122 info.persistent_namespace_id = it->first; 123 info.origin = *origin_it; 124 infos->push_back(info); 125 } 126 } 127 } 128 129 void DOMStorageContextImpl::DeleteLocalStorage(const GURL& origin) { 130 DCHECK(!is_shutdown_); 131 DOMStorageNamespace* local = GetStorageNamespace(kLocalStorageNamespaceId); 132 local->DeleteLocalStorageOrigin(origin); 133 // Synthesize a 'cleared' event if the area is open so CachedAreas in 134 // renderers get emptied out too. 135 DOMStorageArea* area = local->GetOpenStorageArea(origin); 136 if (area) 137 NotifyAreaCleared(area, origin); 138 } 139 140 void DOMStorageContextImpl::DeleteSessionStorage( 141 const SessionStorageUsageInfo& usage_info) { 142 DCHECK(!is_shutdown_); 143 DOMStorageNamespace* dom_storage_namespace = NULL; 144 std::map<std::string, int64>::const_iterator it = 145 persistent_namespace_id_to_namespace_id_.find( 146 usage_info.persistent_namespace_id); 147 if (it != persistent_namespace_id_to_namespace_id_.end()) { 148 dom_storage_namespace = GetStorageNamespace(it->second); 149 } else { 150 int64 namespace_id = AllocateSessionId(); 151 CreateSessionNamespace(namespace_id, usage_info.persistent_namespace_id); 152 dom_storage_namespace = GetStorageNamespace(namespace_id); 153 } 154 dom_storage_namespace->DeleteSessionStorageOrigin(usage_info.origin); 155 // Synthesize a 'cleared' event if the area is open so CachedAreas in 156 // renderers get emptied out too. 157 DOMStorageArea* area = 158 dom_storage_namespace->GetOpenStorageArea(usage_info.origin); 159 if (area) 160 NotifyAreaCleared(area, usage_info.origin); 161 } 162 163 void DOMStorageContextImpl::Shutdown() { 164 is_shutdown_ = true; 165 StorageNamespaceMap::const_iterator it = namespaces_.begin(); 166 for (; it != namespaces_.end(); ++it) 167 it->second->Shutdown(); 168 169 if (localstorage_directory_.empty() && !session_storage_database_.get()) 170 return; 171 172 // Respect the content policy settings about what to 173 // keep and what to discard. 174 if (force_keep_session_state_) 175 return; // Keep everything. 176 177 bool has_session_only_origins = 178 special_storage_policy_.get() && 179 special_storage_policy_->HasSessionOnlyOrigins(); 180 181 if (has_session_only_origins) { 182 // We may have to delete something. We continue on the 183 // commit sequence after area shutdown tasks have cycled 184 // thru that sequence (and closed their database files). 185 bool success = task_runner_->PostShutdownBlockingTask( 186 FROM_HERE, 187 DOMStorageTaskRunner::COMMIT_SEQUENCE, 188 base::Bind(&DOMStorageContextImpl::ClearSessionOnlyOrigins, this)); 189 DCHECK(success); 190 } 191 } 192 193 void DOMStorageContextImpl::AddEventObserver(EventObserver* observer) { 194 event_observers_.AddObserver(observer); 195 } 196 197 void DOMStorageContextImpl::RemoveEventObserver(EventObserver* observer) { 198 event_observers_.RemoveObserver(observer); 199 } 200 201 void DOMStorageContextImpl::NotifyItemSet( 202 const DOMStorageArea* area, 203 const base::string16& key, 204 const base::string16& new_value, 205 const base::NullableString16& old_value, 206 const GURL& page_url) { 207 FOR_EACH_OBSERVER( 208 EventObserver, event_observers_, 209 OnDOMStorageItemSet(area, key, new_value, old_value, page_url)); 210 } 211 212 void DOMStorageContextImpl::NotifyItemRemoved( 213 const DOMStorageArea* area, 214 const base::string16& key, 215 const base::string16& old_value, 216 const GURL& page_url) { 217 FOR_EACH_OBSERVER( 218 EventObserver, event_observers_, 219 OnDOMStorageItemRemoved(area, key, old_value, page_url)); 220 } 221 222 void DOMStorageContextImpl::NotifyAreaCleared( 223 const DOMStorageArea* area, 224 const GURL& page_url) { 225 FOR_EACH_OBSERVER( 226 EventObserver, event_observers_, 227 OnDOMStorageAreaCleared(area, page_url)); 228 } 229 230 void DOMStorageContextImpl::NotifyAliasSessionMerged( 231 int64 namespace_id, 232 DOMStorageNamespace* old_alias_master_namespace) { 233 FOR_EACH_OBSERVER( 234 EventObserver, event_observers_, 235 OnDOMSessionStorageReset(namespace_id)); 236 if (old_alias_master_namespace) 237 MaybeShutdownSessionNamespace(old_alias_master_namespace); 238 } 239 240 std::string DOMStorageContextImpl::AllocatePersistentSessionId() { 241 std::string guid = base::GenerateGUID(); 242 std::replace(guid.begin(), guid.end(), '-', '_'); 243 return guid; 244 } 245 246 void DOMStorageContextImpl::CreateSessionNamespace( 247 int64 namespace_id, 248 const std::string& persistent_namespace_id) { 249 if (is_shutdown_) 250 return; 251 DCHECK(namespace_id != kLocalStorageNamespaceId); 252 DCHECK(namespaces_.find(namespace_id) == namespaces_.end()); 253 namespaces_[namespace_id] = new DOMStorageNamespace( 254 namespace_id, persistent_namespace_id, session_storage_database_.get(), 255 task_runner_.get()); 256 persistent_namespace_id_to_namespace_id_[persistent_namespace_id] = 257 namespace_id; 258 } 259 260 void DOMStorageContextImpl::DeleteSessionNamespace( 261 int64 namespace_id, bool should_persist_data) { 262 DCHECK_NE(kLocalStorageNamespaceId, namespace_id); 263 StorageNamespaceMap::const_iterator it = namespaces_.find(namespace_id); 264 if (it == namespaces_.end() || 265 it->second->ready_for_deletion_pending_aliases()) { 266 return; 267 } 268 it->second->set_ready_for_deletion_pending_aliases(true); 269 DOMStorageNamespace* alias_master = it->second->alias_master_namespace(); 270 if (alias_master) { 271 DCHECK(it->second->num_aliases() == 0); 272 DCHECK(alias_master->alias_master_namespace() == NULL); 273 if (should_persist_data) 274 alias_master->set_must_persist_at_shutdown(true); 275 if (it->second->DecrementMasterAliasCount()) 276 MaybeShutdownSessionNamespace(alias_master); 277 namespaces_.erase(namespace_id); 278 } else { 279 if (should_persist_data) 280 it->second->set_must_persist_at_shutdown(true); 281 MaybeShutdownSessionNamespace(it->second); 282 } 283 } 284 285 void DOMStorageContextImpl::MaybeShutdownSessionNamespace( 286 DOMStorageNamespace* ns) { 287 if (ns->num_aliases() > 0 || !ns->ready_for_deletion_pending_aliases()) 288 return; 289 DCHECK_EQ(ns->num_aliases(), 0); 290 DCHECK(ns->alias_master_namespace() == NULL); 291 std::string persistent_namespace_id = ns->persistent_namespace_id(); 292 if (session_storage_database_.get()) { 293 if (!ns->must_persist_at_shutdown()) { 294 task_runner_->PostShutdownBlockingTask( 295 FROM_HERE, 296 DOMStorageTaskRunner::COMMIT_SEQUENCE, 297 base::Bind( 298 base::IgnoreResult(&SessionStorageDatabase::DeleteNamespace), 299 session_storage_database_, 300 persistent_namespace_id)); 301 } else { 302 // Ensure that the data gets committed before we shut down. 303 ns->Shutdown(); 304 if (!scavenging_started_) { 305 // Protect the persistent namespace ID from scavenging. 306 protected_persistent_session_ids_.insert(persistent_namespace_id); 307 } 308 } 309 } 310 persistent_namespace_id_to_namespace_id_.erase(persistent_namespace_id); 311 namespaces_.erase(ns->namespace_id()); 312 } 313 314 void DOMStorageContextImpl::CloneSessionNamespace( 315 int64 existing_id, int64 new_id, 316 const std::string& new_persistent_id) { 317 if (is_shutdown_) 318 return; 319 DCHECK_NE(kLocalStorageNamespaceId, existing_id); 320 DCHECK_NE(kLocalStorageNamespaceId, new_id); 321 StorageNamespaceMap::iterator found = namespaces_.find(existing_id); 322 if (found != namespaces_.end()) 323 namespaces_[new_id] = found->second->Clone(new_id, new_persistent_id); 324 else 325 CreateSessionNamespace(new_id, new_persistent_id); 326 } 327 328 void DOMStorageContextImpl::CreateAliasSessionNamespace( 329 int64 existing_id, int64 new_id, 330 const std::string& persistent_id) { 331 if (is_shutdown_) 332 return; 333 DCHECK_NE(kLocalStorageNamespaceId, existing_id); 334 DCHECK_NE(kLocalStorageNamespaceId, new_id); 335 StorageNamespaceMap::iterator found = namespaces_.find(existing_id); 336 if (found != namespaces_.end()) { 337 namespaces_[new_id] = found->second->CreateAlias(new_id); 338 } else { 339 CreateSessionNamespace(new_id, persistent_id); 340 } 341 } 342 343 void DOMStorageContextImpl::ClearSessionOnlyOrigins() { 344 if (!localstorage_directory_.empty()) { 345 std::vector<LocalStorageUsageInfo> infos; 346 const bool kDontIncludeFileInfo = false; 347 GetLocalStorageUsage(&infos, kDontIncludeFileInfo); 348 for (size_t i = 0; i < infos.size(); ++i) { 349 const GURL& origin = infos[i].origin; 350 if (special_storage_policy_->IsStorageProtected(origin)) 351 continue; 352 if (!special_storage_policy_->IsStorageSessionOnly(origin)) 353 continue; 354 355 base::FilePath database_file_path = localstorage_directory_.Append( 356 DOMStorageArea::DatabaseFileNameFromOrigin(origin)); 357 sql::Connection::Delete(database_file_path); 358 } 359 } 360 if (session_storage_database_.get()) { 361 std::vector<SessionStorageUsageInfo> infos; 362 GetSessionStorageUsage(&infos); 363 for (size_t i = 0; i < infos.size(); ++i) { 364 const GURL& origin = infos[i].origin; 365 if (special_storage_policy_->IsStorageProtected(origin)) 366 continue; 367 if (!special_storage_policy_->IsStorageSessionOnly(origin)) 368 continue; 369 session_storage_database_->DeleteArea(infos[i].persistent_namespace_id, 370 origin); 371 } 372 } 373 } 374 375 void DOMStorageContextImpl::SetSaveSessionStorageOnDisk() { 376 DCHECK(namespaces_.empty()); 377 if (!sessionstorage_directory_.empty()) { 378 session_storage_database_ = new SessionStorageDatabase( 379 sessionstorage_directory_); 380 } 381 } 382 383 void DOMStorageContextImpl::StartScavengingUnusedSessionStorage() { 384 if (session_storage_database_.get()) { 385 task_runner_->PostDelayedTask( 386 FROM_HERE, base::Bind(&DOMStorageContextImpl::FindUnusedNamespaces, 387 this), 388 base::TimeDelta::FromSeconds(kSessionStoraceScavengingSeconds)); 389 } 390 } 391 392 void DOMStorageContextImpl::FindUnusedNamespaces() { 393 DCHECK(session_storage_database_.get()); 394 if (scavenging_started_) 395 return; 396 scavenging_started_ = true; 397 std::set<std::string> namespace_ids_in_use; 398 for (StorageNamespaceMap::const_iterator it = namespaces_.begin(); 399 it != namespaces_.end(); ++it) 400 namespace_ids_in_use.insert(it->second->persistent_namespace_id()); 401 std::set<std::string> protected_persistent_session_ids; 402 protected_persistent_session_ids.swap(protected_persistent_session_ids_); 403 task_runner_->PostShutdownBlockingTask( 404 FROM_HERE, DOMStorageTaskRunner::COMMIT_SEQUENCE, 405 base::Bind( 406 &DOMStorageContextImpl::FindUnusedNamespacesInCommitSequence, 407 this, namespace_ids_in_use, protected_persistent_session_ids)); 408 } 409 410 void DOMStorageContextImpl::FindUnusedNamespacesInCommitSequence( 411 const std::set<std::string>& namespace_ids_in_use, 412 const std::set<std::string>& protected_persistent_session_ids) { 413 DCHECK(session_storage_database_.get()); 414 // Delete all namespaces which don't have an associated DOMStorageNamespace 415 // alive. 416 std::map<std::string, std::vector<GURL> > namespaces_and_origins; 417 session_storage_database_->ReadNamespacesAndOrigins(&namespaces_and_origins); 418 for (std::map<std::string, std::vector<GURL> >::const_iterator it = 419 namespaces_and_origins.begin(); 420 it != namespaces_and_origins.end(); ++it) { 421 if (namespace_ids_in_use.find(it->first) == namespace_ids_in_use.end() && 422 protected_persistent_session_ids.find(it->first) == 423 protected_persistent_session_ids.end()) { 424 deletable_persistent_namespace_ids_.push_back(it->first); 425 } 426 } 427 if (!deletable_persistent_namespace_ids_.empty()) { 428 task_runner_->PostDelayedTask( 429 FROM_HERE, base::Bind( 430 &DOMStorageContextImpl::DeleteNextUnusedNamespace, 431 this), 432 base::TimeDelta::FromSeconds(kSessionStoraceScavengingSeconds)); 433 } 434 } 435 436 void DOMStorageContextImpl::DeleteNextUnusedNamespace() { 437 if (is_shutdown_) 438 return; 439 task_runner_->PostShutdownBlockingTask( 440 FROM_HERE, DOMStorageTaskRunner::COMMIT_SEQUENCE, 441 base::Bind( 442 &DOMStorageContextImpl::DeleteNextUnusedNamespaceInCommitSequence, 443 this)); 444 } 445 446 void DOMStorageContextImpl::DeleteNextUnusedNamespaceInCommitSequence() { 447 if (deletable_persistent_namespace_ids_.empty()) 448 return; 449 const std::string& persistent_id = deletable_persistent_namespace_ids_.back(); 450 session_storage_database_->DeleteNamespace(persistent_id); 451 deletable_persistent_namespace_ids_.pop_back(); 452 if (!deletable_persistent_namespace_ids_.empty()) { 453 task_runner_->PostDelayedTask( 454 FROM_HERE, base::Bind( 455 &DOMStorageContextImpl::DeleteNextUnusedNamespace, 456 this), 457 base::TimeDelta::FromSeconds(kSessionStoraceScavengingSeconds)); 458 } 459 } 460 461 void DOMStorageContextImpl::AddTransactionLogProcessId(int64 namespace_id, 462 int process_id) { 463 DCHECK_NE(kLocalStorageNamespaceId, namespace_id); 464 StorageNamespaceMap::const_iterator it = namespaces_.find(namespace_id); 465 if (it == namespaces_.end()) 466 return; 467 it->second->AddTransactionLogProcessId(process_id); 468 } 469 470 void DOMStorageContextImpl::RemoveTransactionLogProcessId(int64 namespace_id, 471 int process_id) { 472 DCHECK_NE(kLocalStorageNamespaceId, namespace_id); 473 StorageNamespaceMap::const_iterator it = namespaces_.find(namespace_id); 474 if (it == namespaces_.end()) 475 return; 476 it->second->RemoveTransactionLogProcessId(process_id); 477 } 478 479 SessionStorageNamespace::MergeResult 480 DOMStorageContextImpl::MergeSessionStorage( 481 int64 namespace1_id, bool actually_merge, int process_id, 482 int64 namespace2_id) { 483 DCHECK_NE(kLocalStorageNamespaceId, namespace1_id); 484 DCHECK_NE(kLocalStorageNamespaceId, namespace2_id); 485 StorageNamespaceMap::const_iterator it = namespaces_.find(namespace1_id); 486 if (it == namespaces_.end()) 487 return SessionStorageNamespace::MERGE_RESULT_NAMESPACE_NOT_FOUND; 488 DOMStorageNamespace* ns1 = it->second; 489 it = namespaces_.find(namespace2_id); 490 if (it == namespaces_.end()) 491 return SessionStorageNamespace::MERGE_RESULT_NAMESPACE_NOT_FOUND; 492 DOMStorageNamespace* ns2 = it->second; 493 return ns1->Merge(actually_merge, process_id, ns2, this); 494 } 495 496 } // namespace content 497
