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

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 21 matching lines @@
 // Should NOT be used on the IO thread since this does blocking
 // file io. The ServiceWorkerStorage class owns this class and
 // is responsible for only calling it serially on background
 // non-IO threads (ala SequencedWorkerPool).
 class CONTENT_EXPORT ServiceWorkerDatabase {
  public:
   // We do leveldb stuff in |path| or in memory if |path| is empty.
   explicit ServiceWorkerDatabase(const base::FilePath& path);
   ~ServiceWorkerDatabase();
 
+  enum Status {
+    STATUS_OK,
+    STATUS_ERROR_NOT_FOUND,
+    STATUS_ERROR_CORRUPTED,
+    STATUS_ERROR_FAILED,
+  };
+
   struct CONTENT_EXPORT RegistrationData {
     // These values are immutable for the life of a registration.
     int64 registration_id;
     GURL scope;
     GURL script;
 
     // Versions are first stored once they successfully install and become
     // the waiting version. Then transition to the active version. The stored
     // version may be in the ACTIVE state or in the INSTALLED state.
     int64 version_id;
     bool is_active;
     bool has_fetch_handler;
     base::Time last_update_check;
 
     RegistrationData();
     ~RegistrationData();
   };
 
   struct ResourceRecord {
     int64 resource_id;
     GURL url;
   };
 
-  // For use during initialization.
-  ServiceWorkerStatusCode GetNextAvailableIds(
+  // Reads next available ids from the database. Returns OK if they are
+  // successfully read. Fills the arguments with an initial value and returns
+  // OK if they are not found in the database. Otherwise, returns an error.
+  Status GetNextAvailableIds(
       int64* next_avail_registration_id,
       int64* next_avail_version_id,
       int64* next_avail_resource_id);
-  ServiceWorkerStatusCode GetOriginsWithRegistrations(
-      std::set<GURL>* origins);
 
-  // For use when first handling a request in an origin with registrations.
-  bool GetRegistrationsForOrigin(const GURL& origin,
-                                 std::vector<RegistrationData>* registrations);
+  // Reads origins that have one or more than one registration from the
+  // database. Returns OK if they are successfully read or not found.
+  // Otherwise, returns an error.
+  Status GetOriginsWithRegistrations(std::set<GURL>* origins);
 
-  bool GetAllRegistrations(std::vector<RegistrationData>* registrations);
+  // Reads registrations for |origin| from the database. Returns OK if they are
+  // successfully read or not found. Otherwise, returns an error.
+  Status GetRegistrationsForOrigin(
+      const GURL& origin,
+      std::vector<RegistrationData>* registrations);
+
+  // Reads all registrations from the database. Returns OK if successfully read
+  // or not found. Otherwise, returns an error.
+  Status 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);
@@ skipping 41 matching lines @@
 
   // Delete all data for |origin|, namely, unique origin, registrations and
   // resource records. Resources are moved to the purgeable list.
   bool 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 true if the database was opened. Returns
-  // false if the opening failed or was not neccessary, that is, the database
-  // does not exist and |create_if_needed| is false.
-  bool LazyOpen(bool create_if_needed);
+  // 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.
+  Status LazyOpen(bool create_if_missing);
 
-  ServiceWorkerStatusCode ReadNextAvailableId(
+  // Helper for LazyOpen(). |status| must be the return value from LazyOpen()
+  // and this must be called just after LazyOpen() is called. Returns true if
+  // the database is new or nonexistent, that is, it has never been used.
+  bool IsNewOrNonexistentDatabase(Status status);
+
+  // 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.
+  Status 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);
   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 true.
-  bool ReadDatabaseVersion(int64* db_version);
+  // been written anything yet, sets |db_version| to 0 and returns OK.
+  Status ReadDatabaseVersion(int64* db_version);
 
   // Write 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);
 
   // 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);
@@ skipping 23 matching lines @@
   // True if a database was initialized, that is, the schema version was written
   // in the database.
   bool is_initialized_;
 
   base::SequenceChecker sequence_checker_;
 
   FRIEND_TEST_ALL_PREFIXES(ServiceWorkerDatabaseTest, OpenDatabase);
   FRIEND_TEST_ALL_PREFIXES(ServiceWorkerDatabaseTest, OpenDatabase_InMemory);
   FRIEND_TEST_ALL_PREFIXES(ServiceWorkerDatabaseTest, DatabaseVersion);
   FRIEND_TEST_ALL_PREFIXES(ServiceWorkerDatabaseTest, GetNextAvailableIds);
-  FRIEND_TEST_ALL_PREFIXES(ServiceWorkerDatabaseTest, Registration_Basic);
-  FRIEND_TEST_ALL_PREFIXES(ServiceWorkerDatabaseTest, Registration_Overwrite);
-  FRIEND_TEST_ALL_PREFIXES(ServiceWorkerDatabaseTest, Registration_Multiple);
 
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerDatabase);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_DATABASE_H_