Fixed file/directory url resolution for external mount point provider.

webkit/fileapi/file_system_operation_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/file_system_operation.h"
 
+#include "base/file_util.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_temp_dir.h"
 #include "base/message_loop.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/fileapi/file_system_callback_dispatcher.h"
+#include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_file_util.h"
+#include "webkit/fileapi/file_system_mount_point_provider.h"
 #include "webkit/fileapi/file_system_operation.h"
+#include "webkit/fileapi/file_system_path_manager.h"
+#include "webkit/fileapi/file_system_util.h"
 
 namespace fileapi {
 
 const int kFileOperationStatusNotSet = 1;
 const int kFileOperationSucceeded = 0;
 
 static bool FileExists(FilePath path) {
   return file_util::PathExists(path) && !file_util::DirectoryExists(path);
 }
 
 class MockDispatcher;
 
 // Test class for FileSystemOperation.  Note that this just tests low-level
 // operations but doesn't test OpenFileSystem or any additional checks
 // that require FileSystemContext (e.g. sandboxed paths, unlimited_storage
 // quota handling etc).
 // See SimpleFileSystem for more complete test environment for sandboxed
 // FileSystem.
 class FileSystemOperationTest : public testing::Test {
  public:
   FileSystemOperationTest()
       : status_(kFileOperationStatusNotSet) {
     EXPECT_TRUE(base_.CreateUniqueTempDir());
   }
 
   FileSystemOperation* operation();
 
+  void set_local_path(const FilePath& path) { local_path_ = path; }
+  const FilePath& local_path() const { return local_path_; }
   void set_status(int status) { status_ = status; }
   int status() const { return status_; }
   void set_info(const base::PlatformFileInfo& info) { info_ = info; }
   const base::PlatformFileInfo& info() const { return info_; }
   void set_path(const FilePath& path) { path_ = path; }
   const FilePath& path() const { return path_; }
   void set_entries(const std::vector<base::FileUtilProxy::Entry>& entries) {
     entries_ = entries;
   }
   const std::vector<base::FileUtilProxy::Entry>& entries() const {
     return entries_;
   }
 
  protected:
   // Common temp base for nondestructive uses.
   ScopedTempDir base_;
 
   GURL URLForRelativePath(const std::string& path) const {
     // Only the path will actually get used.
     return GURL("file://").Resolve(base_.path().value()).Resolve(path);
   }
 
   GURL URLForPath(const FilePath& path) const {
     // Only the path will actually get used.
     return GURL("file://").Resolve(path.value());
   }
 
+  GURL TestLocalPath(const FilePath& path) const {
+    return GURL(std::string("chrome://test") + path.value());

[ericu, 2011/04/20 02:23:46]

This looks unlikely to work on Windows, where path will start with "c:\".  Can
you just use URLForPath?

[zel, 2011/04/20 02:49:57]

Done.

+  }
+
+  GURL TestURLForPath(const FilePath& path) const {
+    return GURL(std::string("filesystem:") + TestLocalPath(path).spec());

[ericu, 2011/04/20 02:23:46]

Likewise here, can you use one of the above functions?

[zel, 2011/04/20 02:49:57]

Yes, I've been already bitten by angry bbots on this one. Done.

+  }
+
   // For post-operation status.
   int status_;
   base::PlatformFileInfo info_;
   FilePath path_;
+  FilePath local_path_;
   std::vector<base::FileUtilProxy::Entry> entries_;
 
   DISALLOW_COPY_AND_ASSIGN(FileSystemOperationTest);
 };
 
 class MockDispatcher : public FileSystemCallbackDispatcher {
  public:
   MockDispatcher(FileSystemOperationTest* test) : test_(test) { }
 
   virtual void DidFail(base::PlatformFileError status) {
     test_->set_status(status);
   }
 
   virtual void DidSucceed() {
     test_->set_status(kFileOperationSucceeded);
   }
 
+  virtual void DidGetLocalPath(const FilePath& local_path) {
+    test_->set_local_path(local_path);
+    test_->set_status(kFileOperationSucceeded);
+  }
+
   virtual void DidReadMetadata(
       const base::PlatformFileInfo& info,
       const FilePath& platform_path) {
     test_->set_info(info);
     test_->set_path(platform_path);
     test_->set_status(kFileOperationSucceeded);
   }
 
   virtual void DidReadDirectory(
       const std::vector<base::FileUtilProxy::Entry>& entries,
@@ skipping 19 matching lines @@
       base::MessageLoopProxy::CreateForCurrentThread(),
       NULL,
       FileSystemFileUtil::GetInstance());
   operation->file_system_operation_context()->set_src_type(
       kFileSystemTypeTemporary);
   operation->file_system_operation_context()->set_dest_type(
       kFileSystemTypeTemporary);
   GURL origin_url("fake://fake.foo/");
   operation->file_system_operation_context()->set_src_origin_url(origin_url);
   operation->file_system_operation_context()->set_dest_origin_url(origin_url);
+
   return operation;
 }
 
 TEST_F(FileSystemOperationTest, TestMoveFailureSrcDoesntExist) {
   GURL src(URLForRelativePath("a"));
   GURL dest(URLForRelativePath("b"));
   operation()->Move(src, dest);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, status());
 }
@@ skipping 464 matching lines @@
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kFileOperationSucceeded, status());
 
   operation()->GetMetadata(URLForPath(file));
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kFileOperationSucceeded, status());
   EXPECT_FALSE(info().is_directory);
   EXPECT_EQ(file, path());
 }
 
+TEST_F(FileSystemOperationTest, TestGetLocalFilePathSuccess) {
+  ScopedTempDir dir;
+  ASSERT_TRUE(dir.CreateUniqueTempDir());
+  operation()->GetLocalPath(TestURLForPath(dir.path()));
+  MessageLoop::current()->RunAllPending();
+  EXPECT_EQ(kFileOperationSucceeded, status());
+  EXPECT_EQ(local_path().value(), TestLocalPath(dir.path()).spec());
+
+  FilePath file;
+  file_util::CreateTemporaryFileInDir(dir.path(), &file);
+  operation()->GetLocalPath(TestURLForPath(file));
+  MessageLoop::current()->RunAllPending();
+  EXPECT_EQ(kFileOperationSucceeded, status());
+  EXPECT_EQ(local_path().value(), TestLocalPath(file).spec());
+}
+
 TEST_F(FileSystemOperationTest, TestTypeMismatchErrors) {
   ScopedTempDir dir;
   ASSERT_TRUE(dir.CreateUniqueTempDir());
   operation()->FileExists(URLForPath(dir.path()));
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_A_FILE, status());
 
   FilePath file;
   ASSERT_TRUE(file_util::CreateTemporaryFileInDir(dir.path(), &file));
   operation()->DirectoryExists(URLForPath(file));
@@ skipping 156 matching lines @@
 
   // Check that its length is now 3 and that it contains only bits of test data.
   EXPECT_TRUE(file_util::GetFileInfo(file, &info));
   EXPECT_EQ(length, info.size);
   EXPECT_EQ(length, file_util::ReadFile(file, data, length));
   for (int i = 0; i < length; ++i)
     EXPECT_EQ(test_data[i], data[i]);
 }
 
 }  // namespace fileapi