content/browser/indexed_db/leveldb/leveldb_database.cc - platform/external/chromium_org - Git at Google

 // Copyright (c) 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/indexed_db/leveldb/leveldb_database.h"

 #include <cerrno>

 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/sys_info.h"
 #include "content/browser/indexed_db/leveldb/leveldb_comparator.h"
 #include "content/browser/indexed_db/leveldb/leveldb_iterator.h"
 #include "content/browser/indexed_db/leveldb/leveldb_write_batch.h"
 #include "third_party/leveldatabase/env_chromium.h"
 #include "third_party/leveldatabase/env_idb.h"
 #include "third_party/leveldatabase/src/helpers/memenv/memenv.h"
 #include "third_party/leveldatabase/src/include/leveldb/comparator.h"
 #include "third_party/leveldatabase/src/include/leveldb/db.h"
 #include "third_party/leveldatabase/src/include/leveldb/env.h"
 #include "third_party/leveldatabase/src/include/leveldb/slice.h"

 using base::StringPiece;

 namespace content {

 // Forcing flushes to disk at the end of a transaction guarantees that the
 // data hit disk, but drastically impacts throughput when the filesystem is
 // busy with background compactions. Not syncing trades off reliability for
 // performance. Note that background compactions which move data from the
 // log to SSTs are still done with reliable writes.
 //
 // Sync writes are necessary on Windows for quota calculations; POSIX
 // calculates file sizes correctly even when not synced to disk.
 #if defined(OS_WIN)
 static const bool kSyncWrites = true;
 #else
 static const bool kSyncWrites = false;
 #endif

 static leveldb::Slice MakeSlice(const StringPiece& s) {
   return leveldb::Slice(s.begin(), s.size());
 }

 static StringPiece MakeStringPiece(const leveldb::Slice& s) {
   return StringPiece(s.data(), s.size());
 }

 class ComparatorAdapter : public leveldb::Comparator {
  public:
   explicit ComparatorAdapter(const LevelDBComparator* comparator)
       : comparator_(comparator) {}

   virtual int Compare(const leveldb::Slice& a, const leveldb::Slice& b) const
       OVERRIDE {
     return comparator_->Compare(MakeStringPiece(a), MakeStringPiece(b));
   }

   virtual const char* Name() const OVERRIDE { return comparator_->Name(); }

   // TODO(jsbell): Support the methods below in the future.
   virtual void FindShortestSeparator(std::string* start,
                                      const leveldb::Slice& limit) const
       OVERRIDE {}
   virtual void FindShortSuccessor(std::string* key) const OVERRIDE {}

  private:
   const LevelDBComparator* comparator_;
 };

 LevelDBSnapshot::LevelDBSnapshot(LevelDBDatabase* db)
     : db_(db->db_.get()), snapshot_(db_->GetSnapshot()) {}

 LevelDBSnapshot::~LevelDBSnapshot() { db_->ReleaseSnapshot(snapshot_); }

 LevelDBDatabase::LevelDBDatabase() {}

 LevelDBDatabase::~LevelDBDatabase() {
   // db_'s destructor uses comparator_adapter_; order of deletion is important.
   db_.reset();
   comparator_adapter_.reset();
   env_.reset();
 }

 static leveldb::Status OpenDB(leveldb::Comparator* comparator,
                               leveldb::Env* env,
                               const base::FilePath& path,
                               leveldb::DB** db) {
   leveldb::Options options;
   options.comparator = comparator;
   options.create_if_missing = true;
   options.paranoid_checks = true;
   options.compression = leveldb::kSnappyCompression;

   // For info about the troubles we've run into with this parameter, see:
   // https://code.google.com/p/chromium/issues/detail?id=227313#c11
   options.max_open_files = 80;
   options.env = env;

   // ChromiumEnv assumes UTF8, converts back to FilePath before using.
   return leveldb::DB::Open(options, path.AsUTF8Unsafe(), db);
 }

 bool LevelDBDatabase::Destroy(const base::FilePath& file_name) {
   leveldb::Options options;
   options.env = leveldb::IDBEnv();
   // ChromiumEnv assumes UTF8, converts back to FilePath before using.
   const leveldb::Status s =
       leveldb::DestroyDB(file_name.AsUTF8Unsafe(), options);
   return s.ok();
 }

 namespace {
 class LockImpl : public LevelDBLock {
  public:
   explicit LockImpl(leveldb::Env* env, leveldb::FileLock* lock)
       : env_(env), lock_(lock) {}
   virtual ~LockImpl() { env_->UnlockFile(lock_); }
  private:
   leveldb::Env* env_;
   leveldb::FileLock* lock_;
 };
 }

 scoped_ptr<LevelDBLock> LevelDBDatabase::LockForTesting(
     const base::FilePath& file_name) {
   leveldb::Env* env = leveldb::IDBEnv();
   base::FilePath lock_path = file_name.AppendASCII("LOCK");
   leveldb::FileLock* lock = NULL;
   leveldb::Status status = env->LockFile(lock_path.AsUTF8Unsafe(), &lock);
   if (!status.ok())
     return scoped_ptr<LevelDBLock>();
   DCHECK(lock);
   return scoped_ptr<LevelDBLock>(new LockImpl(env, lock));
 }

 static int CheckFreeSpace(const char* const type,
                           const base::FilePath& file_name) {
   std::string name =
       std::string("WebCore.IndexedDB.LevelDB.Open") + type + "FreeDiskSpace";
   int64 free_disk_space_in_k_bytes =
       base::SysInfo::AmountOfFreeDiskSpace(file_name) / 1024;
   if (free_disk_space_in_k_bytes < 0) {
     base::Histogram::FactoryGet(
         "WebCore.IndexedDB.LevelDB.FreeDiskSpaceFailure",
         1,
         2 /*boundary*/,
         2 /*boundary*/ + 1,
         base::HistogramBase::kUmaTargetedHistogramFlag)->Add(1 /*sample*/);
     return -1;
   }
   int clamped_disk_space_k_bytes = free_disk_space_in_k_bytes > INT_MAX
                                        ? INT_MAX
                                        : free_disk_space_in_k_bytes;
   const uint64 histogram_max = static_cast<uint64>(1e9);
   COMPILE_ASSERT(histogram_max <= INT_MAX, histogram_max_too_big);
   base::Histogram::FactoryGet(name,
                               1,
                               histogram_max,
                               11 /*buckets*/,
                               base::HistogramBase::kUmaTargetedHistogramFlag)
       ->Add(clamped_disk_space_k_bytes);
   return clamped_disk_space_k_bytes;
 }

 static void ParseAndHistogramIOErrorDetails(const std::string& histogram_name,
                                             const leveldb::Status& s) {
   leveldb_env::MethodID method;
   int error = -1;
   leveldb_env::ErrorParsingResult result =
       leveldb_env::ParseMethodAndError(s.ToString().c_str(), &method, &error);
   if (result == leveldb_env::NONE)
     return;
   std::string method_histogram_name(histogram_name);
   method_histogram_name.append(".EnvMethod");
   base::LinearHistogram::FactoryGet(
       method_histogram_name,
       1,
       leveldb_env::kNumEntries,
       leveldb_env::kNumEntries + 1,
       base::HistogramBase::kUmaTargetedHistogramFlag)->Add(method);

   std::string error_histogram_name(histogram_name);

   if (result == leveldb_env::METHOD_AND_PFE) {
     DCHECK(error < 0);
     error_histogram_name.append(std::string(".PFE.") +
                                 leveldb_env::MethodIDToString(method));
     base::LinearHistogram::FactoryGet(
         error_histogram_name,
         1,
         -base::PLATFORM_FILE_ERROR_MAX,
         -base::PLATFORM_FILE_ERROR_MAX + 1,
         base::HistogramBase::kUmaTargetedHistogramFlag)->Add(-error);
   } else if (result == leveldb_env::METHOD_AND_ERRNO) {
     error_histogram_name.append(std::string(".Errno.") +
                                 leveldb_env::MethodIDToString(method));
     base::LinearHistogram::FactoryGet(
         error_histogram_name,
         1,
         ERANGE + 1,
         ERANGE + 2,
         base::HistogramBase::kUmaTargetedHistogramFlag)->Add(error);
   }
 }

 static void ParseAndHistogramCorruptionDetails(
     const std::string& histogram_name,
     const leveldb::Status& status) {
   int error = leveldb_env::ParseCorruptionMessage(status);
   DCHECK(error >= 0);
   std::string corruption_histogram_name(histogram_name);
   corruption_histogram_name.append(".Corruption");
   const int kNumPatterns = leveldb_env::GetNumCorruptionPatterns();
   base::LinearHistogram::FactoryGet(
       corruption_histogram_name,
       1,
       kNumPatterns,
       kNumPatterns + 1,
       base::HistogramBase::kUmaTargetedHistogramFlag)->Add(error);
 }

 static void HistogramLevelDBError(const std::string& histogram_name,
                                   const leveldb::Status& s) {
   if (s.ok()) {
     NOTREACHED();
     return;
   }
   enum {
     LEVEL_DB_NOT_FOUND,
     LEVEL_DB_CORRUPTION,
     LEVEL_DB_IO_ERROR,
     LEVEL_DB_OTHER,
     LEVEL_DB_MAX_ERROR
   };
   int leveldb_error = LEVEL_DB_OTHER;
   if (s.IsNotFound())
     leveldb_error = LEVEL_DB_NOT_FOUND;
   else if (s.IsCorruption())
     leveldb_error = LEVEL_DB_CORRUPTION;
   else if (s.IsIOError())
     leveldb_error = LEVEL_DB_IO_ERROR;
   base::Histogram::FactoryGet(histogram_name,
                               1,
                               LEVEL_DB_MAX_ERROR,
                               LEVEL_DB_MAX_ERROR + 1,
                               base::HistogramBase::kUmaTargetedHistogramFlag)
       ->Add(leveldb_error);
   if (s.IsIOError())
     ParseAndHistogramIOErrorDetails(histogram_name, s);
   else
     ParseAndHistogramCorruptionDetails(histogram_name, s);
 }

 leveldb::Status LevelDBDatabase::Open(const base::FilePath& file_name,
                                       const LevelDBComparator* comparator,
                                       scoped_ptr<LevelDBDatabase>* result,
                                       bool* is_disk_full) {
   scoped_ptr<ComparatorAdapter> comparator_adapter(
       new ComparatorAdapter(comparator));

   leveldb::DB* db;
   const leveldb::Status s =
       OpenDB(comparator_adapter.get(), leveldb::IDBEnv(), file_name, &db);

   if (!s.ok()) {
     HistogramLevelDBError("WebCore.IndexedDB.LevelDBOpenErrors", s);
     int free_space_k_bytes = CheckFreeSpace("Failure", file_name);
     // Disks with <100k of free space almost never succeed in opening a
     // leveldb database.
     if (is_disk_full)
       *is_disk_full = free_space_k_bytes >= 0 && free_space_k_bytes < 100;

     LOG(ERROR) << "Failed to open LevelDB database from "
                << file_name.AsUTF8Unsafe() << "," << s.ToString();
     return s;
   }

   CheckFreeSpace("Success", file_name);

   (*result).reset(new LevelDBDatabase);
   (*result)->db_ = make_scoped_ptr(db);
   (*result)->comparator_adapter_ = comparator_adapter.Pass();
   (*result)->comparator_ = comparator;

   return s;
 }

 scoped_ptr<LevelDBDatabase> LevelDBDatabase::OpenInMemory(
     const LevelDBComparator* comparator) {
   scoped_ptr<ComparatorAdapter> comparator_adapter(
       new ComparatorAdapter(comparator));
   scoped_ptr<leveldb::Env> in_memory_env(leveldb::NewMemEnv(leveldb::IDBEnv()));

   leveldb::DB* db;
   const leveldb::Status s = OpenDB(
       comparator_adapter.get(), in_memory_env.get(), base::FilePath(), &db);

   if (!s.ok()) {
     LOG(ERROR) << "Failed to open in-memory LevelDB database: " << s.ToString();
     return scoped_ptr<LevelDBDatabase>();
   }

   scoped_ptr<LevelDBDatabase> result(new LevelDBDatabase);
   result->env_ = in_memory_env.Pass();
   result->db_ = make_scoped_ptr(db);
   result->comparator_adapter_ = comparator_adapter.Pass();
   result->comparator_ = comparator;

   return result.Pass();
 }

 bool LevelDBDatabase::Put(const StringPiece& key, std::string* value) {
   leveldb::WriteOptions write_options;
   write_options.sync = kSyncWrites;

   const leveldb::Status s =
       db_->Put(write_options, MakeSlice(key), MakeSlice(*value));
   if (s.ok())
     return true;
   LOG(ERROR) << "LevelDB put failed: " << s.ToString();
   return false;
 }

 bool LevelDBDatabase::Remove(const StringPiece& key) {
   leveldb::WriteOptions write_options;
   write_options.sync = kSyncWrites;

   const leveldb::Status s = db_->Delete(write_options, MakeSlice(key));
   if (s.ok())
     return true;
   if (s.IsNotFound())
     return false;
   LOG(ERROR) << "LevelDB remove failed: " << s.ToString();
   return false;
 }

 bool LevelDBDatabase::Get(const StringPiece& key,
                           std::string* value,
                           bool* found,
                           const LevelDBSnapshot* snapshot) {
   *found = false;
   leveldb::ReadOptions read_options;
   read_options.verify_checksums = true;  // TODO(jsbell): Disable this if the
                                          // performance impact is too great.
   read_options.snapshot = snapshot ? snapshot->snapshot_ : 0;

   const leveldb::Status s = db_->Get(read_options, MakeSlice(key), value);
   if (s.ok()) {
     *found = true;
     return true;
   }
   if (s.IsNotFound())
     return true;
   HistogramLevelDBError("WebCore.IndexedDB.LevelDBReadErrors", s);
   LOG(ERROR) << "LevelDB get failed: " << s.ToString();
   return false;
 }

 bool LevelDBDatabase::Write(const LevelDBWriteBatch& write_batch) {
   leveldb::WriteOptions write_options;
   write_options.sync = kSyncWrites;

   const leveldb::Status s =
       db_->Write(write_options, write_batch.write_batch_.get());
   if (s.ok())
     return true;
   HistogramLevelDBError("WebCore.IndexedDB.LevelDBWriteErrors", s);
   LOG(ERROR) << "LevelDB write failed: " << s.ToString();
   return false;
 }

 namespace {
 class IteratorImpl : public LevelDBIterator {
  public:
   virtual ~IteratorImpl() {}

   virtual bool IsValid() const OVERRIDE;
   virtual void SeekToLast() OVERRIDE;
   virtual void Seek(const StringPiece& target) OVERRIDE;
   virtual void Next() OVERRIDE;
   virtual void Prev() OVERRIDE;
   virtual StringPiece Key() const OVERRIDE;
   virtual StringPiece Value() const OVERRIDE;

  private:
   friend class content::LevelDBDatabase;
   explicit IteratorImpl(scoped_ptr<leveldb::Iterator> iterator);
   void CheckStatus();

   scoped_ptr<leveldb::Iterator> iterator_;
 };
 }

 IteratorImpl::IteratorImpl(scoped_ptr<leveldb::Iterator> it)
     : iterator_(it.Pass()) {}

 void IteratorImpl::CheckStatus() {
   const leveldb::Status s = iterator_->status();
   if (!s.ok())
     LOG(ERROR) << "LevelDB iterator error: " << s.ToString();
 }

 bool IteratorImpl::IsValid() const { return iterator_->Valid(); }

 void IteratorImpl::SeekToLast() {
   iterator_->SeekToLast();
   CheckStatus();
 }

 void IteratorImpl::Seek(const StringPiece& target) {
   iterator_->Seek(MakeSlice(target));
   CheckStatus();
 }

 void IteratorImpl::Next() {
   DCHECK(IsValid());
   iterator_->Next();
   CheckStatus();
 }

 void IteratorImpl::Prev() {
   DCHECK(IsValid());
   iterator_->Prev();
   CheckStatus();
 }

 StringPiece IteratorImpl::Key() const {
   DCHECK(IsValid());
   return MakeStringPiece(iterator_->key());
 }

 StringPiece IteratorImpl::Value() const {
   DCHECK(IsValid());
   return MakeStringPiece(iterator_->value());
 }

 scoped_ptr<LevelDBIterator> LevelDBDatabase::CreateIterator(
     const LevelDBSnapshot* snapshot) {
   leveldb::ReadOptions read_options;
   read_options.verify_checksums = true;  // TODO(jsbell): Disable this if the
                                          // performance impact is too great.
   read_options.snapshot = snapshot ? snapshot->snapshot_ : 0;

   scoped_ptr<leveldb::Iterator> i(db_->NewIterator(read_options));
   return scoped_ptr<LevelDBIterator>(new IteratorImpl(i.Pass()));
 }

 const LevelDBComparator* LevelDBDatabase::Comparator() const {
   return comparator_;
 }

 }  // namespace content
	// Copyright (c) 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/indexed_db/leveldb/leveldb_database.h"

	#include <cerrno>

	#include "base/basictypes.h"
	#include "base/logging.h"
	#include "base/memory/scoped_ptr.h"
	#include "base/metrics/histogram.h"
	#include "base/strings/string16.h"
	#include "base/strings/string_piece.h"
	#include "base/strings/stringprintf.h"
	#include "base/strings/utf_string_conversions.h"
	#include "base/sys_info.h"
	#include "content/browser/indexed_db/leveldb/leveldb_comparator.h"
	#include "content/browser/indexed_db/leveldb/leveldb_iterator.h"
	#include "content/browser/indexed_db/leveldb/leveldb_write_batch.h"
	#include "third_party/leveldatabase/env_chromium.h"
	#include "third_party/leveldatabase/env_idb.h"
	#include "third_party/leveldatabase/src/helpers/memenv/memenv.h"
	#include "third_party/leveldatabase/src/include/leveldb/comparator.h"
	#include "third_party/leveldatabase/src/include/leveldb/db.h"
	#include "third_party/leveldatabase/src/include/leveldb/env.h"
	#include "third_party/leveldatabase/src/include/leveldb/slice.h"

	using base::StringPiece;

	namespace content {

	// Forcing flushes to disk at the end of a transaction guarantees that the
	// data hit disk, but drastically impacts throughput when the filesystem is
	// busy with background compactions. Not syncing trades off reliability for
	// performance. Note that background compactions which move data from the
	// log to SSTs are still done with reliable writes.
	//
	// Sync writes are necessary on Windows for quota calculations; POSIX
	// calculates file sizes correctly even when not synced to disk.
	#if defined(OS_WIN)
	static const bool kSyncWrites = true;
	#else
	static const bool kSyncWrites = false;
	#endif

	static leveldb::Slice MakeSlice(const StringPiece& s) {
	return leveldb::Slice(s.begin(), s.size());
	}

	static StringPiece MakeStringPiece(const leveldb::Slice& s) {
	return StringPiece(s.data(), s.size());
	}

	class ComparatorAdapter : public leveldb::Comparator {
	public:
	explicit ComparatorAdapter(const LevelDBComparator* comparator)
	: comparator_(comparator) {}

	virtual int Compare(const leveldb::Slice& a, const leveldb::Slice& b) const
	OVERRIDE {
	return comparator_->Compare(MakeStringPiece(a), MakeStringPiece(b));
	}

	virtual const char* Name() const OVERRIDE { return comparator_->Name(); }

	// TODO(jsbell): Support the methods below in the future.
	virtual void FindShortestSeparator(std::string* start,
	const leveldb::Slice& limit) const
	OVERRIDE {}
	virtual void FindShortSuccessor(std::string* key) const OVERRIDE {}

	private:
	const LevelDBComparator* comparator_;
	};

	LevelDBSnapshot::LevelDBSnapshot(LevelDBDatabase* db)
	: db_(db->db_.get()), snapshot_(db_->GetSnapshot()) {}

	LevelDBSnapshot::~LevelDBSnapshot() { db_->ReleaseSnapshot(snapshot_); }

	LevelDBDatabase::LevelDBDatabase() {}

	LevelDBDatabase::~LevelDBDatabase() {
	// db_'s destructor uses comparator_adapter_; order of deletion is important.
	db_.reset();
	comparator_adapter_.reset();
	env_.reset();
	}

	static leveldb::Status OpenDB(leveldb::Comparator* comparator,
	leveldb::Env* env,
	const base::FilePath& path,
	leveldb::DB** db) {
	leveldb::Options options;
	options.comparator = comparator;
	options.create_if_missing = true;
	options.paranoid_checks = true;
	options.compression = leveldb::kSnappyCompression;

	// For info about the troubles we've run into with this parameter, see:
	// https://code.google.com/p/chromium/issues/detail?id=227313#c11
	options.max_open_files = 80;
	options.env = env;

	// ChromiumEnv assumes UTF8, converts back to FilePath before using.
	return leveldb::DB::Open(options, path.AsUTF8Unsafe(), db);
	}

	bool LevelDBDatabase::Destroy(const base::FilePath& file_name) {
	leveldb::Options options;
	options.env = leveldb::IDBEnv();
	// ChromiumEnv assumes UTF8, converts back to FilePath before using.
	const leveldb::Status s =
	leveldb::DestroyDB(file_name.AsUTF8Unsafe(), options);
	return s.ok();
	}

	namespace {
	class LockImpl : public LevelDBLock {
	public:
	explicit LockImpl(leveldb::Env* env, leveldb::FileLock* lock)
	: env_(env), lock_(lock) {}
	virtual ~LockImpl() { env_->UnlockFile(lock_); }
	private:
	leveldb::Env* env_;
	leveldb::FileLock* lock_;
	};
	}

	scoped_ptr<LevelDBLock> LevelDBDatabase::LockForTesting(
	const base::FilePath& file_name) {
	leveldb::Env* env = leveldb::IDBEnv();
	base::FilePath lock_path = file_name.AppendASCII("LOCK");
	leveldb::FileLock* lock = NULL;
	leveldb::Status status = env->LockFile(lock_path.AsUTF8Unsafe(), &lock);
	if (!status.ok())
	return scoped_ptr<LevelDBLock>();
	DCHECK(lock);
	return scoped_ptr<LevelDBLock>(new LockImpl(env, lock));
	}

	static int CheckFreeSpace(const char* const type,
	const base::FilePath& file_name) {
	std::string name =
	std::string("WebCore.IndexedDB.LevelDB.Open") + type + "FreeDiskSpace";
	int64 free_disk_space_in_k_bytes =
	base::SysInfo::AmountOfFreeDiskSpace(file_name) / 1024;
	if (free_disk_space_in_k_bytes < 0) {
	base::Histogram::FactoryGet(
	"WebCore.IndexedDB.LevelDB.FreeDiskSpaceFailure",
	1,
	2 /boundary/,
	2 /boundary/ + 1,
	base::HistogramBase::kUmaTargetedHistogramFlag)->Add(1 /sample/);
	return -1;
	}
	int clamped_disk_space_k_bytes = free_disk_space_in_k_bytes > INT_MAX
	? INT_MAX
	: free_disk_space_in_k_bytes;
	const uint64 histogram_max = static_cast<uint64>(1e9);
	COMPILE_ASSERT(histogram_max <= INT_MAX, histogram_max_too_big);
	base::Histogram::FactoryGet(name,
	1,
	histogram_max,
	11 /buckets/,
	base::HistogramBase::kUmaTargetedHistogramFlag)
	->Add(clamped_disk_space_k_bytes);
	return clamped_disk_space_k_bytes;
	}

	static void ParseAndHistogramIOErrorDetails(const std::string& histogram_name,
	const leveldb::Status& s) {
	leveldb_env::MethodID method;
	int error = -1;
	leveldb_env::ErrorParsingResult result =
	leveldb_env::ParseMethodAndError(s.ToString().c_str(), &method, &error);
	if (result == leveldb_env::NONE)
	return;
	std::string method_histogram_name(histogram_name);
	method_histogram_name.append(".EnvMethod");
	base::LinearHistogram::FactoryGet(
	method_histogram_name,
	1,
	leveldb_env::kNumEntries,
	leveldb_env::kNumEntries + 1,
	base::HistogramBase::kUmaTargetedHistogramFlag)->Add(method);

	std::string error_histogram_name(histogram_name);

	if (result == leveldb_env::METHOD_AND_PFE) {
	DCHECK(error < 0);
	error_histogram_name.append(std::string(".PFE.") +
	leveldb_env::MethodIDToString(method));
	base::LinearHistogram::FactoryGet(
	error_histogram_name,
	1,
	-base::PLATFORM_FILE_ERROR_MAX,
	-base::PLATFORM_FILE_ERROR_MAX + 1,
	base::HistogramBase::kUmaTargetedHistogramFlag)->Add(-error);
	} else if (result == leveldb_env::METHOD_AND_ERRNO) {
	error_histogram_name.append(std::string(".Errno.") +
	leveldb_env::MethodIDToString(method));
	base::LinearHistogram::FactoryGet(
	error_histogram_name,
	1,
	ERANGE + 1,
	ERANGE + 2,
	base::HistogramBase::kUmaTargetedHistogramFlag)->Add(error);
	}
	}

	static void ParseAndHistogramCorruptionDetails(
	const std::string& histogram_name,
	const leveldb::Status& status) {
	int error = leveldb_env::ParseCorruptionMessage(status);
	DCHECK(error >= 0);
	std::string corruption_histogram_name(histogram_name);
	corruption_histogram_name.append(".Corruption");
	const int kNumPatterns = leveldb_env::GetNumCorruptionPatterns();
	base::LinearHistogram::FactoryGet(
	corruption_histogram_name,
	1,
	kNumPatterns,
	kNumPatterns + 1,
	base::HistogramBase::kUmaTargetedHistogramFlag)->Add(error);
	}

	static void HistogramLevelDBError(const std::string& histogram_name,
	const leveldb::Status& s) {
	if (s.ok()) {
	NOTREACHED();
	return;
	}
	enum {
	LEVEL_DB_NOT_FOUND,
	LEVEL_DB_CORRUPTION,
	LEVEL_DB_IO_ERROR,
	LEVEL_DB_OTHER,
	LEVEL_DB_MAX_ERROR
	};
	int leveldb_error = LEVEL_DB_OTHER;
	if (s.IsNotFound())
	leveldb_error = LEVEL_DB_NOT_FOUND;
	else if (s.IsCorruption())
	leveldb_error = LEVEL_DB_CORRUPTION;
	else if (s.IsIOError())
	leveldb_error = LEVEL_DB_IO_ERROR;
	base::Histogram::FactoryGet(histogram_name,
	1,
	LEVEL_DB_MAX_ERROR,
	LEVEL_DB_MAX_ERROR + 1,
	base::HistogramBase::kUmaTargetedHistogramFlag)
	->Add(leveldb_error);
	if (s.IsIOError())
	ParseAndHistogramIOErrorDetails(histogram_name, s);
	else
	ParseAndHistogramCorruptionDetails(histogram_name, s);
	}

	leveldb::Status LevelDBDatabase::Open(const base::FilePath& file_name,
	const LevelDBComparator* comparator,
	scoped_ptr<LevelDBDatabase>* result,
	bool* is_disk_full) {
	scoped_ptr<ComparatorAdapter> comparator_adapter(
	new ComparatorAdapter(comparator));

	leveldb::DB* db;
	const leveldb::Status s =
	OpenDB(comparator_adapter.get(), leveldb::IDBEnv(), file_name, &db);

	if (!s.ok()) {
	HistogramLevelDBError("WebCore.IndexedDB.LevelDBOpenErrors", s);
	int free_space_k_bytes = CheckFreeSpace("Failure", file_name);
	// Disks with <100k of free space almost never succeed in opening a
	// leveldb database.
	if (is_disk_full)
	*is_disk_full = free_space_k_bytes >= 0 && free_space_k_bytes < 100;

	LOG(ERROR) << "Failed to open LevelDB database from "
	<< file_name.AsUTF8Unsafe() << "," << s.ToString();
	return s;
	}

	CheckFreeSpace("Success", file_name);

	(*result).reset(new LevelDBDatabase);
	(*result)->db_ = make_scoped_ptr(db);
	(*result)->comparator_adapter_ = comparator_adapter.Pass();
	(*result)->comparator_ = comparator;

	return s;
	}

	scoped_ptr<LevelDBDatabase> LevelDBDatabase::OpenInMemory(
	const LevelDBComparator* comparator) {
	scoped_ptr<ComparatorAdapter> comparator_adapter(
	new ComparatorAdapter(comparator));
	scoped_ptr<leveldb::Env> in_memory_env(leveldb::NewMemEnv(leveldb::IDBEnv()));

	leveldb::DB* db;
	const leveldb::Status s = OpenDB(
	comparator_adapter.get(), in_memory_env.get(), base::FilePath(), &db);

	if (!s.ok()) {
	LOG(ERROR) << "Failed to open in-memory LevelDB database: " << s.ToString();
	return scoped_ptr<LevelDBDatabase>();
	}

	scoped_ptr<LevelDBDatabase> result(new LevelDBDatabase);
	result->env_ = in_memory_env.Pass();
	result->db_ = make_scoped_ptr(db);
	result->comparator_adapter_ = comparator_adapter.Pass();
	result->comparator_ = comparator;

	return result.Pass();
	}

	bool LevelDBDatabase::Put(const StringPiece& key, std::string* value) {
	leveldb::WriteOptions write_options;
	write_options.sync = kSyncWrites;

	const leveldb::Status s =
	db_->Put(write_options, MakeSlice(key), MakeSlice(*value));
	if (s.ok())
	return true;
	LOG(ERROR) << "LevelDB put failed: " << s.ToString();
	return false;
	}

	bool LevelDBDatabase::Remove(const StringPiece& key) {
	leveldb::WriteOptions write_options;
	write_options.sync = kSyncWrites;

	const leveldb::Status s = db_->Delete(write_options, MakeSlice(key));
	if (s.ok())
	return true;
	if (s.IsNotFound())
	return false;
	LOG(ERROR) << "LevelDB remove failed: " << s.ToString();
	return false;
	}

	bool LevelDBDatabase::Get(const StringPiece& key,
	std::string* value,
	bool* found,
	const LevelDBSnapshot* snapshot) {
	*found = false;
	leveldb::ReadOptions read_options;
	read_options.verify_checksums = true; // TODO(jsbell): Disable this if the
	// performance impact is too great.
	read_options.snapshot = snapshot ? snapshot->snapshot_ : 0;

	const leveldb::Status s = db_->Get(read_options, MakeSlice(key), value);
	if (s.ok()) {
	*found = true;
	return true;
	}
	if (s.IsNotFound())
	return true;
	HistogramLevelDBError("WebCore.IndexedDB.LevelDBReadErrors", s);
	LOG(ERROR) << "LevelDB get failed: " << s.ToString();
	return false;
	}

	bool LevelDBDatabase::Write(const LevelDBWriteBatch& write_batch) {
	leveldb::WriteOptions write_options;
	write_options.sync = kSyncWrites;

	const leveldb::Status s =
	db_->Write(write_options, write_batch.write_batch_.get());
	if (s.ok())
	return true;
	HistogramLevelDBError("WebCore.IndexedDB.LevelDBWriteErrors", s);
	LOG(ERROR) << "LevelDB write failed: " << s.ToString();
	return false;
	}

	namespace {
	class IteratorImpl : public LevelDBIterator {
	public:
	virtual ~IteratorImpl() {}

	virtual bool IsValid() const OVERRIDE;
	virtual void SeekToLast() OVERRIDE;
	virtual void Seek(const StringPiece& target) OVERRIDE;
	virtual void Next() OVERRIDE;
	virtual void Prev() OVERRIDE;
	virtual StringPiece Key() const OVERRIDE;
	virtual StringPiece Value() const OVERRIDE;

	private:
	friend class content::LevelDBDatabase;
	explicit IteratorImpl(scoped_ptr<leveldb::Iterator> iterator);
	void CheckStatus();

	scoped_ptr<leveldb::Iterator> iterator_;
	};
	}

	IteratorImpl::IteratorImpl(scoped_ptr<leveldb::Iterator> it)
	: iterator_(it.Pass()) {}

	void IteratorImpl::CheckStatus() {
	const leveldb::Status s = iterator_->status();
	if (!s.ok())
	LOG(ERROR) << "LevelDB iterator error: " << s.ToString();
	}

	bool IteratorImpl::IsValid() const { return iterator_->Valid(); }

	void IteratorImpl::SeekToLast() {
	iterator_->SeekToLast();
	CheckStatus();
	}

	void IteratorImpl::Seek(const StringPiece& target) {
	iterator_->Seek(MakeSlice(target));
	CheckStatus();
	}

	void IteratorImpl::Next() {
	DCHECK(IsValid());
	iterator_->Next();
	CheckStatus();
	}

	void IteratorImpl::Prev() {
	DCHECK(IsValid());
	iterator_->Prev();
	CheckStatus();
	}

	StringPiece IteratorImpl::Key() const {
	DCHECK(IsValid());
	return MakeStringPiece(iterator_->key());
	}

	StringPiece IteratorImpl::Value() const {
	DCHECK(IsValid());
	return MakeStringPiece(iterator_->value());
	}

	scoped_ptr<LevelDBIterator> LevelDBDatabase::CreateIterator(
	const LevelDBSnapshot* snapshot) {
	leveldb::ReadOptions read_options;
	read_options.verify_checksums = true; // TODO(jsbell): Disable this if the
	// performance impact is too great.
	read_options.snapshot = snapshot ? snapshot->snapshot_ : 0;

	scoped_ptr<leveldb::Iterator> i(db_->NewIterator(read_options));
	return scoped_ptr<LevelDBIterator>(new IteratorImpl(i.Pass()));
	}

	const LevelDBComparator* LevelDBDatabase::Comparator() const {
	return comparator_;
	}

	} // namespace content