ServiceWorker: Consolidate database state members for cleanup

content/browser/service_worker/service_worker_database.cc

 // 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.
 
 #include "content/browser/service_worker/service_worker_database.h"
 
 #include <string>
 
 #include "base/file_util.h"
 #include "base/location.h"
@@ skipping 222 matching lines @@
 }
 
 ServiceWorkerDatabase::RegistrationData::~RegistrationData() {
 }
 
 ServiceWorkerDatabase::ServiceWorkerDatabase(const base::FilePath& path)
     : path_(path),
       next_avail_registration_id_(0),
       next_avail_resource_id_(0),
       next_avail_version_id_(0),
-      is_disabled_(false),
-      was_corruption_detected_(false),
-      is_initialized_(false) {
+      state_(UNINITIALIZED) {
   sequence_checker_.DetachFromSequence();
 }
 
 ServiceWorkerDatabase::~ServiceWorkerDatabase() {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
   db_.reset();
 }
 
 ServiceWorkerDatabase::Status ServiceWorkerDatabase::GetNextAvailableIds(
     int64* next_avail_registration_id,
@@ skipping 372 matching lines @@
   }
 
   return WriteBatch(&batch);
 }
 
 ServiceWorkerDatabase::Status ServiceWorkerDatabase::LazyOpen(
     bool create_if_missing) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
 
   // Do not try to open a database if we tried and failed once.
-  if (is_disabled_)
+  if (state_ == DISABLED)
     return STATUS_ERROR_FAILED;
   if (IsOpen())
     return STATUS_OK;
 
   // When |path_| is empty, open a database in-memory.
   bool use_in_memory_db = path_.empty();
 
   if (!create_if_missing) {
     // Avoid opening a database if it does not exist at the |path_|.
     if (use_in_memory_db ||
@@ skipping 20 matching lines @@
     return LevelDBStatusToStatus(db_status);
   }
   db_.reset(db);
 
   int64 db_version;
   Status status = ReadDatabaseVersion(&db_version);
   if (status != STATUS_OK)
     return status;
   DCHECK_LE(0, db_version);
   if (db_version > 0)
-    is_initialized_ = true;
+    state_ = INITIALIZED;
   return STATUS_OK;
 }
 
 bool ServiceWorkerDatabase::IsNewOrNonexistentDatabase(
     ServiceWorkerDatabase::Status status) {
   if (status == STATUS_ERROR_NOT_FOUND)
     return true;
-  if (status == STATUS_OK && !is_initialized_)
+  if (status == STATUS_OK && state_ == UNINITIALIZED)
     return true;
   return false;
 }
 
 ServiceWorkerDatabase::Status ServiceWorkerDatabase::ReadNextAvailableId(
     const char* id_key,
     int64* next_avail_id) {
   DCHECK(id_key);
   DCHECK(next_avail_id);
 
@@ skipping 218 matching lines @@
     return STATUS_ERROR_CORRUPTED;
   }
 
   *db_version = parsed;
   return STATUS_OK;
 }
 
 ServiceWorkerDatabase::Status ServiceWorkerDatabase::WriteBatch(
     leveldb::WriteBatch* batch) {
   DCHECK(batch);
-  DCHECK(!is_disabled_);
+  DCHECK_NE(DISABLED, state_);
 
-  if (!is_initialized_) {
+  if (state_ == UNINITIALIZED) {
     // Write the database schema version.
     batch->Put(kDatabaseVersionKey, base::Int64ToString(kCurrentSchemaVersion));
-    is_initialized_ = true;
+    state_ = INITIALIZED;
   }
 
   leveldb::Status status = db_->Write(leveldb::WriteOptions(), batch);
   if (!status.ok())
     HandleError(FROM_HERE, status);
   return LevelDBStatusToStatus(status);
 }
 
 void ServiceWorkerDatabase::BumpNextRegistrationIdIfNeeded(
     int64 used_id, leveldb::WriteBatch* batch) {
   DCHECK(batch);
   if (next_avail_registration_id_ <= used_id) {
     next_avail_registration_id_ = used_id + 1;
     batch->Put(kNextRegIdKey, base::Int64ToString(next_avail_registration_id_));
   }
 }
 
 void ServiceWorkerDatabase::BumpNextVersionIdIfNeeded(
     int64 used_id, leveldb::WriteBatch* batch) {
   DCHECK(batch);
   if (next_avail_version_id_ <= used_id) {
     next_avail_version_id_ = used_id + 1;
     batch->Put(kNextVerIdKey, base::Int64ToString(next_avail_version_id_));
   }
 }
 
 bool ServiceWorkerDatabase::IsOpen() {
-  return db_.get() != NULL;
+  return db_ != NULL;
 }
 
 void ServiceWorkerDatabase::HandleError(
     const tracked_objects::Location& from_here,
     const leveldb::Status& status) {
   // TODO(nhiroki): Add an UMA histogram.
   DLOG(ERROR) << "Failed at: " << from_here.ToString()
               << " with error: " << status.ToString();
-  is_disabled_ = true;
-  if (status.IsCorruption())
-    was_corruption_detected_ = true;
+  state_ = DISABLED;
   db_.reset();
 }
 
 }  // namespace content