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

components/drive/resource_metadata_storage.cc

 // Copyright 2013 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 "components/drive/resource_metadata_storage.h"
 
 #include <stddef.h>
 
 #include <map>
 #include <set>
@@ skipping 251 matching lines @@
     // be successful. Discard the imperfect new DB and restore the old DB.
     if (!base::DeleteFile(resource_map_path, false /* recursive */) ||
         !base::Move(preserved_resource_map_path, resource_map_path))
       return false;
   }
 
   if (!base::PathExists(resource_map_path))
     return false;
 
   // Open DB.
-  leveldb::DB* db = NULL;
+  std::unique_ptr<leveldb::DB> resource_map;
   leveldb::Options options;
   options.max_open_files = 0;  // Use minimum.
   options.create_if_missing = false;
   options.reuse_logs = leveldb_env::kDefaultLogReuseOptionValue;
-  if (!leveldb::DB::Open(options, resource_map_path.AsUTF8Unsafe(), &db).ok())
+  leveldb::Status status = leveldb_env::OpenDB(
+      options, resource_map_path.AsUTF8Unsafe(), &resource_map);
+  if (!status.ok())
     return false;
-  std::unique_ptr<leveldb::DB> resource_map(db);
 
   // Check DB version.
   std::string serialized_header;
   ResourceMetadataHeader header;
   if (!resource_map->Get(leveldb::ReadOptions(),
                          leveldb::Slice(GetHeaderDBKey()),
                          &serialized_header).ok() ||
       !header.ParseFromString(serialized_header))
     return false;
   UMA_HISTOGRAM_SPARSE_SLOWLY("Drive.MetadataDBVersionBeforeUpgradeCheck",
@@ skipping 255 matching lines @@
       directory_path_.Append(kTrashedResourceMapDBName);
 
   // Discard unneeded DBs.
   if (!base::DeleteFile(preserved_resource_map_path, true /* recursive */) ||
       !base::DeleteFile(trashed_resource_map_path, true /* recursive */)) {
     LOG(ERROR) << "Failed to remove unneeded DBs.";
     return false;
   }
 
   // Try to open the existing DB.
-  leveldb::DB* db = NULL;
   leveldb::Options options;
   options.max_open_files = 0;  // Use minimum.
   options.create_if_missing = false;
   options.reuse_logs = leveldb_env::kDefaultLogReuseOptionValue;
 
   DBInitStatus open_existing_result = DB_INIT_NOT_FOUND;
   leveldb::Status status;
   if (base::PathExists(resource_map_path)) {
-    status = leveldb::DB::Open(options, resource_map_path.AsUTF8Unsafe(), &db);
+    status = leveldb_env::OpenDB(options, resource_map_path.AsUTF8Unsafe(),
+                                 &resource_map_);
     open_existing_result = LevelDBStatusToDBInitStatus(status);
   }
 
   if (open_existing_result == DB_INIT_SUCCESS) {
-    resource_map_.reset(db);
-
     // Check the validity of existing DB.
     int db_version = -1;
     ResourceMetadataHeader header;
     if (GetHeader(&header) == FILE_ERROR_OK)
       db_version = header.version();
 
     bool should_discard_db = true;
     if (db_version != kDBVersion) {
       open_existing_result = DB_INIT_INCOMPATIBLE;
       DVLOG(1) << "Reject incompatible DB.";
@@ skipping 22 matching lines @@
     // deleted once the new DB creation succeeds, or is restored later in
     // UpgradeOldDB() when the creation fails.
     MoveIfPossible(resource_map_path, preserved_resource_map_path);
 
     // Create DB.
     options.max_open_files = 0;  // Use minimum.
     options.create_if_missing = true;
     options.error_if_exists = true;
     options.reuse_logs = leveldb_env::kDefaultLogReuseOptionValue;
 
-    status = leveldb::DB::Open(options, resource_map_path.AsUTF8Unsafe(), &db);
+    status = leveldb_env::OpenDB(options, resource_map_path.AsUTF8Unsafe(),
+                                 &resource_map_);
     if (status.ok()) {
-      resource_map_.reset(db);
-
       // Set up header and trash the old DB.
       if (PutHeader(GetDefaultHeaderEntry()) == FILE_ERROR_OK &&
           MoveIfPossible(preserved_resource_map_path,
                          trashed_resource_map_path)) {
         init_result = open_existing_result == DB_INIT_NOT_FOUND ?
             DB_INIT_CREATED_NEW_DB : DB_INIT_REPLACED_EXISTING_DB_WITH_NEW_DB;
       } else {
         init_result = DB_INIT_FAILED;
         resource_map_.reset();
       }
@@ skipping 42 matching lines @@
 
   // Trashed DB may be broken, repair it first.
   leveldb::Status status;
   status = leveldb::RepairDB(trashed_resource_map_path.AsUTF8Unsafe(), options);
   if (!status.ok()) {
     LOG(ERROR) << "Failed to repair trashed DB: " << status.ToString();
     return;
   }
 
   // Open it.
-  leveldb::DB* db = NULL;
-  status = leveldb::DB::Open(options, trashed_resource_map_path.AsUTF8Unsafe(),
-                             &db);
+  std::unique_ptr<leveldb::DB> resource_map;
+  status = leveldb_env::OpenDB(
+      options, trashed_resource_map_path.AsUTF8Unsafe(), &resource_map);
   if (!status.ok()) {
     LOG(ERROR) << "Failed to open trashed DB: " << status.ToString();
     return;
   }
-  std::unique_ptr<leveldb::DB> resource_map(db);
 
   // Check DB version.
   std::string serialized_header;
   ResourceMetadataHeader header;
   if (!resource_map->Get(leveldb::ReadOptions(),
                          leveldb::Slice(GetHeaderDBKey()),
                          &serialized_header).ok() ||
       !header.ParseFromString(serialized_header) ||
       header.version() != kDBVersion) {
     LOG(ERROR) << "Incompatible DB version: " << header.version();
@@ skipping 382 matching lines @@
     RecordCheckValidityFailure(
         CHECK_VALIDITY_FAILURE_CHILD_ENTRY_COUNT_MISMATCH);
     return false;
   }
 
   return true;
 }
 
 }  // namespace internal
 }  // namespace drive