ServiceWorker: DB functions should return status code instead of boolean (3)

content/browser/service_worker/service_worker_database.h

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_DATABASE_H_
 #define CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_DATABASE_H_
 
 #include <map>
 #include <set>
 #include <vector>
@@ skipping 79 matching lines @@
   // Reads all registrations from the database. Returns OK if successfully read
   // or not found. Otherwise, returns an error.
   ServiceWorkerStatusCode GetAllRegistrations(
       std::vector<RegistrationData>* registrations);
 
   // Saving, retrieving, and updating registration data.
   // (will bump next_avail_xxxx_ids as needed)
   // (resource ids will be added/removed from the uncommitted/purgeable
   // lists as needed)
 
-  bool ReadRegistration(int64 registration_id,
-                        const GURL& origin,
-                        RegistrationData* registration,
-                        std::vector<ResourceRecord>* resources);
-  bool WriteRegistration(const RegistrationData& registration,
-                         const std::vector<ResourceRecord>& resources);
+  // Reads a registration for |registration_id| and resource records associated
+  // with it from the database. Returns OK if they are successfully read.
+  // Otherwise, returns an error.
+  ServiceWorkerStatusCode ReadRegistration(
+      int64 registration_id,
+      const GURL& origin,
+      RegistrationData* registration,
+      std::vector<ResourceRecord>* resources);
 
-  bool UpdateVersionToActive(int64 registration_id,
-                             const GURL& origin);
-  bool UpdateLastCheckTime(int64 registration_id,
-                           const GURL& origin,
-                           const base::Time& time);
-  bool DeleteRegistration(int64 registration_id,
-                          const GURL& origin);
+  // Writes |registration| and |resources| into the database and does following
+  // things:
+  //   - Deletes an old version of the registration if exists.
+  //   - Bumps the next registration id and the next version id if needed.
+  //   - Removes |resources| from the uncommitted list if exist.
+  // Returns OK they are successfully written. Otherwise, returns an error.
+  ServiceWorkerStatusCode WriteRegistration(
+      const RegistrationData& registration,
+      const std::vector<ResourceRecord>& resources);
+
+  // Updates a registration for |registration_id| to an active state. Returns OK
+  // if it's successfully updated. Otherwise, returns an error.
+  ServiceWorkerStatusCode UpdateVersionToActive(
+      int64 registration_id,
+      const GURL& origin);
+
+  // Updates last check time of a registration for |registration_id| by |time|.
+  // Returns OK if it's successfully updated. Otherwise, returns an error.
+  ServiceWorkerStatusCode UpdateLastCheckTime(
+      int64 registration_id,
+      const GURL& origin,
+      const base::Time& time);
+
+  // Deletes a registration for |registration_id| and moves resource records
+  // associated with it into the purgeable list. Returns OK if it's successfully
+  // deleted or not found in the database. Otherwise, returns an error.
+  ServiceWorkerStatusCode DeleteRegistration(
+      int64 registration_id,
+      const GURL& origin);
 
   // As new resources are put into the diskcache, they go into an uncommitted
   // list. When a registration is saved that refers to those ids, they're
   // removed from that list. When a resource no longer has any registrations or
   // caches referring to it, it's added to the purgeable list. Periodically,
   // the purgeable list can be purged from the diskcache. At system startup, all
   // uncommitted ids are moved to the purgeable list.
 
   // Reads uncommitted resource ids from the database. Returns true on success.
   // Otherwise clears |ids| and returns false.
@@ skipping 12 matching lines @@
   bool GetPurgeableResourceIds(std::set<int64>* ids);
 
   // Writes |ids| into the database as purgeable resources. Returns true on
   // success. Otherwise writes nothing and returns false.
   bool WritePurgeableResourceIds(const std::set<int64>& ids);
 
   // Deletes purgeable resource ids specified by |ids| from the database.
   // Returns true on success. Otherwise deletes nothing and returns false.
   bool ClearPurgeableResourceIds(const std::set<int64>& ids);
 
-  // Delete all data for |origin|, namely, unique origin, registrations and
-  // resource records. Resources are moved to the purgeable list.
-  bool DeleteAllDataForOrigin(const GURL& origin);
+  // Deletes all data for |origin|, namely, unique origin, registrations and
+  // resource records. Resources are moved to the purgeable list. Returns OK if
+  // they are successfully deleted or not found in the database. Otherwise,
+  // returns an error.
+  ServiceWorkerStatusCode DeleteAllDataForOrigin(const GURL& origin);
 
   bool is_disabled() const { return is_disabled_; }
   bool was_corruption_detected() const { return was_corruption_detected_; }
 
  private:
   // Opens the database at the |path_|. This is lazily called when the first
   // database API is called. Returns OK if the database is successfully opened.
   // Returns NOT_FOUND if the database does not exist and |create_if_missing| is
   // false. Otherwise, returns an error.
   ServiceWorkerStatusCode LazyOpen(bool create_if_missing);
 
   // Reads the next available id for |id_key|. Returns OK if it's successfully
   // read. Fills |next_avail_id| with an initial value and returns OK if it's
   // not found in the database. Otherwise, returns an error.
   ServiceWorkerStatusCode ReadNextAvailableId(
       const char* id_key,
       int64* next_avail_id);
 
-  bool ReadRegistrationData(int64 registration_id,
-                            const GURL& origin,
-                            RegistrationData* registration);
-  bool ReadResourceRecords(int64 version_id,
-                           std::vector<ResourceRecord>* resources);
-  bool DeleteResourceRecords(int64 version_id,
-                             leveldb::WriteBatch* batch);
+  // Reads registration data for |registration_id| from the database. Returns OK
+  // if successfully reads. Otherwise, returns an error.
+  ServiceWorkerStatusCode ReadRegistrationData(
+      int64 registration_id,
+      const GURL& origin,
+      RegistrationData* registration);
+
+  // Reads resource records for |version_id| from the database. Returns OK if
+  // it's successfully read or not found in the database. Otherwise, returns an
+  // error.
+  ServiceWorkerStatusCode ReadResourceRecords(
+      int64 version_id,
+      std::vector<ResourceRecord>* resources);
+
+  // Deletes resource records for |version_id| from the database. Returns OK if
+  // they are successfully deleted or not found in the database. Otherwise,
+  // returns an error.
+  ServiceWorkerStatusCode DeleteResourceRecords(
+      int64 version_id,
+      leveldb::WriteBatch* batch);
+
   bool ReadResourceIds(const char* id_key_prefix,
                        std::set<int64>* ids);
   bool WriteResourceIds(const char* id_key_prefix,
                         const std::set<int64>& ids);
   bool DeleteResourceIds(const char* id_key_prefix,
                          const std::set<int64>& ids);
 
   // Reads the current schema version from the database. If the database hasn't
   // been written anything yet, sets |db_version| to 0 and returns OK.
   ServiceWorkerStatusCode ReadDatabaseVersion(int64* db_version);
 
-  // Write a batch into the database.
+  // Writes a batch into the database.
   // NOTE: You must call this when you want to put something into the database
   // because this initializes the database if needed.
-  bool WriteBatch(leveldb::WriteBatch* batch);
+  ServiceWorkerStatusCode WriteBatch(leveldb::WriteBatch* batch);
 
   // Bumps the next available id if |used_id| is greater than or equal to the
   // cached one.
   void BumpNextRegistrationIdIfNeeded(int64 used_id,
                                       leveldb::WriteBatch* batch);
   void BumpNextVersionIdIfNeeded(int64 used_id,
                                  leveldb::WriteBatch* batch);
 
   bool IsOpen();
 
@@ skipping 25 matching lines @@
   FRIEND_TEST_ALL_PREFIXES(ServiceWorkerDatabaseTest, OpenDatabase_InMemory);
   FRIEND_TEST_ALL_PREFIXES(ServiceWorkerDatabaseTest, DatabaseVersion);
   FRIEND_TEST_ALL_PREFIXES(ServiceWorkerDatabaseTest, GetNextAvailableIds);
 
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerDatabase);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_DATABASE_H_