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

webkit/browser/fileapi/obfuscated_file_util.cc

 // Copyright (c) 2012 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 "webkit/browser/fileapi/obfuscated_file_util.h"
 
 #include <queue>
 #include <string>
 #include <vector>
 
@@ skipping 236 matching lines @@
 
  private:
   std::vector<OriginRecord> origins_;
   OriginRecord current_;
   base::FilePath base_file_path_;
 };
 
 ObfuscatedFileUtil::ObfuscatedFileUtil(
     quota::SpecialStoragePolicy* special_storage_policy,
     const base::FilePath& file_system_directory,
+    leveldb::Env* env_override,
     base::SequencedTaskRunner* file_task_runner,
     const GetTypeStringForURLCallback& get_type_string_for_url,
     const std::set<std::string>& known_type_strings,
     SandboxFileSystemBackendDelegate* sandbox_delegate)
     : special_storage_policy_(special_storage_policy),
       file_system_directory_(file_system_directory),
+      env_override_(env_override),
       db_flush_delay_seconds_(10 * 60),  // 10 mins.
       file_task_runner_(file_task_runner),
       get_type_string_for_url_(get_type_string_for_url),
       known_type_strings_(known_type_strings),
       sandbox_delegate_(sandbox_delegate) {
 }
 
 ObfuscatedFileUtil::~ObfuscatedFileUtil() {
   DropDatabases();
 }
@@ skipping 664 matching lines @@
     SandboxDirectoryDatabase* database = iter->second;
     directories_.erase(iter);
     delete database;
   }
 
   base::File::Error error = base::File::FILE_OK;
   base::FilePath path = GetDirectoryForOriginAndType(
       origin, type_string, false, &error);
   if (path.empty() || error == base::File::FILE_ERROR_NOT_FOUND)
     return true;
-  return SandboxDirectoryDatabase::DestroyDatabase(path);
+  return SandboxDirectoryDatabase::DestroyDatabase(path, env_override_);
 }
 
 // static
 int64 ObfuscatedFileUtil::ComputeFilePathCost(const base::FilePath& path) {
   return UsageForPath(VirtualPath::BaseName(path).value().size());
 }
 
 void ObfuscatedFileUtil::MaybePrepopulateDatabase(
     const std::vector<std::string>& type_strings_to_prepopulate) {
-  SandboxPrioritizedOriginDatabase database(file_system_directory_);
+  SandboxPrioritizedOriginDatabase database(file_system_directory_,
+                                            env_override_);
   std::string origin_string = database.GetPrimaryOrigin();
   if (origin_string.empty() || !database.HasOriginPath(origin_string))
     return;
   const GURL origin = webkit_database::GetOriginFromIdentifier(origin_string);
 
   // Prepopulate the directory database(s) if and only if this instance
   // has primary origin and the directory database is already there.
   for (size_t i = 0; i < type_strings_to_prepopulate.size(); ++i) {
     const std::string type_string = type_strings_to_prepopulate[i];
     // Only handles known types.
     if (!ContainsKey(known_type_strings_, type_string))
       continue;
     base::File::Error error = base::File::FILE_ERROR_FAILED;
     base::FilePath path = GetDirectoryForOriginAndType(
         origin, type_string, false, &error);
     if (error != base::File::FILE_OK)
       continue;
-    scoped_ptr<SandboxDirectoryDatabase> db(new SandboxDirectoryDatabase(path));
+    scoped_ptr<SandboxDirectoryDatabase> db(
+        new SandboxDirectoryDatabase(path, env_override_));
     if (db->Init(SandboxDirectoryDatabase::FAIL_ON_CORRUPTION)) {
       directories_[GetDirectoryDatabaseKey(origin, type_string)] = db.release();
       MarkUsed();
       // Don't populate more than one database, as it may rather hurt
       // performance.
       break;
     }
   }
 }
 
@@ skipping 180 matching lines @@
   }
 
   base::File::Error error = base::File::FILE_OK;
   base::FilePath path = GetDirectoryForURL(url, create, &error);
   if (error != base::File::FILE_OK) {
     LOG(WARNING) << "Failed to get origin+type directory: "
                  << url.DebugString() << " error:" << error;
     return NULL;
   }
   MarkUsed();
-  SandboxDirectoryDatabase* database = new SandboxDirectoryDatabase(path);
+  SandboxDirectoryDatabase* database =
+      new SandboxDirectoryDatabase(path, env_override_);
   directories_[key] = database;
   return database;
 }
 
 base::FilePath ObfuscatedFileUtil::GetDirectoryForOrigin(
     const GURL& origin, bool create, base::File::Error* error_code) {
   if (!InitOriginDatabase(origin, create)) {
     if (error_code) {
       *error_code = create ?
           base::File::FILE_ERROR_FAILED :
@@ skipping 80 matching lines @@
 
   if (!create && !base::DirectoryExists(file_system_directory_))
     return false;
   if (!base::CreateDirectory(file_system_directory_)) {
     LOG(WARNING) << "Failed to create FileSystem directory: " <<
         file_system_directory_.value();
     return false;
   }
 
   SandboxPrioritizedOriginDatabase* prioritized_origin_database =
-      new SandboxPrioritizedOriginDatabase(file_system_directory_);
+      new SandboxPrioritizedOriginDatabase(file_system_directory_,
+                                           env_override_);
   origin_database_.reset(prioritized_origin_database);
 
   if (origin_hint.is_empty() || !HasIsolatedStorage(origin_hint))
     return true;
 
   const std::string isolated_origin_string =
       webkit_database::GetIdentifierFromOrigin(origin_hint);
 
   // TODO(kinuko): Deprecate this after a few release cycles, e.g. around M33.
   base::FilePath isolated_origin_dir = file_system_directory_.Append(
@@ skipping 120 matching lines @@
   }
   return error;
 }
 
 bool ObfuscatedFileUtil::HasIsolatedStorage(const GURL& origin) {
   return special_storage_policy_.get() &&
       special_storage_policy_->HasIsolatedStorage(origin);
 }
 
 }  // namespace fileapi