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

chrome/browser/sync_file_system/local/local_file_change_tracker.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_change_tracker.h"
 
 #include <queue>
 
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/sequenced_task_runner.h"
 #include "base/stl_util.h"
 #include "chrome/browser/sync_file_system/local/local_file_sync_status.h"
 #include "chrome/browser/sync_file_system/syncable_file_system_util.h"
+#include "third_party/leveldatabase/src/helpers/memenv/memenv.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/write_batch.h"
 #include "webkit/browser/fileapi/file_system_context.h"
 #include "webkit/browser/fileapi/file_system_file_util.h"
 #include "webkit/browser/fileapi/file_system_operation_context.h"
 #include "webkit/common/fileapi/file_system_util.h"
 
 using fileapi::FileSystemContext;
 using fileapi::FileSystemFileUtil;
 using fileapi::FileSystemOperationContext;
 using fileapi::FileSystemURL;
 using fileapi::FileSystemURLSet;
 
 namespace sync_file_system {
 
 namespace {
 const base::FilePath::CharType kDatabaseName[] =
     FILE_PATH_LITERAL("LocalFileChangeTracker");
 const char kMark[] = "d";
 }  // namespace
 
 // A database class that stores local file changes in a local database. This
 // object must be destructed on file_task_runner.
 class LocalFileChangeTracker::TrackerDB {
  public:
-  explicit TrackerDB(const base::FilePath& base_path);
+  TrackerDB(const base::FilePath& base_path,
+            leveldb::Env* env_override);
 
   SyncStatusCode MarkDirty(const std::string& url);
   SyncStatusCode ClearDirty(const std::string& url);
   SyncStatusCode GetDirtyEntries(
       std::queue<FileSystemURL>* dirty_files);
   SyncStatusCode WriteBatch(scoped_ptr<leveldb::WriteBatch> batch);
 
  private:
   enum RecoveryOption {
     REPAIR_ON_CORRUPTION,
     FAIL_ON_CORRUPTION,
   };
 
   SyncStatusCode Init(RecoveryOption recovery_option);
   SyncStatusCode Repair(const std::string& db_path);
   void HandleError(const tracked_objects::Location& from_here,
                    const leveldb::Status& status);
 
   const base::FilePath base_path_;
+  leveldb::Env* env_override_;
   scoped_ptr<leveldb::DB> db_;
   SyncStatusCode db_status_;
 
   DISALLOW_COPY_AND_ASSIGN(TrackerDB);
 };
 
 LocalFileChangeTracker::ChangeInfo::ChangeInfo() : change_seq(-1) {}
 LocalFileChangeTracker::ChangeInfo::~ChangeInfo() {}
 
 // LocalFileChangeTracker ------------------------------------------------------
 
 LocalFileChangeTracker::LocalFileChangeTracker(
     const base::FilePath& base_path,
+    leveldb::Env* env_override,
     base::SequencedTaskRunner* file_task_runner)
     : initialized_(false),
       file_task_runner_(file_task_runner),
-      tracker_db_(new TrackerDB(base_path)),
+      tracker_db_(new TrackerDB(base_path, env_override)),
       current_change_seq_(0),
       num_changes_(0) {
 }
 
 LocalFileChangeTracker::~LocalFileChangeTracker() {
   DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
   tracker_db_.reset();
 }
 
 void LocalFileChangeTracker::OnStartUpdate(const FileSystemURL& url) {
@@ skipping 329 matching lines @@
     changes->erase(url);
     return;
   }
   info.change_seq = new_change_seq;
   if (change_seqs)
     (*change_seqs)[info.change_seq] = url;
 }
 
 // TrackerDB -------------------------------------------------------------------
 
-LocalFileChangeTracker::TrackerDB::TrackerDB(const base::FilePath& base_path)
+LocalFileChangeTracker::TrackerDB::TrackerDB(const base::FilePath& base_path,
+                                             leveldb::Env* env_override)
   : base_path_(base_path),
+    env_override_(env_override),
     db_status_(SYNC_STATUS_OK) {}
 
 SyncStatusCode LocalFileChangeTracker::TrackerDB::Init(
     RecoveryOption recovery_option) {
   if (db_.get() && db_status_ == SYNC_STATUS_OK)
     return SYNC_STATUS_OK;
 
   std::string path = fileapi::FilePathToString(
       base_path_.Append(kDatabaseName));
   leveldb::Options options;
   options.max_open_files = 0;  // Use minimum.
   options.create_if_missing = true;
+  if (env_override_)
+    options.env = env_override_;
   leveldb::DB* db;
   leveldb::Status status = leveldb::DB::Open(options, path, &db);
   if (status.ok()) {
     db_.reset(db);
     return SYNC_STATUS_OK;
   }
 
   HandleError(FROM_HERE, status);
   if (!status.IsCorruption())
     return LevelDBStatusToSyncStatusCode(status);
@@ skipping 114 matching lines @@
   if (!status.ok() && !status.IsNotFound()) {
     HandleError(FROM_HERE, status);
     db_status_ = LevelDBStatusToSyncStatusCode(status);
     db_.reset();
     return db_status_;
   }
   return SYNC_STATUS_OK;
 }
 
 }  // namespace sync_file_system