Fix up some tests for copy-or-move validator and nearby.

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"
@@ skipping 28 matching lines @@
 
 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 {
+    // Move arg management to TestValidator?
     return new TestValidator(true, true, std::string("2"));
   }
 
  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
@@ skipping 47 matching lines @@
 
   ~CopyOrMoveOperationTestHelper() {
     file_system_context_ = NULL;
     quota_manager_proxy_->SimulateQuotaManagerDestroyed();
     quota_manager_ = NULL;
     quota_manager_proxy_ = NULL;
     base::MessageLoop::current()->RunUntilIdle();
   }
 
   void SetUp() {
+    SetUp(true, true);
+  }
+
+  void SetUpNoValidator() {
+    SetUp(true, false);
+  }
+
+  void SetUp(bool require_copy_or_move_validator,
+             bool init_copy_or_move_validator) {
     ASSERT_TRUE(base_.CreateUniqueTempDir());
     base::FilePath base_dir = base_.path();
     quota_manager_ =
         new quota::MockQuotaManager(false /* is_incognito */,
                                     base_dir,
                                     base::MessageLoopProxy::current().get(),
                                     base::MessageLoopProxy::current().get(),
                                     NULL /* special storage policy */);
     quota_manager_proxy_ = new quota::MockQuotaManagerProxy(
         quota_manager_.get(), base::MessageLoopProxy::current().get());
     file_system_context_ =
         CreateFileSystemContextForTesting(quota_manager_proxy_.get(), base_dir);
 
     // Prepare the origin's root directory.
     FileSystemBackend* backend =
         file_system_context_->GetFileSystemBackend(src_type_);
     backend->OpenFileSystem(origin_, src_type_,
                             OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
                             base::Bind(&ExpectOk));
     backend = file_system_context_->GetFileSystemBackend(dest_type_);
     if (dest_type_ == kFileSystemTypeTest) {
       TestFileSystemBackend* test_backend =
           static_cast<TestFileSystemBackend*>(backend);
       scoped_ptr<CopyOrMoveFileValidatorFactory> factory(
           new TestValidatorFactory);
-      test_backend->set_require_copy_or_move_validator(true);
-      test_backend->InitializeCopyOrMoveFileValidatorFactory(factory.Pass());
+      test_backend->set_require_copy_or_move_validator(
+          require_copy_or_move_validator);
+      if (init_copy_or_move_validator)
+        test_backend->InitializeCopyOrMoveFileValidatorFactory(factory.Pass());
     }
     backend->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 369 matching lines @@
   test::TestCaseRecord kMoveDirResultCases[] = {
     {false, FILE_PATH_LITERAL("file 0"), 38},
     {false, FILE_PATH_LITERAL("file 3"), 0},
   };
 
   helper.VerifyTestCaseFiles(dest,
                              kMoveDirResultCases,
                              arraysize(kMoveDirResultCases));
 }
 
+TEST(LocalFileSystemCopyOrMoveOperationTest, CopySingleFileNoValidator) {
+  CopyOrMoveOperationTestHelper helper(GURL("http://foo"),
+                                       kFileSystemTypeTemporary,
+                                       kFileSystemTypeTest);
+  helper.SetUpNoValidator();
+
+  FileSystemURL src = helper.SourceURL("a");
+  FileSystemURL dest = helper.DestURL("b");
+
+  // Set up a source file.
+  ASSERT_EQ(base::PLATFORM_FILE_OK, helper.CreateFile(src, 10));
+
+  // The copy attempt should fail with a security error -- getting
+  // the factory returns a security error, and the copy operation must
+  // respect that.
+  ASSERT_EQ(base::PLATFORM_FILE_ERROR_SECURITY, helper.Copy(src, dest));
+}
+
 }  // namespace fileapi