1 // Copyright 2013 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_area.h" 6 7 #include "base/bind.h" 8 #include "base/location.h" 9 #include "base/logging.h" 10 #include "base/metrics/histogram.h" 11 #include "base/strings/utf_string_conversions.h" 12 #include "base/time/time.h" 13 #include "content/browser/dom_storage/dom_storage_namespace.h" 14 #include "content/browser/dom_storage/dom_storage_task_runner.h" 15 #include "content/browser/dom_storage/local_storage_database_adapter.h" 16 #include "content/browser/dom_storage/session_storage_database.h" 17 #include "content/browser/dom_storage/session_storage_database_adapter.h" 18 #include "content/common/dom_storage/dom_storage_map.h" 19 #include "content/common/dom_storage/dom_storage_types.h" 20 #include "storage/browser/database/database_util.h" 21 #include "storage/common/database/database_identifier.h" 22 #include "storage/common/fileapi/file_system_util.h" 23 24 using storage::DatabaseUtil; 25 26 namespace content { 27 28 static const int kCommitTimerSeconds = 1; 29 30 DOMStorageArea::CommitBatch::CommitBatch() 31 : clear_all_first(false) { 32 } 33 DOMStorageArea::CommitBatch::~CommitBatch() {} 34 35 36 // static 37 const base::FilePath::CharType DOMStorageArea::kDatabaseFileExtension[] = 38 FILE_PATH_LITERAL(".localstorage"); 39 40 // static 41 base::FilePath DOMStorageArea::DatabaseFileNameFromOrigin(const GURL& origin) { 42 std::string filename = storage::GetIdentifierFromOrigin(origin); 43 // There is no base::FilePath.AppendExtension() method, so start with just the 44 // extension as the filename, and then InsertBeforeExtension the desired 45 // name. 46 return base::FilePath().Append(kDatabaseFileExtension). 47 InsertBeforeExtensionASCII(filename); 48 } 49 50 // static 51 GURL DOMStorageArea::OriginFromDatabaseFileName(const base::FilePath& name) { 52 DCHECK(name.MatchesExtension(kDatabaseFileExtension)); 53 std::string origin_id = 54 name.BaseName().RemoveExtension().MaybeAsASCII(); 55 return storage::GetOriginFromIdentifier(origin_id); 56 } 57 58 DOMStorageArea::DOMStorageArea( 59 const GURL& origin, const base::FilePath& directory, 60 DOMStorageTaskRunner* task_runner) 61 : namespace_id_(kLocalStorageNamespaceId), origin_(origin), 62 directory_(directory), 63 task_runner_(task_runner), 64 map_(new DOMStorageMap(kPerStorageAreaQuota + 65 kPerStorageAreaOverQuotaAllowance)), 66 is_initial_import_done_(true), 67 is_shutdown_(false), 68 commit_batches_in_flight_(0) { 69 if (!directory.empty()) { 70 base::FilePath path = directory.Append(DatabaseFileNameFromOrigin(origin_)); 71 backing_.reset(new LocalStorageDatabaseAdapter(path)); 72 is_initial_import_done_ = false; 73 } 74 } 75 76 DOMStorageArea::DOMStorageArea( 77 int64 namespace_id, 78 const std::string& persistent_namespace_id, 79 const GURL& origin, 80 SessionStorageDatabase* session_storage_backing, 81 DOMStorageTaskRunner* task_runner) 82 : namespace_id_(namespace_id), 83 persistent_namespace_id_(persistent_namespace_id), 84 origin_(origin), 85 task_runner_(task_runner), 86 map_(new DOMStorageMap(kPerStorageAreaQuota + 87 kPerStorageAreaOverQuotaAllowance)), 88 session_storage_backing_(session_storage_backing), 89 is_initial_import_done_(true), 90 is_shutdown_(false), 91 commit_batches_in_flight_(0) { 92 DCHECK(namespace_id != kLocalStorageNamespaceId); 93 if (session_storage_backing) { 94 backing_.reset(new SessionStorageDatabaseAdapter( 95 session_storage_backing, persistent_namespace_id, origin)); 96 is_initial_import_done_ = false; 97 } 98 } 99 100 DOMStorageArea::~DOMStorageArea() { 101 } 102 103 void DOMStorageArea::ExtractValues(DOMStorageValuesMap* map) { 104 if (is_shutdown_) 105 return; 106 InitialImportIfNeeded(); 107 map_->ExtractValues(map); 108 } 109 110 unsigned DOMStorageArea::Length() { 111 if (is_shutdown_) 112 return 0; 113 InitialImportIfNeeded(); 114 return map_->Length(); 115 } 116 117 base::NullableString16 DOMStorageArea::Key(unsigned index) { 118 if (is_shutdown_) 119 return base::NullableString16(); 120 InitialImportIfNeeded(); 121 return map_->Key(index); 122 } 123 124 base::NullableString16 DOMStorageArea::GetItem(const base::string16& key) { 125 if (is_shutdown_) 126 return base::NullableString16(); 127 InitialImportIfNeeded(); 128 return map_->GetItem(key); 129 } 130 131 bool DOMStorageArea::SetItem(const base::string16& key, 132 const base::string16& value, 133 base::NullableString16* old_value) { 134 if (is_shutdown_) 135 return false; 136 InitialImportIfNeeded(); 137 if (!map_->HasOneRef()) 138 map_ = map_->DeepCopy(); 139 bool success = map_->SetItem(key, value, old_value); 140 if (success && backing_) { 141 CommitBatch* commit_batch = CreateCommitBatchIfNeeded(); 142 commit_batch->changed_values[key] = base::NullableString16(value, false); 143 } 144 return success; 145 } 146 147 bool DOMStorageArea::RemoveItem(const base::string16& key, 148 base::string16* old_value) { 149 if (is_shutdown_) 150 return false; 151 InitialImportIfNeeded(); 152 if (!map_->HasOneRef()) 153 map_ = map_->DeepCopy(); 154 bool success = map_->RemoveItem(key, old_value); 155 if (success && backing_) { 156 CommitBatch* commit_batch = CreateCommitBatchIfNeeded(); 157 commit_batch->changed_values[key] = base::NullableString16(); 158 } 159 return success; 160 } 161 162 bool DOMStorageArea::Clear() { 163 if (is_shutdown_) 164 return false; 165 InitialImportIfNeeded(); 166 if (map_->Length() == 0) 167 return false; 168 169 map_ = new DOMStorageMap(kPerStorageAreaQuota + 170 kPerStorageAreaOverQuotaAllowance); 171 172 if (backing_) { 173 CommitBatch* commit_batch = CreateCommitBatchIfNeeded(); 174 commit_batch->clear_all_first = true; 175 commit_batch->changed_values.clear(); 176 } 177 178 return true; 179 } 180 181 void DOMStorageArea::FastClear() { 182 // TODO(marja): Unify clearing localStorage and sessionStorage. The problem is 183 // to make the following 3 to work together: 1) FastClear, 2) PurgeMemory and 184 // 3) not creating events when clearing an empty area. 185 if (is_shutdown_) 186 return; 187 188 map_ = new DOMStorageMap(kPerStorageAreaQuota + 189 kPerStorageAreaOverQuotaAllowance); 190 // This ensures no import will happen while we're waiting to clear the data 191 // from the database. This mechanism fails if PurgeMemory is called. 192 is_initial_import_done_ = true; 193 194 if (backing_) { 195 CommitBatch* commit_batch = CreateCommitBatchIfNeeded(); 196 commit_batch->clear_all_first = true; 197 commit_batch->changed_values.clear(); 198 } 199 } 200 201 DOMStorageArea* DOMStorageArea::ShallowCopy( 202 int64 destination_namespace_id, 203 const std::string& destination_persistent_namespace_id) { 204 DCHECK_NE(kLocalStorageNamespaceId, namespace_id_); 205 DCHECK_NE(kLocalStorageNamespaceId, destination_namespace_id); 206 207 DOMStorageArea* copy = new DOMStorageArea( 208 destination_namespace_id, destination_persistent_namespace_id, origin_, 209 session_storage_backing_.get(), task_runner_.get()); 210 copy->map_ = map_; 211 copy->is_shutdown_ = is_shutdown_; 212 copy->is_initial_import_done_ = true; 213 214 // All the uncommitted changes to this area need to happen before the actual 215 // shallow copy is made (scheduled by the upper layer). Another OnCommitTimer 216 // call might be in the event queue at this point, but it's handled gracefully 217 // when it fires. 218 if (commit_batch_) 219 OnCommitTimer(); 220 return copy; 221 } 222 223 bool DOMStorageArea::HasUncommittedChanges() const { 224 DCHECK(!is_shutdown_); 225 return commit_batch_.get() || commit_batches_in_flight_; 226 } 227 228 void DOMStorageArea::DeleteOrigin() { 229 DCHECK(!is_shutdown_); 230 // This function shouldn't be called for sessionStorage. 231 DCHECK(!session_storage_backing_.get()); 232 if (HasUncommittedChanges()) { 233 // TODO(michaeln): This logically deletes the data immediately, 234 // and in a matter of a second, deletes the rows from the backing 235 // database file, but the file itself will linger until shutdown 236 // or purge time. Ideally, this should delete the file more 237 // quickly. 238 Clear(); 239 return; 240 } 241 map_ = new DOMStorageMap(kPerStorageAreaQuota + 242 kPerStorageAreaOverQuotaAllowance); 243 if (backing_) { 244 is_initial_import_done_ = false; 245 backing_->Reset(); 246 backing_->DeleteFiles(); 247 } 248 } 249 250 void DOMStorageArea::PurgeMemory() { 251 DCHECK(!is_shutdown_); 252 // Purging sessionStorage is not supported; it won't work with FastClear. 253 DCHECK(!session_storage_backing_.get()); 254 if (!is_initial_import_done_ || // We're not using any memory. 255 !backing_.get() || // We can't purge anything. 256 HasUncommittedChanges()) // We leave things alone with changes pending. 257 return; 258 259 // Drop the in memory cache, we'll reload when needed. 260 is_initial_import_done_ = false; 261 map_ = new DOMStorageMap(kPerStorageAreaQuota + 262 kPerStorageAreaOverQuotaAllowance); 263 264 // Recreate the database object, this frees up the open sqlite connection 265 // and its page cache. 266 backing_->Reset(); 267 } 268 269 void DOMStorageArea::Shutdown() { 270 DCHECK(!is_shutdown_); 271 is_shutdown_ = true; 272 map_ = NULL; 273 if (!backing_) 274 return; 275 276 bool success = task_runner_->PostShutdownBlockingTask( 277 FROM_HERE, 278 DOMStorageTaskRunner::COMMIT_SEQUENCE, 279 base::Bind(&DOMStorageArea::ShutdownInCommitSequence, this)); 280 DCHECK(success); 281 } 282 283 void DOMStorageArea::InitialImportIfNeeded() { 284 if (is_initial_import_done_) 285 return; 286 287 DCHECK(backing_.get()); 288 289 base::TimeTicks before = base::TimeTicks::Now(); 290 DOMStorageValuesMap initial_values; 291 backing_->ReadAllValues(&initial_values); 292 map_->SwapValues(&initial_values); 293 is_initial_import_done_ = true; 294 base::TimeDelta time_to_import = base::TimeTicks::Now() - before; 295 UMA_HISTOGRAM_TIMES("LocalStorage.BrowserTimeToPrimeLocalStorage", 296 time_to_import); 297 298 size_t local_storage_size_kb = map_->bytes_used() / 1024; 299 // Track localStorage size, from 0-6MB. Note that the maximum size should be 300 // 5MB, but we add some slop since we want to make sure the max size is always 301 // above what we see in practice, since histograms can't change. 302 UMA_HISTOGRAM_CUSTOM_COUNTS("LocalStorage.BrowserLocalStorageSizeInKB", 303 local_storage_size_kb, 304 0, 6 * 1024, 50); 305 if (local_storage_size_kb < 100) { 306 UMA_HISTOGRAM_TIMES( 307 "LocalStorage.BrowserTimeToPrimeLocalStorageUnder100KB", 308 time_to_import); 309 } else if (local_storage_size_kb < 1000) { 310 UMA_HISTOGRAM_TIMES( 311 "LocalStorage.BrowserTimeToPrimeLocalStorage100KBTo1MB", 312 time_to_import); 313 } else { 314 UMA_HISTOGRAM_TIMES( 315 "LocalStorage.BrowserTimeToPrimeLocalStorage1MBTo5MB", 316 time_to_import); 317 } 318 } 319 320 DOMStorageArea::CommitBatch* DOMStorageArea::CreateCommitBatchIfNeeded() { 321 DCHECK(!is_shutdown_); 322 if (!commit_batch_) { 323 commit_batch_.reset(new CommitBatch()); 324 325 // Start a timer to commit any changes that accrue in the batch, but only if 326 // no commits are currently in flight. In that case the timer will be 327 // started after the commits have happened. 328 if (!commit_batches_in_flight_) { 329 task_runner_->PostDelayedTask( 330 FROM_HERE, 331 base::Bind(&DOMStorageArea::OnCommitTimer, this), 332 base::TimeDelta::FromSeconds(kCommitTimerSeconds)); 333 } 334 } 335 return commit_batch_.get(); 336 } 337 338 void DOMStorageArea::OnCommitTimer() { 339 if (is_shutdown_) 340 return; 341 342 DCHECK(backing_.get()); 343 344 // It's possible that there is nothing to commit, since a shallow copy occured 345 // before the timer fired. 346 if (!commit_batch_) 347 return; 348 349 // This method executes on the primary sequence, we schedule 350 // a task for immediate execution on the commit sequence. 351 DCHECK(task_runner_->IsRunningOnPrimarySequence()); 352 bool success = task_runner_->PostShutdownBlockingTask( 353 FROM_HERE, 354 DOMStorageTaskRunner::COMMIT_SEQUENCE, 355 base::Bind(&DOMStorageArea::CommitChanges, this, 356 base::Owned(commit_batch_.release()))); 357 ++commit_batches_in_flight_; 358 DCHECK(success); 359 } 360 361 void DOMStorageArea::CommitChanges(const CommitBatch* commit_batch) { 362 // This method executes on the commit sequence. 363 DCHECK(task_runner_->IsRunningOnCommitSequence()); 364 backing_->CommitChanges(commit_batch->clear_all_first, 365 commit_batch->changed_values); 366 // TODO(michaeln): what if CommitChanges returns false (e.g., we're trying to 367 // commit to a DB which is in an inconsistent state?) 368 task_runner_->PostTask( 369 FROM_HERE, 370 base::Bind(&DOMStorageArea::OnCommitComplete, this)); 371 } 372 373 void DOMStorageArea::OnCommitComplete() { 374 // We're back on the primary sequence in this method. 375 DCHECK(task_runner_->IsRunningOnPrimarySequence()); 376 --commit_batches_in_flight_; 377 if (is_shutdown_) 378 return; 379 if (commit_batch_.get() && !commit_batches_in_flight_) { 380 // More changes have accrued, restart the timer. 381 task_runner_->PostDelayedTask( 382 FROM_HERE, 383 base::Bind(&DOMStorageArea::OnCommitTimer, this), 384 base::TimeDelta::FromSeconds(kCommitTimerSeconds)); 385 } 386 } 387 388 void DOMStorageArea::ShutdownInCommitSequence() { 389 // This method executes on the commit sequence. 390 DCHECK(task_runner_->IsRunningOnCommitSequence()); 391 DCHECK(backing_.get()); 392 if (commit_batch_) { 393 // Commit any changes that accrued prior to the timer firing. 394 bool success = backing_->CommitChanges( 395 commit_batch_->clear_all_first, 396 commit_batch_->changed_values); 397 DCHECK(success); 398 } 399 commit_batch_.reset(); 400 backing_.reset(); 401 session_storage_backing_ = NULL; 402 } 403 404 } // namespace content 405
