Fix QuotaFileUtil to write .usage into the same directory as "chrome-", not under "chrome-*".

webkit/fileapi/quota_file_util_unittest.cc

 // Copyright (c) 2011 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/quota_file_util.h"
 
 #include "base/file_path.h"
 #include "base/memory/scoped_callback_factory.h"
 #include "base/memory/scoped_temp_dir.h"
 #include "base/message_loop_proxy.h"
 #include "base/platform_file.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_file_util.h"
 #include "webkit/fileapi/file_system_operation_context.h"
 #include "webkit/fileapi/file_system_path_manager.h"
 #include "webkit/fileapi/file_system_types.h"
 #include "webkit/fileapi/file_system_usage_cache.h"
+#include "webkit/fileapi/sandbox_mount_point_provider.h"
 
 using namespace fileapi;
 
-namespace {
-
-class MockFileSystemPathManager : public FileSystemPathManager {
- public:
-  MockFileSystemPathManager(const FilePath& filesystem_path)
-      : FileSystemPathManager(base::MessageLoopProxy::CreateForCurrentThread(),
-                              filesystem_path, NULL, false, true),
-        test_filesystem_path_(filesystem_path) {}
-
-  virtual FilePath ValidateFileSystemRootAndGetPathOnFileThread(
-      const GURL& origin_url,
-      fileapi::FileSystemType type,
-      const FilePath& virtual_path,
-      bool create) {
-    return test_filesystem_path_;
-  }
-
- private:
-  FilePath test_filesystem_path_;
-};
-
-}  // namespace (anonymous)
-
 class QuotaFileUtilTest : public testing::Test {
  public:
   QuotaFileUtilTest()
       : callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
   }
 
   void SetUp() {
     ASSERT_TRUE(data_dir_.CreateUniqueTempDir());
     filesystem_dir_ = data_dir_.path().AppendASCII("filesystem");
     file_util::CreateDirectory(filesystem_dir_);
 
+    path_manager_ = new FileSystemPathManager(
+        base::MessageLoopProxy::CreateForCurrentThread(),
+        filesystem_dir_, NULL, false, true);
+
+    file_system_context_ = new FileSystemContext(
+        base::MessageLoopProxy::CreateForCurrentThread(),
+        base::MessageLoopProxy::CreateForCurrentThread(),
+        NULL, NULL, FilePath(), false,
+        true, true, path_manager_);
+
+    // Creates the filesystem directory.
+    path_manager_->sandbox_provider()->
+        ValidateFileSystemRootAndGetPathOnFileThread(
+            GURL("http://www.example.com"), kFileSystemTypeTemporary,
+            FilePath(), true);
+
     usage_file_path_ = Path(FileSystemUsageCache::kUsageFileName);
     FileSystemUsageCache::UpdateUsage(usage_file_path_, 0);
   }
 
  protected:
+  scoped_refptr<FileSystemContext> file_system_context_;
+  FileSystemPathManager* path_manager_;
+
   FileSystemOperationContext* NewContext() {
     FileSystemOperationContext *context = new FileSystemOperationContext(
-        new FileSystemContext(base::MessageLoopProxy::CreateForCurrentThread(),
-                              base::MessageLoopProxy::CreateForCurrentThread(),
-                              NULL, NULL, FilePath(), false,
-                              true, true,
-                              new MockFileSystemPathManager(filesystem_dir_)),
-        QuotaFileUtil::GetInstance());
+        file_system_context_, QuotaFileUtil::GetInstance());
+    context->set_src_origin_url(GURL("http://www.example.com"));
     context->set_src_type(fileapi::kFileSystemTypeTemporary);
     return context;
   }
 
   QuotaFileUtil* FileUtil() {
     return QuotaFileUtil::GetInstance();
   }
 
   FilePath Path(const char *file_name) {
-    return filesystem_dir_.AppendASCII(file_name);
+    return path_manager_->sandbox_provider()->GetBaseDirectoryForOriginAndType(
+        GURL("http://www.example.com"), kFileSystemTypeTemporary).
+            AppendASCII(file_name);
   }
 
   base::PlatformFileError CreateFile(const char* file_name,
       base::PlatformFile* file_handle, bool* created) {
     int file_flags = base::PLATFORM_FILE_CREATE |
         base::PLATFORM_FILE_WRITE | base::PLATFORM_FILE_ASYNC;
 
     scoped_ptr<FileSystemOperationContext> context(NewContext());
     return FileUtil()->CreateOrOpen(context.get(), Path(file_name),
         file_flags, file_handle, created);
@@ skipping 335 matching lines @@
   ASSERT_EQ(1140, GetCachedUsage());
 
   context.reset(NewContext());
   context->set_allowed_bytes_growth(QuotaFileUtil::kNoLimit);
   ASSERT_EQ(base::PLATFORM_FILE_OK,
             QuotaFileUtil::GetInstance()->Delete(context.get(),
                                                  Path(dir),
                                                  true));
   ASSERT_EQ(0, GetCachedUsage());
 }