Add ScopedFile class which supports scope-out deletion and/or callbacks

webkit/blob/scoped_file.h

+// 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.
+
+#ifndef WEBKIT_BLOB_SCOPED_FILE_H_
+#define WEBKIT_BLOB_SCOPED_FILE_H_
+
+#include <map>
+
+#include "base/callback_forward.h"
+#include "base/files/file_path.h"
+#include "base/memory/ref_counted.h"
+#include "base/move.h"
+#include "webkit/storage/webkit_storage_export.h"
+
+namespace base {
+class TaskRunner;
+}
+
+namespace webkit_blob {
+
+// A scoped reference for a FilePath that can optionally schedule the file
+// to be deleted and/or to notify a consumer when it is going to be scoped out.
+// This class supports move semantics, i.e. consumers can call Pass() to
+// pass the ownership of ScopedFile.
+//
+// TODO(kinuko): Probably this can be moved under base or somewhere more
+// common place.
+class WEBKIT_STORAGE_EXPORT ScopedFile {
+  MOVE_ONLY_TYPE_FOR_CPP_03(ScopedFile, RValue)

[michaeln, 2013/04/22 21:07:03]

geeezz... macro voodoo, i'll have to dig up what the heck this really means?

[kinuko, 2013/04/23 06:31:29]

It's to support move only semantics, the macro automatically defines Pass()
(like scoped_ptr). I've added some descriptive comments.

+
+ public:
+  typedef base::Callback<void(const base::FilePath&)> ScopeOutCallback;
+  typedef std::pair<ScopeOutCallback, scoped_refptr<base::TaskRunner> >
+      ScopeOutCallbackPair;
+  typedef std::vector<ScopeOutCallbackPair> ScopeOutCallbackList;
+
+  enum ScopeOutPolicy {
+    DELETE_ON_SCOPE_OUT,
+    DONT_DELETE_ON_SCOPE_OUT,
+  };
+
+  ScopedFile();
+
+  // |file_task_runner| is used to schedule a file deletion if |policy|
+  // is DELETE_ON_SCOPE_OUT.
+  ScopedFile(const base::FilePath& path,
+             ScopeOutPolicy policy,
+             base::TaskRunner* file_task_runner);
+
+  ScopedFile(RValue other);
+  ScopedFile& operator=(RValue rhs) {
+    Swap(*rhs.object);

[michaeln, 2013/04/22 21:07:03]

assignment mutates the rhs, is that right? and is that common with 'moveonly'
semantics?

[kinuko, 2013/04/23 06:31:29]

Yes. I've added comments about that.

+    return *this;
+  }
+
+  ~ScopedFile();
+
+  // The |callback| is fired on |callback_runner| when the final reference
+  // of this instance is released.
+  // If release policy is DELETE_ON_SCOPE_OUT the
+  // callback(s) is/are called before the deletion is scheduled.
+  void AddScopeOutCallback(const ScopeOutCallback& callback,
+                           base::TaskRunner* callback_runner);
+
+  // The full file path.
+  const base::FilePath& path() const { return path_; }
+
+  bool empty() const { return path_.empty(); }
+
+  // Releases the file. After this operation, this operation will hold
+  // an empty file path and scoping out won't make any file deletion
+  // or callback dispatch. (If an owned pointer is attached to the callback
+  // the pointer will be deleted when the callback is reset.)
+  base::FilePath Release();
+
+  void Swap(ScopedFile& other);
+
+ private:
+  void ScopeOut();
+
+  base::FilePath path_;
+  ScopeOutPolicy scope_out_policy_;
+  scoped_refptr<base::TaskRunner> file_task_runner_;
+  ScopeOutCallbackList scope_out_callbacks_;
+};
+
+}  // namespace webkit_blob
+
+#endif  // WEBKIT_BLOB_SCOPED_FILE_H_