Asynchronously open the temp file used for Pepper StreamToFile, and delete th...

chrome/browser/file_system_proxy.cc

+// Copyright (c) 2010 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 "chrome/browser/file_system_proxy.h"
+
+#include "base/file_util.h"
+#include "chrome/browser/chrome_thread_relay.h"
+
+namespace {
+
+class RelayCreateOrOpen : public ChromeThreadRelay {
+ public:
+  RelayCreateOrOpen(
+      const FilePath& file_path,
+      int file_flags,
+      FileSystemProxy::CreateOrOpenCallback* callback)
+      : file_path_(file_path),
+        file_flags_(file_flags),
+        callback_(callback),
+        file_handle_(base::kInvalidPlatformFileValue),
+        created_(false) {
+    DCHECK(callback);
+  }
+
+ protected:
+  virtual ~RelayCreateOrOpen() {
+    if (file_handle_ != base::kInvalidPlatformFileValue)
+      FileSystemProxy::Close(file_handle_, NULL);
+  }
+
+  virtual void RunWork() {
+    file_handle_ = base::CreatePlatformFile(file_path_, file_flags_, &created_);
+  }
+
+  virtual void RunCallback() {
+    callback_->Run(base::PassPlatformFile(&file_handle_), created_);
+    delete callback_;
+  }
+
+ private:
+  FilePath file_path_;
+  int file_flags_;
+  FileSystemProxy::CreateOrOpenCallback* callback_;
+  base::PlatformFile file_handle_;
+  bool created_;
+};
+
+class RelayCreateTemporary : public ChromeThreadRelay {
+ public:
+  explicit RelayCreateTemporary(
+      FileSystemProxy::CreateTemporaryCallback* callback)
+      : callback_(callback),
+        file_handle_(base::kInvalidPlatformFileValue) {
+    DCHECK(callback);
+  }
+
+ protected:
+  virtual ~RelayCreateTemporary() {
+    if (file_handle_ != base::kInvalidPlatformFileValue)
+      FileSystemProxy::Close(file_handle_, NULL);
+  }
+
+  virtual void RunWork() {
+    // TODO(darin): file_util should have a variant of CreateTemporaryFile
+    // that returns a FilePath and a PlatformFile.
+    file_util::CreateTemporaryFile(&file_path_);
+
+    // Use a fixed set of flags that are appropriate for writing to a temporary
+    // file from the IO thread using a net::FileStream.
+    int file_flags =
+        base::PLATFORM_FILE_CREATE_ALWAYS |
+        base::PLATFORM_FILE_WRITE |
+        base::PLATFORM_FILE_ASYNC |
+        base::PLATFORM_FILE_TEMPORARY;
+    file_handle_ = base::CreatePlatformFile(file_path_, file_flags, NULL);
+  }
+
+  virtual void RunCallback() {
+    callback_->Run(base::PassPlatformFile(&file_handle_), file_path_);
+    delete callback_;
+  }
+
+ private:
+  FileSystemProxy::CreateTemporaryCallback* callback_;
+  base::PlatformFile file_handle_;
+  FilePath file_path_;
+};
+
+class RelayWithStatusCallback : public ChromeThreadRelay {
+ public:
+  explicit RelayWithStatusCallback(FileSystemProxy::StatusCallback* callback)
+      : callback_(callback),
+        succeeded_(false) {
+    // It is OK for callback to be NULL.
+  }
+
+ protected:
+  virtual void RunCallback() {
+    // The caller may not have been interested in the result.
+    if (callback_) {
+      callback_->Run(succeeded_);
+      delete callback_;
+    }
+  }
+
+  void SetStatus(bool succeeded) { succeeded_ = succeeded; }
+
+ private:
+  FileSystemProxy::StatusCallback* callback_;
+  bool succeeded_;
+};
+
+class RelayClose : public RelayWithStatusCallback {
+ public:
+  RelayClose(base::PlatformFile file_handle,
+             FileSystemProxy::StatusCallback* callback)
+      : RelayWithStatusCallback(callback),
+        file_handle_(file_handle) {
+  }
+
+ protected:
+  virtual void RunWork() {
+    SetStatus(base::ClosePlatformFile(file_handle_));
+  }
+
+ private:
+  base::PlatformFile file_handle_;
+};
+
+class RelayDelete : public RelayWithStatusCallback {
+ public:
+  RelayDelete(const FilePath& file_path,
+              bool recursive,
+              FileSystemProxy::StatusCallback* callback)
+      : RelayWithStatusCallback(callback),
+        file_path_(file_path),
+        recursive_(recursive) {
+  }
+
+ protected:
+  virtual void RunWork() {
+    SetStatus(file_util::Delete(file_path_, recursive_));
+  }
+
+ private:
+  FilePath file_path_;
+  bool recursive_;
+};
+
+void Start(const tracked_objects::Location& from_here,
+           scoped_refptr<ChromeThreadRelay> relay) {
+  relay->Start(ChromeThread::FILE, from_here);
+}
+
+}  // namespace
+
+void FileSystemProxy::CreateOrOpen(const FilePath& file_path, int file_flags,
+                                   CreateOrOpenCallback* callback) {
+  Start(FROM_HERE, new RelayCreateOrOpen(file_path, file_flags, callback));
+}
+
+void FileSystemProxy::CreateTemporary(CreateTemporaryCallback* callback) {
+  Start(FROM_HERE, new RelayCreateTemporary(callback));
+}
+
+void FileSystemProxy::Close(base::PlatformFile file_handle,
+                            StatusCallback* callback) {
+  Start(FROM_HERE, new RelayClose(file_handle, callback));
+}
+
+void FileSystemProxy::Delete(const FilePath& file_path,
+                             StatusCallback* callback) {
+  Start(FROM_HERE, new RelayDelete(file_path, false, callback));
+}
+
+void FileSystemProxy::RecursiveDelete(const FilePath& file_path,
+                                      StatusCallback* callback) {
+  Start(FROM_HERE, new RelayDelete(file_path, true, callback));
+}