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