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 49 matching lines @@
 
     RegistrationData();
     ~RegistrationData();
   };
 
   struct ResourceRecord {
     int64 resource_id;
     GURL url;
   };
 
-  // For use during initialization.
+  // 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.
   ServiceWorkerStatusCode GetNextAvailableIds(
       int64* next_avail_registration_id,
       int64* next_avail_version_id,
       int64* next_avail_resource_id);
+
+  // 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.
   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 registrations for |origin| from the database. Returns OK if they are
+  // successfully read or not found. Otherwise, returns an error.
+  ServiceWorkerStatusCode GetRegistrationsForOrigin(
+      const GURL& origin,
+      std::vector<RegistrationData>* registrations);
 
-  bool GetAllRegistrations(std::vector<RegistrationData>* registrations);
+  // 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);
@@ 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.
+  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);
   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.
+  ServiceWorkerStatusCode 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_