Use leveldb_env::OpenDB() to open leveldb databases.

extensions/browser/value_store/lazy_leveldb.cc

 // Copyright 2016 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 "extensions/browser/value_store/lazy_leveldb.h"
 
 #include "base/files/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_util.h"
@@ skipping 164 matching lines @@
   ValueStore::BackingStoreRestoreStatus restore_status =
       ValueStore::RESTORE_NONE;
 
   leveldb::Options repair_options;
   repair_options.create_if_missing = true;
   repair_options.paranoid_checks = true;
 
   // RepairDB can drop an unbounded number of leveldb tables (key/value sets).
   s = leveldb::RepairDB(db_path_.AsUTF8Unsafe(), repair_options);
 
-  leveldb::DB* db = nullptr;
   if (s.ok()) {
     restore_status = ValueStore::DB_RESTORE_REPAIR_SUCCESS;
-    s = leveldb::DB::Open(open_options_, db_path_.AsUTF8Unsafe(), &db);
+    s = leveldb_env::OpenDB(open_options_, db_path_.AsUTF8Unsafe(), &db_);
   }
 
   if (!s.ok()) {
     if (DeleteDbFile()) {
       restore_status = ValueStore::DB_RESTORE_DELETE_SUCCESS;
-      s = leveldb::DB::Open(open_options_, db_path_.AsUTF8Unsafe(), &db);
+      s = leveldb_env::OpenDB(open_options_, db_path_.AsUTF8Unsafe(), &db_);
     } else {
       restore_status = ValueStore::DB_RESTORE_DELETE_FAILURE;
     }
   }
 
-  if (s.ok())
-    db_.reset(db);
-  else
+  if (!s.ok())
     db_unrecoverable_ = true;
 
   if (s.ok() && key) {
     s = DeleteValue(db_.get(), *key);
     if (s.ok()) {
       restore_status = ValueStore::VALUE_RESTORE_DELETE_SUCCESS;
     } else if (s.IsIOError()) {
       restore_status = ValueStore::VALUE_RESTORE_DELETE_FAILURE;
     } else {
-      db_.reset(db);
+      db_.reset();
       if (!DeleteDbFile())
         db_unrecoverable_ = true;
       restore_status = ValueStore::DB_RESTORE_DELETE_FAILURE;
     }
   }
 
   // Only log for the final and most extreme form of database restoration.
   LogRestoreStatus(restore_status);
 
   return restore_status;
 }
 
 ValueStore::Status LazyLevelDb::EnsureDbIsOpen() {
   base::ThreadRestrictions::AssertIOAllowed();
 
   if (db_)
     return ValueStore::Status();
 
   if (db_unrecoverable_) {
     return ValueStore::Status(ValueStore::CORRUPTION,
                               ValueStore::DB_RESTORE_DELETE_FAILURE,
                               "Database corrupted");
   }
 
-  leveldb::DB* db = nullptr;
   leveldb::Status ldb_status =
-      leveldb::DB::Open(open_options_, db_path_.AsUTF8Unsafe(), &db);
+      leveldb_env::OpenDB(open_options_, db_path_.AsUTF8Unsafe(), &db_);
   open_histogram_->Add(leveldb_env::GetLevelDBStatusUMAValue(ldb_status));
   ValueStore::Status status = ToValueStoreError(ldb_status);
-  if (ldb_status.ok()) {
-    db_.reset(db);
-  } else if (ldb_status.IsCorruption()) {
+  if (ldb_status.IsCorruption()) {
     status.restore_status = FixCorruption(nullptr);
     if (status.restore_status != ValueStore::DB_RESTORE_DELETE_FAILURE) {
       status.code = ValueStore::OK;
       status.message = kRestoredDuringOpen;
     }
   }
 
   return status;
 }
 
@@ skipping 25 matching lines @@
 
 ValueStore::Status LazyLevelDb::CreateIterator(
     const leveldb::ReadOptions& read_options,
     std::unique_ptr<leveldb::Iterator>* iterator) {
   ValueStore::Status status = EnsureDbIsOpen();
   if (!status.ok())
     return status;
   *iterator = base::WrapUnique(db_->NewIterator(read_options));
   return ValueStore::Status();
 }