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

webkit/browser/fileapi/copy_or_move_operation_delegate.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 "webkit/browser/fileapi/copy_or_move_operation_delegate.h"
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "webkit/browser/fileapi/copy_or_move_file_validator.h"
 #include "webkit/browser/fileapi/file_system_context.h"
@@ skipping 92 matching lines @@
       error != base::PLATFORM_FILE_ERROR_NOT_FOUND) {
     callback_.Run(error);
     return;
   }
 
   // Start to process the source directory recursively.
   // TODO(kinuko): This could be too expensive for same_file_system_==true
   // and operation==MOVE case, probably we can just rename the root directory.
   // http://crbug.com/172187
   StartRecursiveOperation(
       src_root_, base::Bind(&CopyOrMoveOperationDelegate::DidFinishCopy,

[kinuko, 2013/07/12 05:00:19]

I overlooked this in my previous review, but when DidFinishCopy is called for
this case (and only for this case) the given url_pair contains directories, and
we won't want to run PostWriteValidation.  I think you need to separate out this
case, maybe splitting DidFinishCopy into two or passing another flag.

Also it might be better to add a test for recursive directory /w multiple files
case?

[Greg Billock, 2013/07/12 18:02:19]

OK. I'll add a directory-specific handler for this. Does the MoveDirectory test
already qualify? It looks to me like this moves a directory recursively with
multiples files in it. The test validator just always passes, so we're just
using what ought to be equivalent to the old code path in the test.

[vandebo (ex-Chrome), 2013/07/12 18:51:48]

Probably want a complementary test that fails verify at some middle point so
that you can ensure the code does what you expect (I don't know what to expect).

[Greg Billock, 2013/07/12 20:36:46]

validation is per-file at present, so you'd expect the move/copy to work except
for the one failed file. Should this work differently do you think?

I agree the behavior is currently somewhat difficult to follow, since there are
lots of cases combined (dir/file, move/copy). They share enough that it's
sensible to combine them, but it does have this result.

On 2013/07/12 18:51:48, vandebo wrote:

[vandebo (ex-Chrome), 2013/07/12 21:06:58]

We only get one result code, so do you say it worked, or failed if only some of
the files worked?  If you are doing a move, do you delete all the originals, the
originals that were ok, or none of the originals ?

[Greg Billock, 2013/07/12 22:06:32]

Yeah, the test shows this: it deletes the entire dest dir, and bails out on the
first error. Is that what we want? (Uploaded current state; this does not pass,
but let's figure out what we want to happen for post-write failure first.)

On 2013/07/12 21:06:58, vandebo wrote:

-                            AsWeakPtr(), src_root_, callback_));
+                            AsWeakPtr(), URLPair(src_root_, dest_root_),
+                            callback_));
 }
 
 void CopyOrMoveOperationDelegate::CopyOrMoveFile(const URLPair& url_pair,
                                             const StatusCallback& callback) {
   // Same filesystem case.
   if (same_file_system_) {
     if (operation_type_ == OPERATION_MOVE) {
       operation_runner()->MoveFileLocal(url_pair.src, url_pair.dest, callback);
     } else {
       operation_runner()->CopyFileLocal(url_pair.src, url_pair.dest, callback);
     }
     return;
   }
 
   // Cross filesystem case.
   // Perform CreateSnapshotFile, CopyInForeignFile and then calls
   // copy_callback which removes the source file if operation_type == MOVE.
   StatusCallback copy_callback =
       base::Bind(&CopyOrMoveOperationDelegate::DidFinishCopy, AsWeakPtr(),
-                 url_pair.src, callback);
+                 url_pair, callback);
   operation_runner()->CreateSnapshotFile(
       url_pair.src,
       base::Bind(&CopyOrMoveOperationDelegate::DidCreateSnapshot, AsWeakPtr(),
                  url_pair, copy_callback));
 }
 
 void CopyOrMoveOperationDelegate::DidCreateSnapshot(
     const URLPair& url_pair,
     const StatusCallback& callback,
     base::PlatformFileError error,
@@ skipping 37 matching lines @@
     base::PlatformFileError error) {
   if (error != base::PLATFORM_FILE_OK) {
     callback.Run(error);
     return;
   }
 
   operation_runner()->CopyInForeignFile(platform_path, dest, callback);
 }
 
 void CopyOrMoveOperationDelegate::DidFinishCopy(
-    const FileSystemURL& src,
+    const URLPair& url_pair,
     const StatusCallback& callback,
     base::PlatformFileError error) {
-  if (error != base::PLATFORM_FILE_OK ||
-      operation_type_ == OPERATION_COPY) {
+  if (error != base::PLATFORM_FILE_OK) {
     callback.Run(error);
     return;
   }
+
+  // |validator_| must not exist in the same-filesystem case.
+  if (!validator_.get()) {
+    scoped_refptr<webkit_blob::ShareableFileReference> file_ref;
+    DidPostWriteValidation(url_pair, callback, file_ref,
+                           base::PLATFORM_FILE_OK);
+    return;
+  }
+
+  DCHECK(!same_file_system_);
+  operation_runner()->CreateSnapshotFile(
+      url_pair.dest,
+      base::Bind(&CopyOrMoveOperationDelegate::DoPostWriteValidation,
+                 AsWeakPtr(), url_pair, callback));
+}
+
+void CopyOrMoveOperationDelegate::DoPostWriteValidation(
+    const URLPair& url_pair,
+    const StatusCallback& callback,
+    base::PlatformFileError error,
+    const base::PlatformFileInfo& file_info,
+    const base::FilePath& platform_path,
+    const scoped_refptr<webkit_blob::ShareableFileReference>& file_ref) {
+  if (error != base::PLATFORM_FILE_OK) {
+    operation_runner()->Remove(
+        url_pair.dest, true,
+        base::Bind(&CopyOrMoveOperationDelegate::DidRemoveDestForError,
+                   AsWeakPtr(), error, callback));
+    return;
+  }
+
+  DCHECK(validator_.get());
+  validator_->StartPostWriteValidation(

[vandebo (ex-Chrome), 2013/07/12 15:08:15]

Probably should add a comment about keeping file_ref alive until after
PostWriteValidation finishes, otherwise someone might come along later are
remove the "unused" argument.

[Greg Billock, 2013/07/12 18:02:19]

Done.

+      platform_path,
+      base::Bind(&CopyOrMoveOperationDelegate::DidPostWriteValidation,
+                 AsWeakPtr(), url_pair, callback, file_ref));
+}
+
+void CopyOrMoveOperationDelegate::DidPostWriteValidation(
+    const URLPair& url_pair,
+    const StatusCallback& callback,
+    const scoped_refptr<webkit_blob::ShareableFileReference>& file_ref,

[vandebo (ex-Chrome), 2013/07/12 15:08:15]

nit: file_ref isn't used in this context, so /*file ref*/

[Greg Billock, 2013/07/12 18:02:19]

Done.

+    base::PlatformFileError error) {
+  if (error != base::PLATFORM_FILE_OK) {
+    operation_runner()->Remove(
+        url_pair.dest, true,
+        base::Bind(&CopyOrMoveOperationDelegate::DidRemoveDestForError,
+                   AsWeakPtr(), error, callback));
+    return;
+  }
+
+  if (operation_type_ == OPERATION_COPY) {
+    callback.Run(error);
+    return;
+  }
 
   DCHECK_EQ(OPERATION_MOVE, operation_type_);
 
   // Remove the source for finalizing move operation.
   operation_runner()->Remove(
-      src, true /* recursive */,
+      url_pair.src, true /* recursive */,
       base::Bind(&CopyOrMoveOperationDelegate::DidRemoveSourceForMove,
                  AsWeakPtr(), callback));
 }
 
 void CopyOrMoveOperationDelegate::DidRemoveSourceForMove(
     const StatusCallback& callback,
     base::PlatformFileError error) {
   if (error == base::PLATFORM_FILE_ERROR_NOT_FOUND)
     error = base::PLATFORM_FILE_OK;
   callback.Run(error);
 }
 
 FileSystemURL CopyOrMoveOperationDelegate::CreateDestURL(
     const FileSystemURL& src_url) const {
   DCHECK_EQ(src_root_.type(), src_url.type());
   DCHECK_EQ(src_root_.origin(), src_url.origin());
 
   base::FilePath relative = dest_root_.virtual_path();
   src_root_.virtual_path().AppendRelativePath(src_url.virtual_path(),
                                               &relative);
   return file_system_context()->CreateCrackedFileSystemURL(
       dest_root_.origin(),
       dest_root_.mount_type(),
       relative);
 }
 
+void CopyOrMoveOperationDelegate::DidRemoveDestForError(
+    base::PlatformFileError prior_error,
+    const StatusCallback& callback,
+    base::PlatformFileError error) {
+  callback.Run(prior_error);

[vandebo (ex-Chrome), 2013/07/12 15:08:15]

nit: VLOG if error != OK ?

[Greg Billock, 2013/07/12 18:02:19]

Done.

+}
+
 }  // namespace fileapi