Merge 144323

Source/WebCore/Modules/indexeddb/IDBBackingStore.cpp

 /*
  * Copyright (C) 2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 305 matching lines @@
     bool ok = getInt(db, maxObjectStoreIdKey, maxObjectStoreId, found);
     if (!ok)
         return false;
     if (!found)
         maxObjectStoreId = 0;
 
     ASSERT(maxObjectStoreId >= 0);
     return true;
 }
 
+class DefaultLevelDBFactory : public LevelDBFactory {
+public:
+    virtual PassOwnPtr<LevelDBDatabase> openLevelDB(const String& fileName, const LevelDBComparator* comparator)
+    {
+        return LevelDBDatabase::open(fileName, comparator);
+    }
+    virtual bool destroyLevelDB(const String& fileName)
+    {
+        return LevelDBDatabase::destroy(fileName);
+    }
+};
+
 IDBBackingStore::IDBBackingStore(const String& identifier, IDBFactoryBackendImpl* factory, PassOwnPtr<LevelDBDatabase> db)
     : m_identifier(identifier)
     , m_factory(factory)
     , m_db(db)
 {
     m_factory->addIDBBackingStore(identifier, this);
 }
 
 IDBBackingStore::IDBBackingStore()
 {
@@ skipping 17 matching lines @@
     IDBLevelDBBackingStoreOpenFailedUnknownSchema,
     IDBLevelDBBackingStoreOpenCleanupDestroyFailed,
     IDBLevelDBBackingStoreOpenCleanupReopenFailed,
     IDBLevelDBBackingStoreOpenCleanupReopenSuccess,
     IDBLevelDBBackingStoreOpenFailedIOErrCheckingSchema,
     IDBLevelDBBackingStoreOpenMax,
 };
 
 PassRefPtr<IDBBackingStore> IDBBackingStore::open(SecurityOrigin* securityOrigin, const String& pathBaseArg, const String& fileIdentifier, IDBFactoryBackendImpl* factory)
 {
+    DefaultLevelDBFactory levelDBFactory;
+    return IDBBackingStore::open(securityOrigin, pathBaseArg, fileIdentifier, factory, &levelDBFactory);
+}
+
+PassRefPtr<IDBBackingStore> IDBBackingStore::open(SecurityOrigin* securityOrigin, const String& pathBaseArg, const String& fileIdentifier, IDBFactoryBackendImpl* factory, LevelDBFactory* levelDBFactory)
+{
     IDB_TRACE("IDBBackingStore::open");
     String pathBase = pathBaseArg;
 
     OwnPtr<LevelDBComparator> comparator = adoptPtr(new Comparator());
     OwnPtr<LevelDBDatabase> db;
 
     if (pathBase.isEmpty()) {
         HistogramSupport::histogramEnumeration("WebCore.IndexedDB.BackingStore.OpenStatus", IDBLevelDBBackingStoreOpenMemory, IDBLevelDBBackingStoreOpenMax);
         db = LevelDBDatabase::openInMemory(comparator.get());
     } else {
         if (!makeAllDirectories(pathBase)) {
             LOG_ERROR("Unable to create IndexedDB database path %s", pathBase.utf8().data());
             HistogramSupport::histogramEnumeration("WebCore.IndexedDB.BackingStore.OpenStatus", IDBLevelDBBackingStoreOpenFailedDirectory, IDBLevelDBBackingStoreOpenMax);
             return PassRefPtr<IDBBackingStore>();
         }
 
         String path = pathByAppendingComponent(pathBase, securityOrigin->databaseIdentifier() + ".indexeddb.leveldb");
 
-        db = LevelDBDatabase::open(path, comparator.get());
+        db = levelDBFactory->openLevelDB(path, comparator.get());
         if (db) {
             bool known = false;
             bool ok = isSchemaKnown(db.get(), known);
             if (!ok) {
+                LOG_ERROR("IndexedDB had IO error checking schema, treating it as failure to open");
                 HistogramSupport::histogramEnumeration("WebCore.IndexedDB.BackingStore.OpenStatus", IDBLevelDBBackingStoreOpenFailedIOErrCheckingSchema, IDBLevelDBBackingStoreOpenMax);
-                return PassRefPtr<IDBBackingStore>();
-            }
-            if (!known) {
+                db.clear();
+            } else if (!known) {
                 LOG_ERROR("IndexedDB backing store had unknown schema, treating it as failure to open");
                 HistogramSupport::histogramEnumeration("WebCore.IndexedDB.BackingStore.OpenStatus", IDBLevelDBBackingStoreOpenFailedUnknownSchema, IDBLevelDBBackingStoreOpenMax);
                 db.clear();
             }
         }
 
         if (db)
             HistogramSupport::histogramEnumeration("WebCore.IndexedDB.BackingStore.OpenStatus", IDBLevelDBBackingStoreOpenSuccess, IDBLevelDBBackingStoreOpenMax);
         else {
             LOG_ERROR("IndexedDB backing store open failed, attempting cleanup");
-            bool success = LevelDBDatabase::destroy(path);
+            bool success = levelDBFactory->destroyLevelDB(path);
             if (!success) {
                 LOG_ERROR("IndexedDB backing store cleanup failed");
                 HistogramSupport::histogramEnumeration("WebCore.IndexedDB.BackingStore.OpenStatus", IDBLevelDBBackingStoreOpenCleanupDestroyFailed, IDBLevelDBBackingStoreOpenMax);
                 return PassRefPtr<IDBBackingStore>();
             }
 
             LOG_ERROR("IndexedDB backing store cleanup succeeded, reopening");
-            db = LevelDBDatabase::open(path, comparator.get());
+            db = levelDBFactory->openLevelDB(path, comparator.get());
             if (!db) {
                 LOG_ERROR("IndexedDB backing store reopen after recovery failed");
                 HistogramSupport::histogramEnumeration("WebCore.IndexedDB.BackingStore.OpenStatus", IDBLevelDBBackingStoreOpenCleanupReopenFailed, IDBLevelDBBackingStoreOpenMax);
                 return PassRefPtr<IDBBackingStore>();
             }
             HistogramSupport::histogramEnumeration("WebCore.IndexedDB.BackingStore.OpenStatus", IDBLevelDBBackingStoreOpenCleanupReopenSuccess, IDBLevelDBBackingStoreOpenMax);
         }
     }
 
     if (!db)
@@ skipping 1439 matching lines @@
 {
     IDB_TRACE("IDBBackingStore::Transaction::rollback");
     ASSERT(m_transaction);
     m_transaction->rollback();
     m_transaction.clear();
 }
 
 } // namespace WebCore
 
 #endif // ENABLE(INDEXED_DATABASE)