Adding FileUtil::CreateSnapshotFile

webkit/fileapi/file_system_operation.cc

 // Copyright (c) 2012 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/bind.h"
 #include "base/sequenced_task_runner.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "net/base/escape.h"
 #include "net/url_request/url_request_context.h"
 #include "webkit/blob/shareable_file_reference.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_file_util_proxy.h"
 #include "webkit/fileapi/file_system_mount_point_provider.h"
 #include "webkit/fileapi/file_system_operation_context.h"
 #include "webkit/fileapi/file_system_quota_util.h"
 #include "webkit/fileapi/file_system_types.h"
 #include "webkit/fileapi/file_system_url.h"
 #include "webkit/fileapi/file_system_util.h"
 #include "webkit/fileapi/file_writer_delegate.h"
 #include "webkit/fileapi/sandbox_file_stream_writer.h"
 #include "webkit/quota/quota_manager.h"
 #include "webkit/quota/quota_types.h"
 
 namespace fileapi {
 
-namespace {
-
-void GetMetadataForSnapshot(
-    const FileSystemOperationInterface::SnapshotFileCallback& callback,
-    base::PlatformFileError result,
-    const base::PlatformFileInfo& file_info,
-    const FilePath& platform_path) {
-  // We don't want the third party to delete our local file, so just returning
-  // NULL as |file_reference|.
-  callback.Run(result, file_info, platform_path, NULL);
-}
-
-}  // anonymous namespace
-
 class FileSystemOperation::ScopedQuotaNotifier {
  public:
   ScopedQuotaNotifier(FileSystemContext* context,
                       const GURL& origin_url,
                       FileSystemType type);
   ~ScopedQuotaNotifier();
 
  private:
   // Not owned; owned by the owner of this instance (i.e. FileSystemOperation).
   FileSystemQuotaUtil* quota_util_;
@@ skipping 384 matching lines @@
   }
 
   src_util_->GetLocalFilePath(&operation_context_, url, platform_path);
 
   delete this;
 }
 
 void FileSystemOperation::CreateSnapshotFile(
     const FileSystemURL& url,
     const SnapshotFileCallback& callback) {
-  GetMetadata(url, base::Bind(&GetMetadataForSnapshot, callback));
+  DCHECK(SetPendingOperationType(kOperationCreateSnapshotFile));
+
+  base::PlatformFileError result = SetUp(url, &src_util_, SETUP_FOR_READ);
+  if (result != base::PLATFORM_FILE_OK) {
+    callback.Run(result, base::PlatformFileInfo(), FilePath(), NULL);
+    delete this;
+    return;
+  }
+
+  FileSystemFileUtilProxy::CreateSnapshotFile(
+      &operation_context_, src_util_, url,
+      base::Bind(&FileSystemOperation::DidCreateSnapshotFile,
+                 base::Owned(this), callback));
 }
 
 FileSystemOperation::FileSystemOperation(
     FileSystemContext* file_system_context)
     : operation_context_(file_system_context),
       src_util_(NULL),
       dest_util_(NULL),
       peer_handle_(base::kNullProcessHandle),
       pending_operation_(kOperationNone),
       weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
@@ skipping 198 matching lines @@
 void FileSystemOperation::DidOpenFile(
     const OpenFileCallback& callback,
     base::PlatformFileError rv,
     base::PassPlatformFile file,
     bool unused) {
   if (rv == base::PLATFORM_FILE_OK)
     CHECK_NE(base::kNullProcessHandle, peer_handle_);
   callback.Run(rv, file.ReleaseValue(), peer_handle_);
 }
 
+void FileSystemOperation::DidCreateSnapshotFile(
+    const SnapshotFileCallback& callback,
+    base::PlatformFileError result,
+    const base::PlatformFileInfo& file_info,
+    const FilePath& platform_path,
+    const scoped_refptr<webkit_blob::ShareableFileReference>& file_ref) {
+  callback.Run(result, file_info, platform_path, file_ref);
+}
+
 base::PlatformFileError FileSystemOperation::SetUp(
     const FileSystemURL& url,
     FileSystemFileUtil** file_util,
     SetUpMode mode) {
   if (!url.is_valid())
     return base::PLATFORM_FILE_ERROR_INVALID_URL;
 
   if (!file_system_context()->GetMountPointProvider(
           url.type())->IsAccessAllowed(url.origin(), url.type(), url.path()))
     return base::PLATFORM_FILE_ERROR_SECURITY;
@@ skipping 39 matching lines @@
 }
 
 bool FileSystemOperation::SetPendingOperationType(OperationType type) {
   if (pending_operation_ != kOperationNone)
     return false;
   pending_operation_ = type;
   return true;
 }
 
 }  // namespace fileapi