[FileAPI] Replace default leveldb::Env with leveldb::MemEnv in tests.

chrome/browser/sync_file_system/local/local_file_sync_context_unittest.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 "chrome/browser/sync_file_system/local/local_file_sync_context.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/message_loop/message_loop.h"
 #include "base/platform_file.h"
 #include "base/stl_util.h"
 #include "chrome/browser/sync_file_system/local/canned_syncable_file_system.h"
 #include "chrome/browser/sync_file_system/local/local_file_change_tracker.h"
 #include "chrome/browser/sync_file_system/local/sync_file_system_backend.h"
 #include "chrome/browser/sync_file_system/sync_file_metadata.h"
 #include "chrome/browser/sync_file_system/sync_status_code.h"
 #include "chrome/browser/sync_file_system/syncable_file_system_util.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/test/mock_blob_url_request_context.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/leveldatabase/src/helpers/memenv/memenv.h"
+#include "third_party/leveldatabase/src/include/leveldb/env.h"
 #include "webkit/browser/fileapi/file_system_context.h"
 #include "webkit/browser/fileapi/file_system_operation_runner.h"
 #include "webkit/browser/fileapi/isolated_context.h"
 #include "webkit/common/blob/scoped_file.h"
 
 #define FPL FILE_PATH_LITERAL
 
 using content::BrowserThread;
 using fileapi::FileSystemContext;
 using fileapi::FileSystemURL;
@@ skipping 19 matching lines @@
             content::TestBrowserThreadBundle::REAL_FILE_THREAD |
             content::TestBrowserThreadBundle::REAL_IO_THREAD),
         status_(SYNC_FILE_ERROR_FAILED),
         file_error_(base::File::FILE_ERROR_FAILED),
         async_modify_finished_(false),
         has_inflight_prepare_for_sync_(false) {}
 
   virtual void SetUp() OVERRIDE {
     RegisterSyncableFileSystem();
     ASSERT_TRUE(dir_.CreateUniqueTempDir());
+    in_memory_env_.reset(leveldb::NewMemEnv(leveldb::Env::Default()));
 
     ui_task_runner_ = base::MessageLoop::current()->message_loop_proxy();
     io_task_runner_ = BrowserThread::GetMessageLoopProxyForThread(
         BrowserThread::IO);
     file_task_runner_ = BrowserThread::GetMessageLoopProxyForThread(
         BrowserThread::IO);
   }
 
   virtual void TearDown() OVERRIDE {
     RevokeSyncableFileSystem();
@@ skipping 146 matching lines @@
       sync_context_->FinalizeExclusiveSync(
           file_system_context, url,
           status == SYNC_STATUS_OK /* clear_local_changes */,
           base::Bind(&base::DoNothing));
     }
   }
 
   void PrepareForSync_Basic(LocalFileSyncContext::SyncMode sync_mode,
                             SyncStatusCode simulate_sync_finish_status) {
     CannedSyncableFileSystem file_system(GURL(kOrigin1),
+                                         in_memory_env_.get(),
                                          io_task_runner_.get(),
                                          file_task_runner_.get());
     file_system.SetUp();
     sync_context_ = new LocalFileSyncContext(
-        dir_.path(), ui_task_runner_.get(), io_task_runner_.get());
+        dir_.path(), in_memory_env_.get(),
+        ui_task_runner_.get(), io_task_runner_.get());
     ASSERT_EQ(SYNC_STATUS_OK,
               file_system.MaybeInitializeFileSystemContext(
                   sync_context_.get()));
     ASSERT_EQ(base::File::FILE_OK, file_system.OpenFileSystem());
 
     const FileSystemURL kFile(file_system.URL("file"));
     EXPECT_EQ(base::File::FILE_OK, file_system.CreateFile(kFile));
 
     SyncFileMetadata metadata;
     FileChangeList changes;
@@ skipping 25 matching lines @@
 
     sync_context_->ShutdownOnUIThread();
     sync_context_ = NULL;
 
     file_system.TearDown();
   }
 
   void PrepareForSync_WriteDuringSync(
       LocalFileSyncContext::SyncMode sync_mode) {
     CannedSyncableFileSystem file_system(GURL(kOrigin1),
+                                         in_memory_env_.get(),
                                          io_task_runner_.get(),
                                          file_task_runner_.get());
     file_system.SetUp();
     sync_context_ = new LocalFileSyncContext(
-        dir_.path(), ui_task_runner_.get(), io_task_runner_.get());
+        dir_.path(), in_memory_env_.get(),
+        ui_task_runner_.get(), io_task_runner_.get());
     ASSERT_EQ(SYNC_STATUS_OK,
               file_system.MaybeInitializeFileSystemContext(
                   sync_context_.get()));
     ASSERT_EQ(base::File::FILE_OK, file_system.OpenFileSystem());
 
     const FileSystemURL kFile(file_system.URL("file"));
     EXPECT_EQ(base::File::FILE_OK, file_system.CreateFile(kFile));
 
     SyncFileMetadata metadata;
     FileChangeList changes;
@@ skipping 38 matching lines @@
 
     sync_context_->ShutdownOnUIThread();
     sync_context_ = NULL;
 
     file_system.TearDown();
   }
 
   ScopedEnableSyncFSDirectoryOperation enable_directory_operation_;
 
   base::ScopedTempDir dir_;
+  scoped_ptr<leveldb::Env> in_memory_env_;
 
   // These need to remain until the very end.
   content::TestBrowserThreadBundle thread_bundle_;
 
   scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> file_task_runner_;
 
   scoped_refptr<LocalFileSyncContext> sync_context_;
 
   SyncStatusCode status_;
   base::File::Error file_error_;
   bool async_modify_finished_;
   bool has_inflight_prepare_for_sync_;
 };
 
 TEST_F(LocalFileSyncContextTest, ConstructAndDestruct) {
   sync_context_ =
       new LocalFileSyncContext(
-          dir_.path(), ui_task_runner_.get(), io_task_runner_.get());
+          dir_.path(), in_memory_env_.get(),
+          ui_task_runner_.get(), io_task_runner_.get());
   sync_context_->ShutdownOnUIThread();
 }
 
 TEST_F(LocalFileSyncContextTest, InitializeFileSystemContext) {
   CannedSyncableFileSystem file_system(GURL(kOrigin1),
+                                       in_memory_env_.get(),
                                        io_task_runner_.get(),
                                        file_task_runner_.get());
   file_system.SetUp();
 
   sync_context_ = new LocalFileSyncContext(
-      dir_.path(), ui_task_runner_.get(), io_task_runner_.get());
+      dir_.path(), in_memory_env_.get(),
+      ui_task_runner_.get(), io_task_runner_.get());
 
   // Initializes file_system using |sync_context_|.
   EXPECT_EQ(SYNC_STATUS_OK,
             file_system.MaybeInitializeFileSystemContext(sync_context_.get()));
 
   // Make sure everything's set up for file_system to be able to handle
   // syncable file system operations.
   EXPECT_TRUE(file_system.backend()->sync_context() != NULL);
   EXPECT_TRUE(file_system.backend()->change_tracker() != NULL);
   EXPECT_EQ(sync_context_.get(), file_system.backend()->sync_context());
@@ skipping 15 matching lines @@
   ASSERT_EQ(1U, urls.size());
   EXPECT_TRUE(ContainsKey(urls, kURL));
 
   // Finishing the test.
   sync_context_->ShutdownOnUIThread();
   file_system.TearDown();
 }
 
 TEST_F(LocalFileSyncContextTest, MultipleFileSystemContexts) {
   CannedSyncableFileSystem file_system1(GURL(kOrigin1),
+                                        in_memory_env_.get(),
                                         io_task_runner_.get(),
                                         file_task_runner_.get());
   CannedSyncableFileSystem file_system2(GURL(kOrigin2),
+                                        in_memory_env_.get(),
                                         io_task_runner_.get(),
                                         file_task_runner_.get());
   file_system1.SetUp();
   file_system2.SetUp();
 
   sync_context_ = new LocalFileSyncContext(
-      dir_.path(), ui_task_runner_.get(), io_task_runner_.get());
+      dir_.path(), in_memory_env_.get(),
+      ui_task_runner_.get(), io_task_runner_.get());
 
   // Initializes file_system1 and file_system2.
   EXPECT_EQ(SYNC_STATUS_OK,
             file_system1.MaybeInitializeFileSystemContext(sync_context_.get()));
   EXPECT_EQ(SYNC_STATUS_OK,
             file_system2.MaybeInitializeFileSystemContext(sync_context_.get()));
 
   EXPECT_EQ(base::File::FILE_OK, file_system1.OpenFileSystem());
   EXPECT_EQ(base::File::FILE_OK, file_system2.OpenFileSystem());
 
@@ skipping 86 matching lines @@
 TEST_F(LocalFileSyncContextTest, PrepareSync_WriteDuringSync_Snapshot) {
   PrepareForSync_WriteDuringSync(LocalFileSyncContext::SYNC_SNAPSHOT);
 }
 
 // LocalFileSyncContextTest.PrepareSyncWhileWriting is flaky on android.
 // http://crbug.com/239793
 // It is also flaky on the TSAN v2 bots, and hangs other bots.
 // http://crbug.com/305905.
 TEST_F(LocalFileSyncContextTest, DISABLED_PrepareSyncWhileWriting) {
   CannedSyncableFileSystem file_system(GURL(kOrigin1),
+                                       in_memory_env_.get(),
                                        io_task_runner_.get(),
                                        file_task_runner_.get());
   file_system.SetUp();
   sync_context_ = new LocalFileSyncContext(
-      dir_.path(), ui_task_runner_.get(), io_task_runner_.get());
+      dir_.path(), in_memory_env_.get(),
+      ui_task_runner_.get(), io_task_runner_.get());
   EXPECT_EQ(SYNC_STATUS_OK,
             file_system.MaybeInitializeFileSystemContext(sync_context_.get()));
 
   EXPECT_EQ(base::File::FILE_OK, file_system.OpenFileSystem());
 
   const FileSystemURL kURL1(file_system.URL("foo"));
 
   // Creates a file in file_system.
   EXPECT_EQ(base::File::FILE_OK, file_system.CreateFile(kURL1));
 
@@ skipping 36 matching lines @@
   EXPECT_EQ(SYNC_FILE_TYPE_FILE, metadata.file_type);
   EXPECT_EQ(1, metadata.size);
 
   sync_context_->ShutdownOnUIThread();
   sync_context_ = NULL;
   file_system.TearDown();
 }
 
 TEST_F(LocalFileSyncContextTest, ApplyRemoteChangeForDeletion) {
   CannedSyncableFileSystem file_system(GURL(kOrigin1),
+                                       in_memory_env_.get(),
                                        io_task_runner_.get(),
                                        file_task_runner_.get());
   file_system.SetUp();
 
   sync_context_ = new LocalFileSyncContext(
-      dir_.path(), ui_task_runner_.get(), io_task_runner_.get());
+      dir_.path(), in_memory_env_.get(),
+      ui_task_runner_.get(), io_task_runner_.get());
   ASSERT_EQ(SYNC_STATUS_OK,
             file_system.MaybeInitializeFileSystemContext(sync_context_.get()));
   ASSERT_EQ(base::File::FILE_OK, file_system.OpenFileSystem());
 
   // Record the initial usage (likely 0).
   int64 initial_usage = -1;
   int64 quota = -1;
   EXPECT_EQ(quota::kQuotaStatusOk,
             file_system.GetUsageAndQuota(&initial_usage, &quota));
 
@@ skipping 60 matching lines @@
             file_system.GetUsageAndQuota(&new_usage, &quota));
   EXPECT_EQ(new_usage, initial_usage);
 
   sync_context_->ShutdownOnUIThread();
   sync_context_ = NULL;
   file_system.TearDown();
 }
 
 TEST_F(LocalFileSyncContextTest, ApplyRemoteChangeForDeletion_ForRoot) {
   CannedSyncableFileSystem file_system(GURL(kOrigin1),
+                                       in_memory_env_.get(),
                                        io_task_runner_.get(),
                                        file_task_runner_.get());
   file_system.SetUp();
 
   sync_context_ = new LocalFileSyncContext(
-      dir_.path(), ui_task_runner_.get(), io_task_runner_.get());
+      dir_.path(), in_memory_env_.get(),
+      ui_task_runner_.get(), io_task_runner_.get());
   ASSERT_EQ(SYNC_STATUS_OK,
             file_system.MaybeInitializeFileSystemContext(sync_context_.get()));
   ASSERT_EQ(base::File::FILE_OK, file_system.OpenFileSystem());
 
   // Record the initial usage (likely 0).
   int64 initial_usage = -1;
   int64 quota = -1;
   EXPECT_EQ(quota::kQuotaStatusOk,
             file_system.GetUsageAndQuota(&initial_usage, &quota));
 
@@ skipping 42 matching lines @@
   sync_context_->ShutdownOnUIThread();
   sync_context_ = NULL;
   file_system.TearDown();
 }
 
 TEST_F(LocalFileSyncContextTest, ApplyRemoteChangeForAddOrUpdate) {
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 
   CannedSyncableFileSystem file_system(GURL(kOrigin1),
+                                       in_memory_env_.get(),
                                        io_task_runner_.get(),
                                        file_task_runner_.get());
   file_system.SetUp();
 
   sync_context_ = new LocalFileSyncContext(
-      dir_.path(), ui_task_runner_.get(), io_task_runner_.get());
+      dir_.path(), in_memory_env_.get(),
+      ui_task_runner_.get(), io_task_runner_.get());
   ASSERT_EQ(SYNC_STATUS_OK,
             file_system.MaybeInitializeFileSystemContext(sync_context_.get()));
   ASSERT_EQ(base::File::FILE_OK, file_system.OpenFileSystem());
 
   const FileSystemURL kFile1(file_system.URL("file1"));
   const FileSystemURL kFile2(file_system.URL("file2"));
   const FileSystemURL kDir(file_system.URL("dir"));
 
   const char kTestFileData0[] = "0123456789";
   const char kTestFileData1[] = "Lorem ipsum!";
@@ skipping 123 matching lines @@
 
   sync_context_->ShutdownOnUIThread();
   file_system.TearDown();
 }
 
 TEST_F(LocalFileSyncContextTest, ApplyRemoteChangeForAddOrUpdate_NoParent) {
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 
   CannedSyncableFileSystem file_system(GURL(kOrigin1),
+                                       in_memory_env_.get(),
                                        io_task_runner_.get(),
                                        file_task_runner_.get());
   file_system.SetUp();
 
   sync_context_ = new LocalFileSyncContext(
-      dir_.path(), ui_task_runner_.get(), io_task_runner_.get());
+      dir_.path(), in_memory_env_.get(),
+      ui_task_runner_.get(), io_task_runner_.get());
   ASSERT_EQ(SYNC_STATUS_OK,
             file_system.MaybeInitializeFileSystemContext(sync_context_.get()));
   ASSERT_EQ(base::File::FILE_OK, file_system.OpenFileSystem());
 
   const char kTestFileData[] = "Lorem ipsum!";
   const FileSystemURL kDir(file_system.URL("dir"));
   const FileSystemURL kFile(file_system.URL("dir/file"));
 
   // Either kDir or kFile not exist yet.
   EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, file_system.FileExists(kDir));
@@ skipping 23 matching lines @@
 
   // Make sure kDir and kFile are created by ApplyRemoteChange.
   EXPECT_EQ(base::File::FILE_OK, file_system.FileExists(kFile));
   EXPECT_EQ(base::File::FILE_OK, file_system.DirectoryExists(kDir));
 
   sync_context_->ShutdownOnUIThread();
   file_system.TearDown();
 }
 
 }  // namespace sync_file_system