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

content/browser/dom_storage/session_storage_database.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 "content/browser/dom_storage/session_storage_database.h"
 
 #include <inttypes.h>
 #include <stddef.h>
 
 #include <vector>
@@ skipping 339 matching lines @@
   uint64_t size;
   bool res = base::StringToUint64(db_memory_usage, &size);
   DCHECK(res);
 
   auto* mad = pmd->CreateAllocatorDump(
       base::StringPrintf("dom_storage/session_storage_0x%" PRIXPTR,
                          reinterpret_cast<uintptr_t>(this)));
   mad->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize,
                  base::trace_event::MemoryAllocatorDump::kUnitsBytes, size);
 
-  // Memory is allocated from system allocator (malloc).
-  const char* system_allocator_name =
-      base::trace_event::MemoryDumpManager::GetInstance()
-          ->system_allocator_pool_name();
-  if (system_allocator_name)
-    pmd->AddSuballocation(mad->guid(), system_allocator_name);
+  // All leveldb databases are already dumped by leveldb_env::DBTracker. Add
+  // an edge to avoid double counting.
+  pmd->AddSuballocation(mad->guid(),
+                        leveldb_env::DBTracker::GetMemoryDumpName(db_.get()));
 }
 
 bool SessionStorageDatabase::LazyOpen(bool create_if_needed) {
   base::AutoLock auto_lock(db_lock_);
   if (db_error_ || is_inconsistent_) {
     // Don't try to open a database that we know has failed already.
     return false;
   }
   if (IsOpen())
     return true;
 
   if (!create_if_needed &&
       (!base::PathExists(file_path_) || base::IsDirectoryEmpty(file_path_))) {
     // If the directory doesn't exist already and we haven't been asked to
     // create a file on disk, then we don't bother opening the database. This
     // means we wait until we absolutely need to put something onto disk before
     // we do so.
     return false;
   }
 
-  leveldb::DB* db;
-  leveldb::Status s = TryToOpen(&db);
+  leveldb::Status s = TryToOpen(&db_);
   if (!s.ok()) {
     LOG(WARNING) << "Failed to open leveldb in " << file_path_.value()
                  << ", error: " << s.ToString();
-    DCHECK(db == NULL);
 
     // Clear the directory and try again.
     base::DeleteFile(file_path_, true);
-    s = TryToOpen(&db);
+    s = TryToOpen(&db_);
     if (!s.ok()) {
       LOG(WARNING) << "Failed to open leveldb in " << file_path_.value()
                    << ", error: " << s.ToString();
       if (s.IsNotFound()) {
         UMA_HISTOGRAM_ENUMERATION(session_storage_uma_name,
                                   SESSION_STORAGE_UMA_RECREATE_NOT_FOUND,
                                   SESSION_STORAGE_UMA_MAX);
       } else if (s.IsNotSupportedError()) {
         UMA_HISTOGRAM_ENUMERATION(session_storage_uma_name,
                                   SESSION_STORAGE_UMA_RECREATE_NOT_SUPPORTED,
                                   SESSION_STORAGE_UMA_MAX);
       } else if (s.IsCorruption()) {
         UMA_HISTOGRAM_ENUMERATION(session_storage_uma_name,
                                   SESSION_STORAGE_UMA_RECREATE_CORRUPTION,
                                   SESSION_STORAGE_UMA_MAX);
       } else if (s.IsInvalidArgument()) {
         UMA_HISTOGRAM_ENUMERATION(session_storage_uma_name,
                                   SESSION_STORAGE_UMA_RECREATE_INVALID_ARGUMENT,
                                   SESSION_STORAGE_UMA_MAX);
       } else if (s.IsIOError()) {
         UMA_HISTOGRAM_ENUMERATION(session_storage_uma_name,
                                   SESSION_STORAGE_UMA_RECREATE_IO_ERROR,
                                   SESSION_STORAGE_UMA_MAX);
       } else {
         NOTREACHED();
       }
 
-      DCHECK(db == NULL);
       db_error_ = true;
       return false;
     }
     UMA_HISTOGRAM_ENUMERATION(session_storage_uma_name,
                               SESSION_STORAGE_UMA_RECREATED,
                               SESSION_STORAGE_UMA_MAX);
   } else {
     UMA_HISTOGRAM_ENUMERATION(session_storage_uma_name,
                               SESSION_STORAGE_UMA_SUCCESS,
                               SESSION_STORAGE_UMA_MAX);
   }
-  db_.reset(db);
   return true;
 }
 
-leveldb::Status SessionStorageDatabase::TryToOpen(leveldb::DB** db) {
+leveldb::Status SessionStorageDatabase::TryToOpen(
+    std::unique_ptr<leveldb::DB>* db) {
   leveldb::Options options;
   // The directory exists but a valid leveldb database might not exist inside it
   // (e.g., a subset of the needed files might be missing). Handle this
   // situation gracefully by creating the database now.
   options.max_open_files = 0;  // Use minimum.
   options.create_if_missing = true;
   options.reuse_logs = leveldb_env::kDefaultLogReuseOptionValue;
   // Default write_buffer_size is 4 MB but that might leave a 3.999
   // memory allocation in RAM from a log file recovery.
   options.write_buffer_size = 64 * 1024;
-  return leveldb::DB::Open(options, file_path_.AsUTF8Unsafe(), db);
+  return leveldb_env::OpenDB(options, file_path_.AsUTF8Unsafe(), db);
 }
 
 bool SessionStorageDatabase::IsOpen() const {
   return db_.get() != NULL;
 }
 
 bool SessionStorageDatabase::CallerErrorCheck(bool ok) const {
   DCHECK(ok);
   return ok;
 }
@@ skipping 329 matching lines @@
 std::string SessionStorageDatabase::MapKey(const std::string& map_id,
                                            const std::string& key) {
   return base::StringPrintf("map-%s-%s", map_id.c_str(), key.c_str());
 }
 
 const char* SessionStorageDatabase::NextMapIdKey() {
   return "next-map-id";
 }
 
 }  // namespace content