Cleanup IndexedDBIO unit tests using GoogleMock.

content/browser/indexed_db/indexed_db_cleanup_on_io_error_unittest.cc

Index: content/browser/indexed_db/indexed_db_cleanup_on_io_error_unittest.cc
diff --git a/content/browser/indexed_db/indexed_db_cleanup_on_io_error_unittest.cc b/content/browser/indexed_db/indexed_db_cleanup_on_io_error_unittest.cc
index 2bcd428c60e3d7c902b5968263d4bc1162c87f87..953d4b4c767c97e7fa88cf8ce21826a6dc65dc8b 100644
--- a/content/browser/indexed_db/indexed_db_cleanup_on_io_error_unittest.cc
+++ b/content/browser/indexed_db/indexed_db_cleanup_on_io_error_unittest.cc
@@ -11,6 +11,8 @@
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/indexed_db/indexed_db_backing_store.h"
 #include "content/browser/indexed_db/leveldb/leveldb_database.h"
+#include "content/browser/indexed_db/leveldb/mock_leveldb_factory.h"
+#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/leveldatabase/env_chromium.h"
 
@@ -20,6 +22,9 @@ using content::LevelDBComparator;
 using content::LevelDBDatabase;
 using content::LevelDBFactory;
 using content::LevelDBSnapshot;
+using testing::_;
+using testing::Exactly;
+using testing::Invoke;
 
 namespace base {
 class TaskRunner;
@@ -54,30 +59,27 @@ class BustedLevelDBDatabase : public LevelDBDatabase {
   DISALLOW_COPY_AND_ASSIGN(BustedLevelDBDatabase);
 };
 
-class MockLevelDBFactory : public LevelDBFactory {
+class BustedLevelDBFactory : public LevelDBFactory {
  public:
-  MockLevelDBFactory() : destroy_called_(false) {}
   virtual leveldb::Status OpenLevelDB(
       const base::FilePath& file_name,
       const LevelDBComparator* comparator,
       scoped_ptr<LevelDBDatabase>* db,
       bool* is_disk_full = 0) OVERRIDE {
-    *db = BustedLevelDBDatabase::Open(file_name, comparator);
-    return leveldb::Status::OK();
+    if (open_error_.ok())
+      *db = BustedLevelDBDatabase::Open(file_name, comparator);
+    return open_error_;
   }
-  virtual leveldb::Status DestroyLevelDB(const base::FilePath& file_name)
-      OVERRIDE {
-    EXPECT_FALSE(destroy_called_);
-    destroy_called_ = true;
+  virtual leveldb::Status DestroyLevelDB(
+      const base::FilePath& file_name) OVERRIDE {
     return leveldb::Status::IOError("error");
   }
-  virtual ~MockLevelDBFactory() { EXPECT_TRUE(destroy_called_); }
-
- private:
-  bool destroy_called_;
+  void SetOpenError(const leveldb::Status& open_error) {
+    open_error_ = open_error;
+  }
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(MockLevelDBFactory);
+  leveldb::Status open_error_;
 };
 
 TEST(IndexedDBIOErrorTest, CleanUpTest) {
@@ -87,9 +89,17 @@ TEST(IndexedDBIOErrorTest, CleanUpTest) {
   ASSERT_TRUE(temp_directory.CreateUniqueTempDir());
   const base::FilePath path = temp_directory.path();
   net::URLRequestContext* request_context = NULL;
-  MockLevelDBFactory mock_leveldb_factory;
-  blink::WebIDBDataLoss data_loss =
-      blink::WebIDBDataLossNone;
+
+  BustedLevelDBFactory busted_factory;
+  content::MockLevelDBFactory mock_leveldb_factory;
+  ON_CALL(mock_leveldb_factory, OpenLevelDB(_, _, _, _)).WillByDefault(
+      Invoke(&busted_factory, &BustedLevelDBFactory::OpenLevelDB));
+  ON_CALL(mock_leveldb_factory, DestroyLevelDB(_)).WillByDefault(
+      Invoke(&busted_factory, &BustedLevelDBFactory::DestroyLevelDB));
+
+  EXPECT_CALL(mock_leveldb_factory, OpenLevelDB(_, _, _, _)).Times(Exactly(1));
+  EXPECT_CALL(mock_leveldb_factory, DestroyLevelDB(_)).Times(Exactly(1));
+  blink::WebIDBDataLoss data_loss = blink::WebIDBDataLossNone;
   std::string data_loss_message;
   bool disk_full = false;
   base::TaskRunner* task_runner = NULL;
@@ -109,41 +119,6 @@ TEST(IndexedDBIOErrorTest, CleanUpTest) {
                                   &s);
 }
 
-// TODO(dgrogan): Remove expect_destroy if we end up not using it again. It is
-// currently set to false in all 4 calls below.
-template <class T>
-class MockErrorLevelDBFactory : public LevelDBFactory {
- public:
-  MockErrorLevelDBFactory(T error, bool expect_destroy)
-      : error_(error),
-        expect_destroy_(expect_destroy),
-        destroy_called_(false) {}
-  virtual leveldb::Status OpenLevelDB(
-      const base::FilePath& file_name,
-      const LevelDBComparator* comparator,
-      scoped_ptr<LevelDBDatabase>* db,
-      bool* is_disk_full = 0) OVERRIDE {
-    return MakeIOError(
-        "some filename", "some message", leveldb_env::kNewLogger, error_);
-  }
-  virtual leveldb::Status DestroyLevelDB(const base::FilePath& file_name)
-      OVERRIDE {
-    EXPECT_FALSE(destroy_called_);
-    destroy_called_ = true;
-    return leveldb::Status::IOError("error");
-  }
-  virtual ~MockErrorLevelDBFactory() {
-    EXPECT_EQ(expect_destroy_, destroy_called_);
-  }
-
- private:
-  T error_;
-  bool expect_destroy_;
-  bool destroy_called_;
-
-  DISALLOW_COPY_AND_ASSIGN(MockErrorLevelDBFactory);
-};
-
 TEST(IndexedDBNonRecoverableIOErrorTest, NuancedCleanupTest) {
   content::IndexedDBFactory* factory = NULL;
   const GURL origin("http://localhost:81");
@@ -159,7 +134,18 @@ TEST(IndexedDBNonRecoverableIOErrorTest, NuancedCleanupTest) {
   bool clean_journal = false;
   leveldb::Status s;
 
-  MockErrorLevelDBFactory<int> mock_leveldb_factory(ENOSPC, false);
+  BustedLevelDBFactory busted_factory;
+  content::MockLevelDBFactory mock_leveldb_factory;
+  ON_CALL(mock_leveldb_factory, OpenLevelDB(_, _, _, _)).WillByDefault(
+      Invoke(&busted_factory, &BustedLevelDBFactory::OpenLevelDB));
+  ON_CALL(mock_leveldb_factory, DestroyLevelDB(_)).WillByDefault(
+      Invoke(&busted_factory, &BustedLevelDBFactory::DestroyLevelDB));
+
+  EXPECT_CALL(mock_leveldb_factory, OpenLevelDB(_, _, _, _)).Times(Exactly(4));
+  EXPECT_CALL(mock_leveldb_factory, DestroyLevelDB(_)).Times(Exactly(0));
+
+  busted_factory.SetOpenError(MakeIOError(
+      "some filename", "some message", leveldb_env::kNewLogger, ENOSPC));
   scoped_refptr<IndexedDBBackingStore> backing_store =
       IndexedDBBackingStore::Open(factory,
                                   origin,
@@ -174,8 +160,10 @@ TEST(IndexedDBNonRecoverableIOErrorTest, NuancedCleanupTest) {
                                   &s);
   ASSERT_TRUE(s.IsIOError());
 
-  MockErrorLevelDBFactory<base::File::Error> mock_leveldb_factory2(
-      base::File::FILE_ERROR_NO_MEMORY, false);
+  busted_factory.SetOpenError(MakeIOError("some filename",
+                                          "some message",
+                                          leveldb_env::kNewLogger,
+                                          base::File::FILE_ERROR_NO_MEMORY));
   scoped_refptr<IndexedDBBackingStore> backing_store2 =
       IndexedDBBackingStore::Open(factory,
                                   origin,
@@ -184,13 +172,14 @@ TEST(IndexedDBNonRecoverableIOErrorTest, NuancedCleanupTest) {
                                   &data_loss,
                                   &data_loss_reason,
                                   &disk_full,
-                                  &mock_leveldb_factory2,
+                                  &mock_leveldb_factory,
                                   task_runner,
                                   clean_journal,
                                   &s);
   ASSERT_TRUE(s.IsIOError());
 
-  MockErrorLevelDBFactory<int> mock_leveldb_factory3(EIO, false);
+  busted_factory.SetOpenError(MakeIOError(
+      "some filename", "some message", leveldb_env::kNewLogger, EIO));
   scoped_refptr<IndexedDBBackingStore> backing_store3 =
       IndexedDBBackingStore::Open(factory,
                                   origin,
@@ -199,14 +188,16 @@ TEST(IndexedDBNonRecoverableIOErrorTest, NuancedCleanupTest) {
                                   &data_loss,
                                   &data_loss_reason,
                                   &disk_full,
-                                  &mock_leveldb_factory3,
+                                  &mock_leveldb_factory,
                                   task_runner,
                                   clean_journal,
                                   &s);
   ASSERT_TRUE(s.IsIOError());
 
-  MockErrorLevelDBFactory<base::File::Error> mock_leveldb_factory4(
-      base::File::FILE_ERROR_FAILED, false);
+  busted_factory.SetOpenError(MakeIOError("some filename",
+                                          "some message",
+                                          leveldb_env::kNewLogger,
+                                          base::File::FILE_ERROR_FAILED));
   scoped_refptr<IndexedDBBackingStore> backing_store4 =
       IndexedDBBackingStore::Open(factory,
                                   origin,
@@ -215,7 +206,7 @@ TEST(IndexedDBNonRecoverableIOErrorTest, NuancedCleanupTest) {
                                   &data_loss,
                                   &data_loss_reason,
                                   &disk_full,
-                                  &mock_leveldb_factory4,
+                                  &mock_leveldb_factory,
                                   task_runner,
                                   clean_journal,
                                   &s);