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/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_temp_dir.h"
 #include "base/message_loop.h"
@@ skipping 21 matching lines @@
 // 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 {
@@ skipping 11 matching lines @@
 
   GURL URLForPath(const FilePath& path) const {
     // Only the path will actually get used.
     return GURL("file://").Resolve(path.value());
   }
 
   // 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);
+  }
+
   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 624 matching lines @@
   file_util::CreateTemporaryFileInDir(parent_dir.path(), &child_file);
   FilePath child_dir;
   ASSERT_TRUE(file_util::CreateTemporaryDirInDir(
       parent_dir.path(), FILE_PATH_LITERAL("child_dir"), &child_dir));
 
   operation()->Remove(URLForPath(parent_dir.path()), true /* recursive */);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kFileOperationSucceeded, status());
   EXPECT_FALSE(file_util::DirectoryExists(parent_dir.path()));
 }
 

[ericu, 2011/04/19 20:30:49]

Missing test for new operation.

[zel, 2011/04/20 02:02:07]

Tests added. Done.

 TEST_F(FileSystemOperationTest, TestTruncate) {
   ScopedTempDir dir;
   ASSERT_TRUE(dir.CreateUniqueTempDir());
   FilePath file;
   file_util::CreateTemporaryFileInDir(dir.path(), &file);
 
   char test_data[] = "test data";
   int data_size = static_cast<int>(sizeof(test_data));
   EXPECT_EQ(data_size,
             file_util::WriteFile(file, test_data, data_size));
@@ skipping 34 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