Change some snapshot- or temporary-file related changes to use ScopedFile

webkit/fileapi/async_file_util_adapter.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/fileapi/async_file_util_adapter.h"
 
 #include "base/bind.h"
 #include "base/sequenced_task_runner.h"
 #include "base/task_runner_util.h"
+#include "webkit/blob/shareable_file_reference.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_file_util.h"
 #include "webkit/fileapi/file_system_operation_context.h"
 #include "webkit/fileapi/file_system_url.h"
 #include "webkit/fileapi/file_system_util.h"
 
-namespace fileapi {
-
 using base::Bind;
 using base::Callback;
 using base::Owned;
 using base::PlatformFileError;
 using base::Unretained;
+using webkit_blob::ShareableFileReference;
+
+namespace fileapi {
 
 namespace {
 
 class EnsureFileExistsHelper {
  public:
   EnsureFileExistsHelper() : error_(base::PLATFORM_FILE_OK), created_(false) {}
 
   void RunWork(FileSystemFileUtil* file_util,
                FileSystemOperationContext* context,
                const FileSystemURL& url) {
     error_ = file_util->EnsureFileExists(context, url, &created_);
   }
 
   void Reply(const AsyncFileUtil::EnsureFileExistsCallback& callback) {
     if (!callback.is_null())
       callback.Run(error_, created_);
   }
 
  private:
   base::PlatformFileError error_;
   bool created_;
   DISALLOW_COPY_AND_ASSIGN(EnsureFileExistsHelper);
 };
 
 class GetFileInfoHelper {
  public:
   GetFileInfoHelper()
-      : error_(base::PLATFORM_FILE_OK),
-        snapshot_policy_(kSnapshotFileUnknown) {}
+      : error_(base::PLATFORM_FILE_OK) {}
 
   void GetFileInfo(FileSystemFileUtil* file_util,
                    FileSystemOperationContext* context,
                    const FileSystemURL& url) {
     error_ = file_util->GetFileInfo(context, url, &file_info_, &platform_path_);
   }
 
   void CreateSnapshotFile(FileSystemFileUtil* file_util,
                           FileSystemOperationContext* context,
                           const FileSystemURL& url) {
-    error_ = file_util->CreateSnapshotFile(
-        context, url, &file_info_, &platform_path_, &snapshot_policy_);
+    scoped_file_ = file_util->CreateSnapshotFile(
+        context, url, &error_, &file_info_, &platform_path_);
   }
 
   void ReplyFileInfo(const AsyncFileUtil::GetFileInfoCallback& callback) {
     if (!callback.is_null())
       callback.Run(error_, file_info_, platform_path_);
   }
 
   void ReplySnapshotFile(
       const AsyncFileUtil::CreateSnapshotFileCallback& callback) {
-    DCHECK(snapshot_policy_ != kSnapshotFileUnknown);
     if (!callback.is_null())
-      callback.Run(error_, file_info_, platform_path_, snapshot_policy_);
+      callback.Run(error_, file_info_, platform_path_,
+                   ShareableFileReference::GetOrCreate(scoped_file_.Pass()));
   }
 
  private:
   base::PlatformFileError error_;
   base::PlatformFileInfo file_info_;
   base::FilePath platform_path_;
-  SnapshotFilePolicy snapshot_policy_;
+  webkit_blob::ScopedFile scoped_file_;
   DISALLOW_COPY_AND_ASSIGN(GetFileInfoHelper);
 };
 
 class ReadDirectoryHelper {
  public:
   ReadDirectoryHelper() : error_(base::PLATFORM_FILE_OK) {}
 
   void RunWork(FileSystemFileUtil* file_util,
                FileSystemOperationContext* context,
                const FileSystemURL& url) {
@@ skipping 204 matching lines @@
     const CreateSnapshotFileCallback& callback) {
   GetFileInfoHelper* helper = new GetFileInfoHelper;
   return context->task_runner()->PostTaskAndReply(
         FROM_HERE,
         Bind(&GetFileInfoHelper::CreateSnapshotFile, Unretained(helper),
              sync_file_util_.get(), context, url),
         Bind(&GetFileInfoHelper::ReplySnapshotFile, Owned(helper), callback));
 }
 
 }  // namespace fileapi