Don't delete leveldb directory if disk was full.

content/browser/indexed_db/leveldb/leveldb_database.cc

 // 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 <string>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
@@ skipping 91 matching lines @@
 
 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();
 }
 
-static void HistogramFreeSpace(const char* type,
-                               const base::FilePath& file_name) {
+static int CheckFreeSpace(const char* type, const base::FilePath& file_name) {
+  // TODO(dgrogan): Change string16 -> std::string.
   string16 name = ASCIIToUTF16("WebCore.IndexedDB.LevelDB.Open") +
                   ASCIIToUTF16(type) + ASCIIToUTF16("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;
+    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(UTF16ToUTF8(name),
                               1,
                               histogram_max,
                               11 /*buckets*/,
                               base::HistogramBase::kUmaTargetedHistogramFlag)
       ->Add(clamped_disk_space_k_bytes);
+  return clamped_disk_space_k_bytes;
 }
 
 static void HistogramLevelDBError(const char* histogram_name,
                                   const leveldb::Status& s) {
   DCHECK(!s.ok());
   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);
 }
 
 scoped_ptr<LevelDBDatabase> LevelDBDatabase::Open(
     const base::FilePath& file_name,
-    const LevelDBComparator* comparator) {
+    const LevelDBComparator* comparator,
+    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);
-    HistogramFreeSpace("Failure", file_name);
+    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 scoped_ptr<LevelDBDatabase>();
   }
 
-  HistogramFreeSpace("Success", file_name);
+  CheckFreeSpace("Success", file_name);
 
   scoped_ptr<LevelDBDatabase> result(new LevelDBDatabase);
   result->db_ = make_scoped_ptr(db);
   result->comparator_adapter_ = comparator_adapter.Pass();
   result->comparator_ = comparator;
 
   return result.Pass();
 }
 
 scoped_ptr<LevelDBDatabase> LevelDBDatabase::OpenInMemory(
@@ skipping 155 matching lines @@
   if (!i)  // TODO(jsbell): Double check if we actually need to check this.
     return scoped_ptr<LevelDBIterator>();
   return scoped_ptr<LevelDBIterator>(new IteratorImpl(i.Pass()));
 }
 
 const LevelDBComparator* LevelDBDatabase::Comparator() const {
   return comparator_;
 }
 
 }  // namespace content