content/browser/service_worker/service_worker_database.cc

   1 // Copyright 2014 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/service_worker/service_worker_database.h"
   6
   7 #include <string>
   8
   9 #include "base/file_util.h"
  10 #include "base/location.h"
  11 #include "base/logging.h"
  12 #include "base/metrics/histogram.h"
  13 #include "base/stl_util.h"
  14 #include "base/strings/string_number_conversions.h"
  15 #include "base/strings/string_split.h"
  16 #include "base/strings/string_util.h"
  17 #include "base/strings/stringprintf.h"
  18 #include "content/browser/service_worker/service_worker_database.pb.h"
  19 #include "content/browser/service_worker/service_worker_metrics.h"
  20 #include "content/common/service_worker/service_worker_types.h"
  21 #include "third_party/leveldatabase/src/helpers/memenv/memenv.h"
  22 #include "third_party/leveldatabase/src/include/leveldb/db.h"
  23 #include "third_party/leveldatabase/src/include/leveldb/env.h"
  24 #include "third_party/leveldatabase/src/include/leveldb/write_batch.h"
  25
  26 // LevelDB database schema
  27 // =======================
  28 //
  29 // NOTE
  30 // - int64 value is serialized as a string by base::Int64ToString().
  31 // - GURL value is serialized as a string by GURL::spec().
  32 //
  33 // Version 1 (in sorted order)
  34 //   key: "INITDATA_DB_VERSION"
  35 //   value: "1"
  36 //
  37 //   key: "INITDATA_NEXT_REGISTRATION_ID"
  38 //   value: <int64 'next_available_registration_id'>
  39 //
  40 //   key: "INITDATA_NEXT_RESOURCE_ID"
  41 //   value: <int64 'next_available_resource_id'>
  42 //
  43 //   key: "INITDATA_NEXT_VERSION_ID"
  44 //   value: <int64 'next_available_version_id'>
  45 //
  46 //   key: "INITDATA_UNIQUE_ORIGIN:" + <GURL 'origin'>
  47 //   value: <empty>
  48 //
  49 //   key: "PRES:" + <int64 'purgeable_resource_id'>
  50 //   value: <empty>
  51 //
  52 //   key: "REG:" + <GURL 'origin'> + '\x00' + <int64 'registration_id'>
  53 //     (ex. "REG:http://example.com\x00123456")
  54 //   value: <ServiceWorkerRegistrationData serialized as a string>
  55 //
  56 //   key: "RES:" + <int64 'version_id'> + '\x00' + <int64 'resource_id'>
  57 //     (ex. "RES:123456\x00654321")
  58 //   value: <ServiceWorkerResourceRecord serialized as a string>
  59 //
  60 //   key: "URES:" + <int64 'uncommitted_resource_id'>
  61 //   value: <empty>
  62
  63 namespace content {
  64
  65 namespace {
  66
  67 const char kDatabaseVersionKey[] = "INITDATA_DB_VERSION";
  68 const char kNextRegIdKey[] = "INITDATA_NEXT_REGISTRATION_ID";
  69 const char kNextResIdKey[] = "INITDATA_NEXT_RESOURCE_ID";
  70 const char kNextVerIdKey[] = "INITDATA_NEXT_VERSION_ID";
  71 const char kUniqueOriginKey[] = "INITDATA_UNIQUE_ORIGIN:";
  72
  73 const char kRegKeyPrefix[] = "REG:";
  74 const char kResKeyPrefix[] = "RES:";
  75 const char kKeySeparator = '\x00';
  76
  77 const char kUncommittedResIdKeyPrefix[] = "URES:";
  78 const char kPurgeableResIdKeyPrefix[] = "PRES:";
  79
  80 const int64 kCurrentSchemaVersion = 1;
  81
  82 bool RemovePrefix(const std::string& str,
  83                   const std::string& prefix,
  84                   std::string* out) {
  85   if (!StartsWithASCII(str, prefix, true))
  86     return false;
  87   if (out)
  88     *out = str.substr(prefix.size());
  89   return true;
  90 }
  91
  92 std::string CreateRegistrationKey(int64 registration_id,
  93                                   const GURL& origin) {
  94   return base::StringPrintf("%s%s%c%s",
  95                             kRegKeyPrefix,
  96                             origin.spec().c_str(),
  97                             kKeySeparator,
  98                             base::Int64ToString(registration_id).c_str());
  99 }
 100
 101 std::string CreateResourceRecordKeyPrefix(int64 version_id) {
 102   return base::StringPrintf("%s%s%c",
 103                             kResKeyPrefix,
 104                             base::Int64ToString(version_id).c_str(),
 105                             kKeySeparator);
 106 }
 107
 108 std::string CreateResourceRecordKey(int64 version_id,
 109                                     int64 resource_id) {
 110   return CreateResourceRecordKeyPrefix(version_id).append(
 111       base::Int64ToString(resource_id));
 112 }
 113
 114 std::string CreateUniqueOriginKey(const GURL& origin) {
 115   return base::StringPrintf("%s%s", kUniqueOriginKey, origin.spec().c_str());
 116 }
 117
 118 std::string CreateResourceIdKey(const char* key_prefix, int64 resource_id) {
 119   return base::StringPrintf(
 120       "%s%s", key_prefix, base::Int64ToString(resource_id).c_str());
 121 }
 122
 123 void PutRegistrationDataToBatch(
 124     const ServiceWorkerDatabase::RegistrationData& input,
 125     leveldb::WriteBatch* batch) {
 126   DCHECK(batch);
 127
 128   // Convert RegistrationData to ServiceWorkerRegistrationData.
 129   ServiceWorkerRegistrationData data;
 130   data.set_registration_id(input.registration_id);
 131   data.set_scope_url(input.scope.spec());
 132   data.set_script_url(input.script.spec());
 133   data.set_version_id(input.version_id);
 134   data.set_is_active(input.is_active);
 135   data.set_has_fetch_handler(input.has_fetch_handler);
 136   data.set_last_update_check_time(input.last_update_check.ToInternalValue());
 137
 138   std::string value;
 139   bool success = data.SerializeToString(&value);
 140   DCHECK(success);
 141   GURL origin = input.scope.GetOrigin();
 142   batch->Put(CreateRegistrationKey(data.registration_id(), origin), value);
 143 }
 144
 145 void PutResourceRecordToBatch(
 146     const ServiceWorkerDatabase::ResourceRecord& input,
 147     int64 version_id,
 148     leveldb::WriteBatch* batch) {
 149   DCHECK(batch);
 150
 151   // Convert ResourceRecord to ServiceWorkerResourceRecord.
 152   ServiceWorkerResourceRecord record;
 153   record.set_resource_id(input.resource_id);
 154   record.set_url(input.url.spec());
 155
 156   std::string value;
 157   bool success = record.SerializeToString(&value);
 158   DCHECK(success);
 159   batch->Put(CreateResourceRecordKey(version_id, input.resource_id), value);
 160 }
 161
 162 void PutUniqueOriginToBatch(const GURL& origin,
 163                             leveldb::WriteBatch* batch) {
 164   // Value should be empty.
 165   batch->Put(CreateUniqueOriginKey(origin), "");
 166 }
 167
 168 void PutPurgeableResourceIdToBatch(int64 resource_id,
 169                                    leveldb::WriteBatch* batch) {
 170   // Value should be empty.
 171   batch->Put(CreateResourceIdKey(kPurgeableResIdKeyPrefix, resource_id), "");
 172 }
 173
 174 ServiceWorkerDatabase::Status ParseId(
 175     const std::string& serialized,
 176     int64* out) {
 177   DCHECK(out);
 178   int64 id;
 179   if (!base::StringToInt64(serialized, &id) || id < 0)
 180     return ServiceWorkerDatabase::STATUS_ERROR_CORRUPTED;
 181   *out = id;
 182   return ServiceWorkerDatabase::STATUS_OK;
 183 }
 184
 185 ServiceWorkerDatabase::Status ParseDatabaseVersion(
 186     const std::string& serialized,
 187     int64* out) {
 188   DCHECK(out);
 189   const int kFirstValidVersion = 1;
 190   int64 version;
 191   if (!base::StringToInt64(serialized, &version) ||
 192       version < kFirstValidVersion) {
 193     return ServiceWorkerDatabase::STATUS_ERROR_CORRUPTED;
 194   }
 195   if (kCurrentSchemaVersion < version) {
 196     DLOG(ERROR) << "ServiceWorkerDatabase has newer schema version"
 197                 << " than the current latest version: "
 198                 << version << " vs " << kCurrentSchemaVersion;
 199     return ServiceWorkerDatabase::STATUS_ERROR_CORRUPTED;
 200   }
 201   *out = version;
 202   return ServiceWorkerDatabase::STATUS_OK;
 203 }
 204
 205 ServiceWorkerDatabase::Status ParseRegistrationData(
 206     const std::string& serialized,
 207     ServiceWorkerDatabase::RegistrationData* out) {
 208   DCHECK(out);
 209   ServiceWorkerRegistrationData data;
 210   if (!data.ParseFromString(serialized))
 211     return ServiceWorkerDatabase::STATUS_ERROR_CORRUPTED;
 212
 213   GURL scope_url(data.scope_url());
 214   GURL script_url(data.script_url());
 215   if (!scope_url.is_valid() ||
 216       !script_url.is_valid() ||
 217       scope_url.GetOrigin() != script_url.GetOrigin()) {
 218     return ServiceWorkerDatabase::STATUS_ERROR_CORRUPTED;
 219   }
 220
 221   // Convert ServiceWorkerRegistrationData to RegistrationData.
 222   out->registration_id = data.registration_id();
 223   out->scope = scope_url;
 224   out->script = script_url;
 225   out->version_id = data.version_id();
 226   out->is_active = data.is_active();
 227   out->has_fetch_handler = data.has_fetch_handler();
 228   out->last_update_check =
 229       base::Time::FromInternalValue(data.last_update_check_time());
 230   return ServiceWorkerDatabase::STATUS_OK;
 231 }
 232
 233 ServiceWorkerDatabase::Status ParseResourceRecord(
 234     const std::string& serialized,
 235     ServiceWorkerDatabase::ResourceRecord* out) {
 236   DCHECK(out);
 237   ServiceWorkerResourceRecord record;
 238   if (!record.ParseFromString(serialized))
 239     return ServiceWorkerDatabase::STATUS_ERROR_CORRUPTED;
 240
 241   GURL url(record.url());
 242   if (!url.is_valid())
 243     return ServiceWorkerDatabase::STATUS_ERROR_CORRUPTED;
 244
 245   // Convert ServiceWorkerResourceRecord to ResourceRecord.
 246   out->resource_id = record.resource_id();
 247   out->url = url;
 248   return ServiceWorkerDatabase::STATUS_OK;
 249 }
 250
 251 ServiceWorkerDatabase::Status LevelDBStatusToStatus(
 252     const leveldb::Status& status) {
 253   if (status.ok())
 254     return ServiceWorkerDatabase::STATUS_OK;
 255   else if (status.IsNotFound())
 256     return ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND;
 257   else if (status.IsIOError())
 258     return ServiceWorkerDatabase::STATUS_ERROR_IO_ERROR;
 259   else if (status.IsCorruption())
 260     return ServiceWorkerDatabase::STATUS_ERROR_CORRUPTED;
 261   else
 262     return ServiceWorkerDatabase::STATUS_ERROR_FAILED;
 263 }
 264
 265 const char* StatusToString(ServiceWorkerDatabase::Status status) {
 266   switch (status) {
 267     case ServiceWorkerDatabase::STATUS_OK:
 268       return "Database OK";
 269     case ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND:
 270       return "Database not found";
 271     case ServiceWorkerDatabase::STATUS_ERROR_IO_ERROR:
 272       return "Database IO error";
 273     case ServiceWorkerDatabase::STATUS_ERROR_CORRUPTED:
 274       return "Database corrupted";
 275     case ServiceWorkerDatabase::STATUS_ERROR_FAILED:
 276       return "Database operation failed";
 277     case ServiceWorkerDatabase::STATUS_ERROR_MAX:
 278       NOTREACHED();
 279       return "Database unknown error";
 280   }
 281   NOTREACHED();
 282   return "Database unknown error";
 283 }
 284
 285 }  // namespace
 286
 287 ServiceWorkerDatabase::RegistrationData::RegistrationData()
 288     : registration_id(kInvalidServiceWorkerRegistrationId),
 289       version_id(kInvalidServiceWorkerVersionId),
 290       is_active(false),
 291       has_fetch_handler(false) {
 292 }
 293
 294 ServiceWorkerDatabase::RegistrationData::~RegistrationData() {
 295 }
 296
 297 ServiceWorkerDatabase::ServiceWorkerDatabase(const base::FilePath& path)
 298     : path_(path),
 299       next_avail_registration_id_(0),
 300       next_avail_resource_id_(0),
 301       next_avail_version_id_(0),
 302       state_(UNINITIALIZED) {
 303   sequence_checker_.DetachFromSequence();
 304 }
 305
 306 ServiceWorkerDatabase::~ServiceWorkerDatabase() {
 307   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
 308   db_.reset();
 309 }
 310
 311 ServiceWorkerDatabase::Status ServiceWorkerDatabase::GetNextAvailableIds(
 312     int64* next_avail_registration_id,
 313     int64* next_avail_version_id,
 314     int64* next_avail_resource_id) {
 315   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
 316   DCHECK(next_avail_registration_id);
 317   DCHECK(next_avail_version_id);
 318   DCHECK(next_avail_resource_id);
 319
 320   Status status = LazyOpen(false);
 321   if (IsNewOrNonexistentDatabase(status)) {
 322     *next_avail_registration_id = 0;
 323     *next_avail_version_id = 0;
 324     *next_avail_resource_id = 0;
 325     return STATUS_OK;
 326   }
 327   if (status != STATUS_OK)
 328     return status;
 329
 330   status = ReadNextAvailableId(kNextRegIdKey, &next_avail_registration_id_);
 331   if (status != STATUS_OK)
 332     return status;
 333   status = ReadNextAvailableId(kNextVerIdKey, &next_avail_version_id_);
 334   if (status != STATUS_OK)
 335     return status;
 336   status = ReadNextAvailableId(kNextResIdKey, &next_avail_resource_id_);
 337   if (status != STATUS_OK)
 338     return status;
 339
 340   *next_avail_registration_id = next_avail_registration_id_;
 341   *next_avail_version_id = next_avail_version_id_;
 342   *next_avail_resource_id = next_avail_resource_id_;
 343   return STATUS_OK;
 344 }
 345
 346 ServiceWorkerDatabase::Status
 347 ServiceWorkerDatabase::GetOriginsWithRegistrations(std::set<GURL>* origins) {
 348   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
 349   DCHECK(origins->empty());
 350
 351   Status status = LazyOpen(false);
 352   if (IsNewOrNonexistentDatabase(status))
 353     return STATUS_OK;
 354   if (status != STATUS_OK)
 355     return status;
 356
 357   scoped_ptr<leveldb::Iterator> itr(db_->NewIterator(leveldb::ReadOptions()));
 358   for (itr->Seek(kUniqueOriginKey); itr->Valid(); itr->Next()) {
 359     status = LevelDBStatusToStatus(itr->status());
 360     if (status != STATUS_OK) {
 361       HandleReadResult(FROM_HERE, status);
 362       origins->clear();
 363       return status;
 364     }
 365
 366     std::string origin;
 367     if (!RemovePrefix(itr->key().ToString(), kUniqueOriginKey, &origin))
 368       break;
 369     origins->insert(GURL(origin));
 370   }
 371
 372   HandleReadResult(FROM_HERE, status);
 373   return status;
 374 }
 375
 376 ServiceWorkerDatabase::Status ServiceWorkerDatabase::GetRegistrationsForOrigin(
 377     const GURL& origin,
 378     std::vector<RegistrationData>* registrations) {
 379   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
 380   DCHECK(registrations->empty());
 381
 382   Status status = LazyOpen(false);
 383   if (IsNewOrNonexistentDatabase(status))
 384     return STATUS_OK;
 385   if (status != STATUS_OK)
 386     return status;
 387
 388   // Create a key prefix for registrations.
 389   std::string prefix = base::StringPrintf(
 390       "%s%s%c", kRegKeyPrefix, origin.spec().c_str(), kKeySeparator);
 391
 392   scoped_ptr<leveldb::Iterator> itr(db_->NewIterator(leveldb::ReadOptions()));
 393   for (itr->Seek(prefix); itr->Valid(); itr->Next()) {
 394     status = LevelDBStatusToStatus(itr->status());
 395     if (status != STATUS_OK) {
 396       HandleReadResult(FROM_HERE, status);
 397       registrations->clear();
 398       return status;
 399     }
 400
 401     if (!RemovePrefix(itr->key().ToString(), prefix, NULL))
 402       break;
 403
 404     RegistrationData registration;
 405     status = ParseRegistrationData(itr->value().ToString(), &registration);
 406     if (status != STATUS_OK) {
 407       HandleReadResult(FROM_HERE, status);
 408       registrations->clear();
 409       return status;
 410     }
 411     registrations->push_back(registration);
 412   }
 413
 414   HandleReadResult(FROM_HERE, status);
 415   return status;
 416 }
 417
 418 ServiceWorkerDatabase::Status ServiceWorkerDatabase::GetAllRegistrations(
 419     std::vector<RegistrationData>* registrations) {
 420   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
 421   DCHECK(registrations->empty());
 422
 423   Status status = LazyOpen(false);
 424   if (IsNewOrNonexistentDatabase(status))
 425     return STATUS_OK;
 426   if (status != STATUS_OK)
 427     return status;
 428
 429   scoped_ptr<leveldb::Iterator> itr(db_->NewIterator(leveldb::ReadOptions()));
 430   for (itr->Seek(kRegKeyPrefix); itr->Valid(); itr->Next()) {
 431     status = LevelDBStatusToStatus(itr->status());
 432     if (status != STATUS_OK) {
 433       HandleReadResult(FROM_HERE, status);
 434       registrations->clear();
 435       return status;
 436     }
 437
 438     if (!RemovePrefix(itr->key().ToString(), kRegKeyPrefix, NULL))
 439       break;
 440
 441     RegistrationData registration;
 442     status = ParseRegistrationData(itr->value().ToString(), &registration);
 443     if (status != STATUS_OK) {
 444       HandleReadResult(FROM_HERE, status);
 445       registrations->clear();
 446       return status;
 447     }
 448     registrations->push_back(registration);
 449   }
 450
 451   HandleReadResult(FROM_HERE, status);
 452   return status;
 453 }
 454
 455 ServiceWorkerDatabase::Status ServiceWorkerDatabase::ReadRegistration(
 456     int64 registration_id,
 457     const GURL& origin,
 458     RegistrationData* registration,
 459     std::vector<ResourceRecord>* resources) {
 460   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
 461   DCHECK(registration);
 462   DCHECK(resources);
 463
 464   Status status = LazyOpen(false);
 465   if (IsNewOrNonexistentDatabase(status) || status != STATUS_OK)
 466     return status;
 467
 468   RegistrationData value;
 469   status = ReadRegistrationData(registration_id, origin, &value);
 470   if (status != STATUS_OK)
 471     return status;
 472
 473   status = ReadResourceRecords(value.version_id, resources);
 474   if (status != STATUS_OK)
 475     return status;
 476
 477   *registration = value;
 478   return STATUS_OK;
 479 }
 480
 481 ServiceWorkerDatabase::Status ServiceWorkerDatabase::WriteRegistration(
 482     const RegistrationData& registration,
 483     const std::vector<ResourceRecord>& resources,
 484     int64* deleted_version_id,
 485     std::vector<int64>* newly_purgeable_resources) {
 486   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
 487   *deleted_version_id = kInvalidServiceWorkerVersionId;
 488   Status status = LazyOpen(true);
 489   if (status != STATUS_OK)
 490     return status;
 491
 492   leveldb::WriteBatch batch;
 493   BumpNextRegistrationIdIfNeeded(registration.registration_id, &batch);
 494   BumpNextVersionIdIfNeeded(registration.version_id, &batch);
 495
 496   PutUniqueOriginToBatch(registration.scope.GetOrigin(), &batch);
 497   PutRegistrationDataToBatch(registration, &batch);
 498
 499   // Used for avoiding multiple writes for the same resource id or url.
 500   std::set<int64> pushed_resources;
 501   std::set<GURL> pushed_urls;
 502   for (std::vector<ResourceRecord>::const_iterator itr = resources.begin();
 503        itr != resources.end(); ++itr) {
 504     if (!itr->url.is_valid())
 505       return STATUS_ERROR_FAILED;
 506
 507     // Duplicated resource id or url should not exist.
 508     DCHECK(pushed_resources.insert(itr->resource_id).second);
 509     DCHECK(pushed_urls.insert(itr->url).second);
 510
 511     PutResourceRecordToBatch(*itr, registration.version_id, &batch);
 512
 513     // Delete a resource from the uncommitted list.
 514     batch.Delete(CreateResourceIdKey(
 515         kUncommittedResIdKeyPrefix, itr->resource_id));
 516     // Delete from the purgeable list in case this version was once deleted.
 517     batch.Delete(
 518         CreateResourceIdKey(kPurgeableResIdKeyPrefix, itr->resource_id));
 519   }
 520
 521   // Retrieve a previous version to sweep purgeable resources.
 522   RegistrationData old_registration;
 523   status = ReadRegistrationData(registration.registration_id,
 524                                 registration.scope.GetOrigin(),
 525                                 &old_registration);
 526   if (status != STATUS_OK && status != STATUS_ERROR_NOT_FOUND)
 527     return status;
 528   if (status == STATUS_OK) {
 529     DCHECK_LT(old_registration.version_id, registration.version_id);
 530     *deleted_version_id = old_registration.version_id;
 531     status = DeleteResourceRecords(
 532         old_registration.version_id, newly_purgeable_resources, &batch);
 533     if (status != STATUS_OK)
 534       return status;
 535
 536     // Currently resource sharing across versions and registrations is not
 537     // supported, so resource ids should not be overlapped between
 538     // |registration| and |old_registration|.
 539     std::set<int64> deleted_resources(newly_purgeable_resources->begin(),
 540                                       newly_purgeable_resources->end());
 541     DCHECK(base::STLSetIntersection<std::set<int64> >(
 542         pushed_resources, deleted_resources).empty());
 543   }
 544
 545   return WriteBatch(&batch);
 546 }
 547
 548 ServiceWorkerDatabase::Status ServiceWorkerDatabase::UpdateVersionToActive(
 549     int64 registration_id,
 550     const GURL& origin) {
 551   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
 552   Status status = LazyOpen(false);
 553   if (IsNewOrNonexistentDatabase(status))
 554     return STATUS_ERROR_NOT_FOUND;
 555   if (status != STATUS_OK)
 556     return status;
 557   if (!origin.is_valid())
 558     return STATUS_ERROR_FAILED;
 559
 560   RegistrationData registration;
 561   status = ReadRegistrationData(registration_id, origin, &registration);
 562   if (status != STATUS_OK)
 563     return status;
 564
 565   registration.is_active = true;
 566
 567   leveldb::WriteBatch batch;
 568   PutRegistrationDataToBatch(registration, &batch);
 569   return WriteBatch(&batch);
 570 }
 571
 572 ServiceWorkerDatabase::Status ServiceWorkerDatabase::UpdateLastCheckTime(
 573     int64 registration_id,
 574     const GURL& origin,
 575     const base::Time& time) {
 576   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
 577   Status status = LazyOpen(false);
 578   if (IsNewOrNonexistentDatabase(status))
 579     return STATUS_ERROR_NOT_FOUND;
 580   if (status != STATUS_OK)
 581     return status;
 582   if (!origin.is_valid())
 583     return STATUS_ERROR_FAILED;
 584
 585   RegistrationData registration;
 586   status = ReadRegistrationData(registration_id, origin, &registration);
 587   if (status != STATUS_OK)
 588     return status;
 589
 590   registration.last_update_check = time;
 591
 592   leveldb::WriteBatch batch;
 593   PutRegistrationDataToBatch(registration, &batch);
 594   return WriteBatch(&batch);
 595 }
 596
 597 ServiceWorkerDatabase::Status ServiceWorkerDatabase::DeleteRegistration(
 598     int64 registration_id,
 599     const GURL& origin,
 600     int64* version_id,
 601     std::vector<int64>* newly_purgeable_resources) {
 602   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
 603   *version_id = kInvalidServiceWorkerVersionId;
 604   Status status = LazyOpen(false);
 605   if (IsNewOrNonexistentDatabase(status))
 606     return STATUS_OK;
 607   if (status != STATUS_OK)
 608     return status;
 609   if (!origin.is_valid())
 610     return STATUS_ERROR_FAILED;
 611
 612   leveldb::WriteBatch batch;
 613
 614   // Remove |origin| from unique origins if a registration specified by
 615   // |registration_id| is the only one for |origin|.
 616   // TODO(nhiroki): Check the uniqueness by more efficient way.
 617   std::vector<RegistrationData> registrations;
 618   status = GetRegistrationsForOrigin(origin, &registrations);
 619   if (status != STATUS_OK)
 620     return status;
 621
 622   if (registrations.size() == 1 &&
 623       registrations[0].registration_id == registration_id) {
 624     batch.Delete(CreateUniqueOriginKey(origin));
 625   }
 626
 627   // Delete a registration specified by |registration_id|.
 628   batch.Delete(CreateRegistrationKey(registration_id, origin));
 629
 630   // Delete resource records associated with the registration.
 631   for (std::vector<RegistrationData>::const_iterator itr =
 632            registrations.begin(); itr != registrations.end(); ++itr) {
 633     if (itr->registration_id == registration_id) {
 634       *version_id = itr->version_id;
 635       status = DeleteResourceRecords(
 636           itr->version_id, newly_purgeable_resources, &batch);
 637       if (status != STATUS_OK)
 638         return status;
 639       break;
 640     }
 641   }
 642
 643   return WriteBatch(&batch);
 644 }
 645
 646 ServiceWorkerDatabase::Status
 647 ServiceWorkerDatabase::GetUncommittedResourceIds(std::set<int64>* ids) {
 648   return ReadResourceIds(kUncommittedResIdKeyPrefix, ids);
 649 }
 650
 651 ServiceWorkerDatabase::Status
 652 ServiceWorkerDatabase::WriteUncommittedResourceIds(const std::set<int64>& ids) {
 653   return WriteResourceIds(kUncommittedResIdKeyPrefix, ids);
 654 }
 655
 656 ServiceWorkerDatabase::Status
 657 ServiceWorkerDatabase::ClearUncommittedResourceIds(const std::set<int64>& ids) {
 658   return DeleteResourceIds(kUncommittedResIdKeyPrefix, ids);
 659 }
 660
 661 ServiceWorkerDatabase::Status
 662 ServiceWorkerDatabase::GetPurgeableResourceIds(std::set<int64>* ids) {
 663   return ReadResourceIds(kPurgeableResIdKeyPrefix, ids);
 664 }
 665
 666 ServiceWorkerDatabase::Status
 667 ServiceWorkerDatabase::WritePurgeableResourceIds(const std::set<int64>& ids) {
 668   return WriteResourceIds(kPurgeableResIdKeyPrefix, ids);
 669 }
 670
 671 ServiceWorkerDatabase::Status
 672 ServiceWorkerDatabase::ClearPurgeableResourceIds(const std::set<int64>& ids) {
 673   return DeleteResourceIds(kPurgeableResIdKeyPrefix, ids);
 674 }
 675
 676 ServiceWorkerDatabase::Status
 677 ServiceWorkerDatabase::PurgeUncommittedResourceIds(
 678     const std::set<int64>& ids) {
 679   leveldb::WriteBatch batch;
 680   Status status = DeleteResourceIdsInBatch(
 681       kUncommittedResIdKeyPrefix, ids, &batch);
 682   if (status != STATUS_OK)
 683     return status;
 684   status = WriteResourceIdsInBatch(kPurgeableResIdKeyPrefix, ids, &batch);
 685   if (status != STATUS_OK)
 686     return status;
 687   return WriteBatch(&batch);
 688 }
 689
 690 ServiceWorkerDatabase::Status ServiceWorkerDatabase::DeleteAllDataForOrigin(
 691     const GURL& origin,
 692     std::vector<int64>* newly_purgeable_resources) {
 693   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
 694   Status status = LazyOpen(false);
 695   if (IsNewOrNonexistentDatabase(status))
 696     return STATUS_OK;
 697   if (status != STATUS_OK)
 698     return status;
 699   if (!origin.is_valid())
 700     return STATUS_ERROR_FAILED;
 701
 702   leveldb::WriteBatch batch;
 703
 704   // Delete from the unique origin list.
 705   batch.Delete(CreateUniqueOriginKey(origin));
 706
 707   std::vector<RegistrationData> registrations;
 708   status = GetRegistrationsForOrigin(origin, &registrations);
 709   if (status != STATUS_OK)
 710     return status;
 711
 712   // Delete registrations and resource records.
 713   for (std::vector<RegistrationData>::const_iterator itr =
 714            registrations.begin(); itr != registrations.end(); ++itr) {
 715     batch.Delete(CreateRegistrationKey(itr->registration_id, origin));
 716     status = DeleteResourceRecords(
 717         itr->version_id, newly_purgeable_resources, &batch);
 718     if (status != STATUS_OK)
 719       return status;
 720   }
 721
 722   return WriteBatch(&batch);
 723 }
 724
 725 ServiceWorkerDatabase::Status ServiceWorkerDatabase::DestroyDatabase() {
 726   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
 727   Disable(FROM_HERE, STATUS_OK);
 728   return LevelDBStatusToStatus(
 729       leveldb::DestroyDB(path_.AsUTF8Unsafe(), leveldb::Options()));
 730 }
 731
 732 ServiceWorkerDatabase::Status ServiceWorkerDatabase::LazyOpen(
 733     bool create_if_missing) {
 734   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
 735
 736   // Do not try to open a database if we tried and failed once.
 737   if (state_ == DISABLED)
 738     return STATUS_ERROR_FAILED;
 739   if (IsOpen())
 740     return STATUS_OK;
 741
 742   // When |path_| is empty, open a database in-memory.
 743   bool use_in_memory_db = path_.empty();
 744
 745   if (!create_if_missing) {
 746     // Avoid opening a database if it does not exist at the |path_|.
 747     if (use_in_memory_db ||
 748         !base::PathExists(path_) ||
 749         base::IsDirectoryEmpty(path_)) {
 750       return STATUS_ERROR_NOT_FOUND;
 751     }
 752   }
 753
 754   leveldb::Options options;
 755   options.create_if_missing = create_if_missing;
 756   if (use_in_memory_db) {
 757     env_.reset(leveldb::NewMemEnv(leveldb::Env::Default()));
 758     options.env = env_.get();
 759   }
 760
 761   leveldb::DB* db = NULL;
 762   Status status = LevelDBStatusToStatus(
 763       leveldb::DB::Open(options, path_.AsUTF8Unsafe(), &db));
 764   HandleOpenResult(FROM_HERE, status);
 765   if (status != STATUS_OK) {
 766     DCHECK(!db);
 767     // TODO(nhiroki): Should we retry to open the database?
 768     return status;
 769   }
 770   db_.reset(db);
 771
 772   int64 db_version;
 773   status = ReadDatabaseVersion(&db_version);
 774   if (status != STATUS_OK)
 775     return status;
 776   DCHECK_LE(0, db_version);
 777   if (db_version > 0)
 778     state_ = INITIALIZED;
 779   return STATUS_OK;
 780 }
 781
 782 bool ServiceWorkerDatabase::IsNewOrNonexistentDatabase(
 783     ServiceWorkerDatabase::Status status) {
 784   if (status == STATUS_ERROR_NOT_FOUND)
 785     return true;
 786   if (status == STATUS_OK && state_ == UNINITIALIZED)
 787     return true;
 788   return false;
 789 }
 790
 791 ServiceWorkerDatabase::Status ServiceWorkerDatabase::ReadNextAvailableId(
 792     const char* id_key,
 793     int64* next_avail_id) {
 794   DCHECK(id_key);
 795   DCHECK(next_avail_id);
 796
 797   std::string value;
 798   Status status = LevelDBStatusToStatus(
 799       db_->Get(leveldb::ReadOptions(), id_key, &value));
 800   if (status == STATUS_ERROR_NOT_FOUND) {
 801     // Nobody has gotten the next resource id for |id_key|.
 802     *next_avail_id = 0;
 803     HandleReadResult(FROM_HERE, STATUS_OK);
 804     return STATUS_OK;
 805   } else if (status != STATUS_OK) {
 806     HandleReadResult(FROM_HERE, status);
 807     return status;
 808   }
 809
 810   status = ParseId(value, next_avail_id);
 811   HandleReadResult(FROM_HERE, status);
 812   return status;
 813 }
 814
 815 ServiceWorkerDatabase::Status ServiceWorkerDatabase::ReadRegistrationData(
 816     int64 registration_id,
 817     const GURL& origin,
 818     RegistrationData* registration) {
 819   DCHECK(registration);
 820
 821   const std::string key = CreateRegistrationKey(registration_id, origin);
 822   std::string value;
 823   Status status = LevelDBStatusToStatus(
 824       db_->Get(leveldb::ReadOptions(), key, &value));
 825   if (status != STATUS_OK) {
 826     HandleReadResult(
 827         FROM_HERE,
 828         status == STATUS_ERROR_NOT_FOUND ? STATUS_OK : status);
 829     return status;
 830   }
 831
 832   status = ParseRegistrationData(value, registration);
 833   HandleReadResult(FROM_HERE, status);
 834   return status;
 835 }
 836
 837 ServiceWorkerDatabase::Status ServiceWorkerDatabase::ReadResourceRecords(
 838     int64 version_id,
 839     std::vector<ResourceRecord>* resources) {
 840   DCHECK(resources->empty());
 841
 842   Status status = STATUS_OK;
 843   const std::string prefix = CreateResourceRecordKeyPrefix(version_id);
 844
 845   scoped_ptr<leveldb::Iterator> itr(db_->NewIterator(leveldb::ReadOptions()));
 846   for (itr->Seek(prefix); itr->Valid(); itr->Next()) {
 847     Status status = LevelDBStatusToStatus(itr->status());
 848     if (status != STATUS_OK) {
 849       HandleReadResult(FROM_HERE, status);
 850       resources->clear();
 851       return status;
 852     }
 853
 854     if (!RemovePrefix(itr->key().ToString(), prefix, NULL))
 855       break;
 856
 857     ResourceRecord resource;
 858     status = ParseResourceRecord(itr->value().ToString(), &resource);
 859     if (status != STATUS_OK) {
 860       HandleReadResult(FROM_HERE, status);
 861       resources->clear();
 862       return status;
 863     }
 864     resources->push_back(resource);
 865   }
 866
 867   HandleReadResult(FROM_HERE, status);
 868   return status;
 869 }
 870
 871 ServiceWorkerDatabase::Status ServiceWorkerDatabase::DeleteResourceRecords(
 872     int64 version_id,
 873     std::vector<int64>* newly_purgeable_resources,
 874     leveldb::WriteBatch* batch) {
 875   DCHECK(batch);
 876
 877   Status status = STATUS_OK;
 878   const std::string prefix = CreateResourceRecordKeyPrefix(version_id);
 879
 880   scoped_ptr<leveldb::Iterator> itr(db_->NewIterator(leveldb::ReadOptions()));
 881   for (itr->Seek(prefix); itr->Valid(); itr->Next()) {
 882     status = LevelDBStatusToStatus(itr->status());
 883     if (status != STATUS_OK) {
 884       HandleReadResult(FROM_HERE, status);
 885       return status;
 886     }
 887
 888     const std::string key = itr->key().ToString();
 889     std::string unprefixed;
 890     if (!RemovePrefix(key, prefix, &unprefixed))
 891       break;
 892
 893     int64 resource_id;
 894     status = ParseId(unprefixed, &resource_id);
 895     if (status != STATUS_OK) {
 896       HandleReadResult(FROM_HERE, status);
 897       return status;
 898     }
 899
 900     // Remove a resource record.
 901     batch->Delete(key);
 902
 903     // Currently resource sharing across versions and registrations is not
 904     // supported, so we can purge this without caring about it.
 905     PutPurgeableResourceIdToBatch(resource_id, batch);
 906     newly_purgeable_resources->push_back(resource_id);
 907   }
 908
 909   HandleReadResult(FROM_HERE, status);
 910   return status;
 911 }
 912
 913 ServiceWorkerDatabase::Status ServiceWorkerDatabase::ReadResourceIds(
 914     const char* id_key_prefix,
 915     std::set<int64>* ids) {
 916   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
 917   DCHECK(id_key_prefix);
 918   DCHECK(ids->empty());
 919
 920   Status status = LazyOpen(false);
 921   if (IsNewOrNonexistentDatabase(status))
 922     return STATUS_OK;
 923   if (status != STATUS_OK)
 924     return status;
 925
 926   scoped_ptr<leveldb::Iterator> itr(db_->NewIterator(leveldb::ReadOptions()));
 927   for (itr->Seek(id_key_prefix); itr->Valid(); itr->Next()) {
 928     status = LevelDBStatusToStatus(itr->status());
 929     if (status != STATUS_OK) {
 930       HandleReadResult(FROM_HERE, status);
 931       ids->clear();
 932       return status;
 933     }
 934
 935     std::string unprefixed;
 936     if (!RemovePrefix(itr->key().ToString(), id_key_prefix, &unprefixed))
 937       break;
 938
 939     int64 resource_id;
 940     status = ParseId(unprefixed, &resource_id);
 941     if (status != STATUS_OK) {
 942       HandleReadResult(FROM_HERE, status);
 943       ids->clear();
 944       return status;
 945     }
 946     ids->insert(resource_id);
 947   }
 948
 949   HandleReadResult(FROM_HERE, status);
 950   return status;
 951 }
 952
 953 ServiceWorkerDatabase::Status ServiceWorkerDatabase::WriteResourceIds(
 954     const char* id_key_prefix,
 955     const std::set<int64>& ids) {
 956   leveldb::WriteBatch batch;
 957   Status status = WriteResourceIdsInBatch(id_key_prefix, ids, &batch);
 958   if (status != STATUS_OK)
 959     return status;
 960   return WriteBatch(&batch);
 961 }
 962
 963 ServiceWorkerDatabase::Status ServiceWorkerDatabase::WriteResourceIdsInBatch(
 964     const char* id_key_prefix,
 965     const std::set<int64>& ids,
 966     leveldb::WriteBatch* batch) {
 967   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
 968   DCHECK(id_key_prefix);
 969
 970   Status status = LazyOpen(true);
 971   if (status != STATUS_OK)
 972     return status;
 973
 974   if (ids.empty())
 975     return STATUS_OK;
 976   for (std::set<int64>::const_iterator itr = ids.begin();
 977        itr != ids.end(); ++itr) {
 978     // Value should be empty.
 979     batch->Put(CreateResourceIdKey(id_key_prefix, *itr), "");
 980   }
 981   // std::set is sorted, so the last element is the largest.
 982   BumpNextResourceIdIfNeeded(*ids.rbegin(), batch);
 983   return STATUS_OK;
 984 }
 985
 986 ServiceWorkerDatabase::Status ServiceWorkerDatabase::DeleteResourceIds(
 987     const char* id_key_prefix,
 988     const std::set<int64>& ids) {
 989   leveldb::WriteBatch batch;
 990   Status status = DeleteResourceIdsInBatch(id_key_prefix, ids, &batch);
 991   if (status != STATUS_OK)
 992     return status;
 993   return WriteBatch(&batch);
 994 }
 995
 996 ServiceWorkerDatabase::Status ServiceWorkerDatabase::DeleteResourceIdsInBatch(
 997     const char* id_key_prefix,
 998     const std::set<int64>& ids,
 999     leveldb::WriteBatch* batch) {
1000   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
1001   DCHECK(id_key_prefix);
1002
1003   Status status = LazyOpen(false);
1004   if (IsNewOrNonexistentDatabase(status))
1005     return STATUS_OK;
1006   if (status != STATUS_OK)
1007     return status;
1008
1009   for (std::set<int64>::const_iterator itr = ids.begin();
1010        itr != ids.end(); ++itr) {
1011     batch->Delete(CreateResourceIdKey(id_key_prefix, *itr));
1012   }
1013   return STATUS_OK;
1014 }
1015
1016 ServiceWorkerDatabase::Status ServiceWorkerDatabase::ReadDatabaseVersion(
1017     int64* db_version) {
1018   std::string value;
1019   Status status = LevelDBStatusToStatus(
1020       db_->Get(leveldb::ReadOptions(), kDatabaseVersionKey, &value));
1021   if (status == STATUS_ERROR_NOT_FOUND) {
1022     // The database hasn't been initialized yet.
1023     *db_version = 0;
1024     HandleReadResult(FROM_HERE, STATUS_OK);
1025     return STATUS_OK;
1026   }
1027
1028   if (status != STATUS_OK) {
1029     HandleReadResult(FROM_HERE, status);
1030     return status;
1031   }
1032
1033   status = ParseDatabaseVersion(value, db_version);
1034   HandleReadResult(FROM_HERE, status);
1035   return status;
1036 }
1037
1038 ServiceWorkerDatabase::Status ServiceWorkerDatabase::WriteBatch(
1039     leveldb::WriteBatch* batch) {
1040   DCHECK(batch);
1041   DCHECK_NE(DISABLED, state_);
1042
1043   if (state_ == UNINITIALIZED) {
1044     // Write the database schema version.
1045     batch->Put(kDatabaseVersionKey, base::Int64ToString(kCurrentSchemaVersion));
1046     state_ = INITIALIZED;
1047   }
1048
1049   Status status = LevelDBStatusToStatus(
1050       db_->Write(leveldb::WriteOptions(), batch));
1051   HandleWriteResult(FROM_HERE, status);
1052   return status;
1053 }
1054
1055 void ServiceWorkerDatabase::BumpNextRegistrationIdIfNeeded(
1056     int64 used_id, leveldb::WriteBatch* batch) {
1057   DCHECK(batch);
1058   if (next_avail_registration_id_ <= used_id) {
1059     next_avail_registration_id_ = used_id + 1;
1060     batch->Put(kNextRegIdKey, base::Int64ToString(next_avail_registration_id_));
1061   }
1062 }
1063
1064 void ServiceWorkerDatabase::BumpNextResourceIdIfNeeded(
1065     int64 used_id, leveldb::WriteBatch* batch) {
1066   DCHECK(batch);
1067   if (next_avail_resource_id_ <= used_id) {
1068     next_avail_resource_id_ = used_id + 1;
1069     batch->Put(kNextResIdKey, base::Int64ToString(next_avail_resource_id_));
1070   }
1071 }
1072
1073 void ServiceWorkerDatabase::BumpNextVersionIdIfNeeded(
1074     int64 used_id, leveldb::WriteBatch* batch) {
1075   DCHECK(batch);
1076   if (next_avail_version_id_ <= used_id) {
1077     next_avail_version_id_ = used_id + 1;
1078     batch->Put(kNextVerIdKey, base::Int64ToString(next_avail_version_id_));
1079   }
1080 }
1081
1082 bool ServiceWorkerDatabase::IsOpen() {
1083   return db_ != NULL;
1084 }
1085
1086 void ServiceWorkerDatabase::Disable(
1087     const tracked_objects::Location& from_here,
1088     Status status) {
1089   if (status != STATUS_OK) {
1090     DLOG(ERROR) << "Failed at: " << from_here.ToString()
1091                 << " with error: " << StatusToString(status);
1092     DLOG(ERROR) << "ServiceWorkerDatabase is disabled.";
1093   }
1094   state_ = DISABLED;
1095   db_.reset();
1096 }
1097
1098 void ServiceWorkerDatabase::HandleOpenResult(
1099     const tracked_objects::Location& from_here,
1100     Status status) {
1101   if (status != STATUS_OK)
1102     Disable(from_here, status);
1103   ServiceWorkerMetrics::CountOpenDatabaseResult(status);
1104 }
1105
1106 void ServiceWorkerDatabase::HandleReadResult(
1107     const tracked_objects::Location& from_here,
1108     Status status) {
1109   if (status != STATUS_OK)
1110     Disable(from_here, status);
1111   ServiceWorkerMetrics::CountReadDatabaseResult(status);
1112 }
1113
1114 void ServiceWorkerDatabase::HandleWriteResult(
1115     const tracked_objects::Location& from_here,
1116     Status status) {
1117   if (status != STATUS_OK)
1118     Disable(from_here, status);
1119   ServiceWorkerMetrics::CountWriteDatabaseResult(status);
1120 }
1121
1122 }  // namespace content