[FileSystem] Add another copy-or-move validation hook for post-write.

webkit/browser/fileapi/copy_or_move_operation_delegate_unittest.cc

 // Copyright (c) 2013 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 <map>
 #include <queue>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop.h"
 #include "base/run_loop.h"
 #include "base/stl_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/browser/fileapi/async_file_test_helper.h"
+#include "webkit/browser/fileapi/copy_or_move_file_validator.h"
 #include "webkit/browser/fileapi/file_system_backend.h"
 #include "webkit/browser/fileapi/file_system_context.h"
 #include "webkit/browser/fileapi/file_system_operation.h"
 #include "webkit/browser/fileapi/file_system_url.h"
 #include "webkit/browser/fileapi/mock_file_system_context.h"
 #include "webkit/browser/fileapi/test_file_set.h"
+#include "webkit/browser/fileapi/test_file_system_backend.h"
 #include "webkit/browser/quota/mock_quota_manager.h"
 #include "webkit/browser/quota/quota_manager.h"
 #include "webkit/common/fileapi/file_system_util.h"
 
 namespace fileapi {
 
 typedef FileSystemOperation::FileEntryList FileEntryList;
 
 namespace {
 
 void ExpectOk(const GURL& origin_url,
               const std::string& name,
               base::PlatformFileError error) {
   ASSERT_EQ(base::PLATFORM_FILE_OK, error);
 }
 
+class TestValidatorFactory : public CopyOrMoveFileValidatorFactory {
+ public:
+  // A factory that creates validators that accept everything or nothing.
+  TestValidatorFactory() {}
+  virtual ~TestValidatorFactory() {}
+
+  virtual CopyOrMoveFileValidator* CreateCopyOrMoveFileValidator(
+      const FileSystemURL& /*src_url*/,
+      const base::FilePath& /*platform_path*/) OVERRIDE {
+    return new TestValidator(true, true, std::string("2"));

[vandebo (ex-Chrome), 2013/07/18 17:35:14]

nit: The args are all static, why not omit the functionality from TestValidator

[Greg Billock, 2013/07/30 23:18:31]

You mean contain it there?

+  }
+
+ private:
+  class TestValidator : public CopyOrMoveFileValidator {
+   public:
+    explicit TestValidator(bool pre_copy_valid,
+                           bool post_copy_valid,
+                           const std::string& reject_string)
+        : result_(pre_copy_valid ? base::PLATFORM_FILE_OK
+                                 : base::PLATFORM_FILE_ERROR_SECURITY),
+          write_result_(post_copy_valid ? base::PLATFORM_FILE_OK
+                                        : base::PLATFORM_FILE_ERROR_SECURITY),
+          reject_string_(reject_string) {
+    }
+    virtual ~TestValidator() {}
+
+    virtual void StartPreWriteValidation(
+        const ResultCallback& result_callback) OVERRIDE {
+      // Post the result since a real validator must do work asynchronously.
+      base::MessageLoop::current()->PostTask(
+          FROM_HERE, base::Bind(result_callback, result_));
+    }
+
+    virtual void StartPostWriteValidation(
+        const base::FilePath& dest_platform_path,
+        const ResultCallback& result_callback) OVERRIDE {
+      base::PlatformFileError result = write_result_;
+      std::string unsafe = dest_platform_path.AsUTF8Unsafe();
+      if (unsafe.find(reject_string_) != std::string::npos) {
+        result = base::PLATFORM_FILE_ERROR_SECURITY;
+      }
+      // Post the result since a real validator must do work asynchronously.
+      base::MessageLoop::current()->PostTask(
+          FROM_HERE, base::Bind(result_callback, result));
+    }
+
+   private:
+    base::PlatformFileError result_;
+    base::PlatformFileError write_result_;
+    std::string reject_string_;
+
+    DISALLOW_COPY_AND_ASSIGN(TestValidator);
+  };
+};
+
 }  // namespace
 
 class CopyOrMoveOperationTestHelper {
  public:
   CopyOrMoveOperationTestHelper(
       const GURL& origin,
       FileSystemType src_type,
       FileSystemType dest_type)
       : origin_(origin),
         src_type_(src_type),
@@ skipping 23 matching lines @@
 
     // Prepare the origin's root directory.
     FileSystemBackend* mount_point_provider =
         file_system_context_->GetFileSystemBackend(src_type_);
     mount_point_provider->OpenFileSystem(
         origin_, src_type_,
         OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
         base::Bind(&ExpectOk));
     mount_point_provider =
         file_system_context_->GetFileSystemBackend(dest_type_);
+    if (dest_type_ == kFileSystemTypeTest) {
+      TestFileSystemBackend* test_provider =
+          static_cast<TestFileSystemBackend*>(mount_point_provider);
+      scoped_ptr<CopyOrMoveFileValidatorFactory> factory(
+          new TestValidatorFactory);
+      test_provider->set_require_copy_or_move_validator(true);
+      test_provider->InitializeCopyOrMoveFileValidatorFactory(factory.Pass());
+    }
     mount_point_provider->OpenFileSystem(
         origin_, dest_type_,
         OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
         base::Bind(&ExpectOk));
     base::MessageLoop::current()->RunUntilIdle();
 
     // Grant relatively big quota initially.
     quota_manager_->SetQuota(origin_,
                              FileSystemTypeToQuotaStorageType(src_type_),
                              1024 * 1024);
@@ skipping 54 matching lines @@
         return result;
     }
     return result;
   }
 
   void VerifyTestCaseFiles(
       const FileSystemURL& root,
       const test::TestCaseRecord* const test_cases,
       size_t test_case_size) {
     std::map<base::FilePath, const test::TestCaseRecord*> test_case_map;
-    for (size_t i = 0; i < test_case_size; ++i)
+    for (size_t i = 0; i < test_case_size; ++i) {
       test_case_map[
           base::FilePath(test_cases[i].path).NormalizePathSeparators()] =
               &test_cases[i];
+    }
 
     std::queue<FileSystemURL> directories;
     FileEntryList entries;
     directories.push(root);
     while (!directories.empty()) {
       FileSystemURL dir = directories.front();
       directories.pop();
       ASSERT_EQ(base::PLATFORM_FILE_OK, ReadDirectory(dir, &entries));
       for (size_t i = 0; i < entries.size(); ++i) {
         FileSystemURL url = file_system_context_->CreateCrackedFileSystemURL(
@@ skipping 252 matching lines @@
                              test::kRegularTestCases,
                              test::kRegularTestCaseSize);
 
   int64 src_new_usage = helper.GetSourceUsage();
   ASSERT_EQ(src_initial_usage, src_new_usage);
 
   int64 dest_increase = helper.GetDestUsage() - dest_initial_usage;
   ASSERT_EQ(src_increase, dest_increase);
 }
 
+TEST(LocalFileSystemCopyOrMoveOperationTest,
+     MoveDirectoryFailPostWriteValidation) {
+  CopyOrMoveOperationTestHelper helper(GURL("http://foo"),
+                                       kFileSystemTypeTemporary,
+                                       kFileSystemTypeTest);
+  helper.SetUp();
+
+  FileSystemURL src = helper.SourceURL("a");
+  FileSystemURL dest = helper.DestURL("b");
+
+  // Set up a source directory.
+  ASSERT_EQ(base::PLATFORM_FILE_OK, helper.CreateDirectory(src));
+  ASSERT_EQ(base::PLATFORM_FILE_OK,
+            helper.SetUpTestCaseFiles(src,
+                                      test::kRegularTestCases,
+                                      test::kRegularTestCaseSize));
+
+  // Move it.
+  helper.Move(src, dest);
+
+  // Verify.
+  ASSERT_TRUE(helper.DirectoryExists(src));
+  ASSERT_TRUE(helper.DirectoryExists(dest));
+
+  test::TestCaseRecord kMoveDirResultCases[] = {
+    {false, FILE_PATH_LITERAL("file 0"), 38},
+    {false, FILE_PATH_LITERAL("file 3"), 0},
+  };
+
+  helper.VerifyTestCaseFiles(dest,
+                             kMoveDirResultCases,
+                             arraysize(kMoveDirResultCases));
+}
+
 }  // namespace fileapi