Always pass FileSystemContext to ObfuscatedFileUtil operations

webkit/fileapi/sandbox_mount_point_provider.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/fileapi/sandbox_mount_point_provider.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 480 matching lines @@
 FilePath SandboxMountPointProvider::GetBaseDirectoryForOriginAndType(
     const GURL& origin_url, fileapi::FileSystemType type, bool create) const {
 
   MigrateIfNeeded(sandbox_file_util_, old_base_path());
 
   return sandbox_file_util_->GetDirectoryForOriginAndType(
       origin_url, type, create);
 }
 
 bool SandboxMountPointProvider::DeleteOriginDataOnFileThread(
-    QuotaManagerProxy* proxy, const GURL& origin_url,
+    FileSystemContext* file_system_context,
+    QuotaManagerProxy* proxy,
+    const GURL& origin_url,
     fileapi::FileSystemType type) {
   MigrateIfNeeded(sandbox_file_util_, old_base_path());
 
-  int64 usage = GetOriginUsageOnFileThread(origin_url, type);
+  int64 usage = GetOriginUsageOnFileThread(file_system_context,
+                                           origin_url, type);
 
   bool result =
       sandbox_file_util_->DeleteDirectoryForOriginAndType(origin_url, type);
   if (result && proxy) {
     proxy->NotifyStorageModified(
         quota::QuotaClient::kFileSystem,
         origin_url,
         FileSystemTypeToQuotaStorageType(type),
         -usage);
   }
@@ skipping 29 matching lines @@
   scoped_ptr<OriginEnumerator> enumerator(CreateOriginEnumerator());
   GURL origin;
   while (!(origin = enumerator->Next()).is_empty()) {
     if (host == net::GetHostOrSpecFromURL(origin) &&
         enumerator->HasFileSystemType(type))
       origins->insert(origin);
   }
 }
 
 int64 SandboxMountPointProvider::GetOriginUsageOnFileThread(
-    const GURL& origin_url, fileapi::FileSystemType type) {
+    FileSystemContext* file_system_context,
+    const GURL& origin_url,
+    fileapi::FileSystemType type) {
   DCHECK(type == kFileSystemTypeTemporary ||
          type == kFileSystemTypePersistent);
   FilePath base_path =
       GetBaseDirectoryForOriginAndType(origin_url, type, false);
   if (base_path.empty() || !file_util::DirectoryExists(base_path)) return 0;
   FilePath usage_file_path =
       base_path.Append(FileSystemUsageCache::kUsageFileName);
 
   bool is_valid = FileSystemUsageCache::IsValid(usage_file_path);
   int32 dirty_status = FileSystemUsageCache::GetDirty(usage_file_path);
   bool visited = (visited_origins_.find(origin_url) != visited_origins_.end());
   visited_origins_.insert(origin_url);
   if (is_valid && (dirty_status == 0 || (dirty_status > 0 && visited))) {
     // The usage cache is clean (dirty == 0) or the origin is already
     // initialized and running.  Read the cache file to get the usage.
     return FileSystemUsageCache::GetUsage(usage_file_path);
   }
   // The usage cache has not been initialized or the cache is dirty.
   // Get the directory size now and update the cache.
   FileSystemUsageCache::Delete(usage_file_path);
 
-  FileSystemOperationContext context(NULL);
+  FileSystemOperationContext context(file_system_context);
   FileSystemPath path(origin_url, type, FilePath());
   scoped_ptr<FileSystemFileUtil::AbstractFileEnumerator> enumerator(
       sandbox_file_util_->CreateFileEnumerator(&context, path, true));
 
   FilePath file_path_each;
   int64 usage = 0;
 
   while (!(file_path_each = enumerator->Next()).empty()) {
     base::PlatformFileInfo file_info;
     FilePath platform_file_path;
@@ skipping 147 matching lines @@
       break;
     case base::PLATFORM_FILE_ERROR_FAILED:
     default:
       REPORT(kUnknownError);
       break;
   }
 #undef REPORT
 }
 
 }  // namespace fileapi