OLD | NEW |
| (Empty) |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #ifndef NET_BASE_DIRECTORY_LISTER_H_ | |
6 #define NET_BASE_DIRECTORY_LISTER_H_ | |
7 | |
8 #include <vector> | |
9 | |
10 #include "base/atomicops.h" | |
11 #include "base/files/file_enumerator.h" | |
12 #include "base/files/file_path.h" | |
13 #include "base/macros.h" | |
14 #include "base/memory/ref_counted.h" | |
15 #include "base/memory/scoped_ptr.h" | |
16 #include "base/message_loop/message_loop_proxy.h" | |
17 #include "net/base/net_export.h" | |
18 | |
19 namespace net { | |
20 | |
21 // This class provides an API for asynchronously listing the contents of a | |
22 // directory on the filesystem. It runs a task on a background thread, and | |
23 // enumerates all files in the specified directory on that thread. Destroying | |
24 // the lister cancels the list operation. The DirectoryLister must only be | |
25 // used on a thread with a MessageLoop. | |
26 class NET_EXPORT DirectoryLister { | |
27 public: | |
28 // Represents one file found. | |
29 struct DirectoryListerData { | |
30 base::FileEnumerator::FileInfo info; | |
31 base::FilePath path; | |
32 }; | |
33 | |
34 // Implement this class to receive directory entries. | |
35 class DirectoryListerDelegate { | |
36 public: | |
37 // Called for each file found by the lister. | |
38 virtual void OnListFile(const DirectoryListerData& data) = 0; | |
39 | |
40 // Called when the listing is complete. | |
41 virtual void OnListDone(int error) = 0; | |
42 | |
43 protected: | |
44 virtual ~DirectoryListerDelegate() {} | |
45 }; | |
46 | |
47 // Sort options | |
48 // ALPHA_DIRS_FIRST is the default sort : | |
49 // directories first in name order, then files by name order | |
50 // FULL_PATH sorts by paths as strings, ignoring files v. directories | |
51 // DATE sorts by last modified date | |
52 // TODO(mmenke): Only NO_SORT and ALPHA_DIRS_FIRST appear to be used in | |
53 // production code, and there's very little testing of some of these | |
54 // options. Remove unused options, improve testing of the others. | |
55 enum SortType { | |
56 NO_SORT, | |
57 DATE, | |
58 ALPHA_DIRS_FIRST, | |
59 FULL_PATH | |
60 }; | |
61 | |
62 DirectoryLister(const base::FilePath& dir, | |
63 DirectoryListerDelegate* delegate); | |
64 | |
65 DirectoryLister(const base::FilePath& dir, | |
66 bool recursive, | |
67 SortType sort, | |
68 DirectoryListerDelegate* delegate); | |
69 | |
70 // Will invoke Cancel(). | |
71 ~DirectoryLister(); | |
72 | |
73 // Call this method to start the directory enumeration thread. | |
74 bool Start(); | |
75 | |
76 // Call this method to asynchronously stop directory enumeration. The | |
77 // delegate will not be called back. | |
78 void Cancel(); | |
79 | |
80 private: | |
81 typedef std::vector<DirectoryListerData> DirectoryList; | |
82 | |
83 // Class responsible for retrieving and sorting the actual directory list on | |
84 // a worker pool thread. Created on the DirectoryLister's thread. As it's | |
85 // refcounted, it's destroyed when the final reference is released, which may | |
86 // happen on either thread. | |
87 // | |
88 // It's kept alive during the calls to Start() and DoneOnOriginThread() by the | |
89 // reference owned by the callback itself. | |
90 class Core : public base::RefCountedThreadSafe<Core> { | |
91 public: | |
92 Core(const base::FilePath& dir, | |
93 bool recursive, | |
94 SortType sort, | |
95 DirectoryLister* lister); | |
96 | |
97 // May only be called on a worker pool thread. | |
98 void Start(); | |
99 | |
100 // Must be called on the origin thread. | |
101 void CancelOnOriginThread(); | |
102 | |
103 private: | |
104 friend class base::RefCountedThreadSafe<Core>; | |
105 class DataEvent; | |
106 | |
107 ~Core(); | |
108 | |
109 // Called on both threads. | |
110 bool IsCancelled() const; | |
111 | |
112 // Called on origin thread. | |
113 void DoneOnOriginThread(scoped_ptr<DirectoryList> directory_list, | |
114 int error) const; | |
115 | |
116 const base::FilePath dir_; | |
117 const bool recursive_; | |
118 const SortType sort_; | |
119 const scoped_refptr<base::MessageLoopProxy> origin_loop_; | |
120 | |
121 // Only used on the origin thread. | |
122 DirectoryLister* lister_; | |
123 | |
124 // Set to 1 on cancellation. Used both to abort listing files early on the | |
125 // worker pool thread for performance reasons and to ensure |lister_| isn't | |
126 // called after cancellation on the origin thread. | |
127 base::subtle::Atomic32 cancelled_; | |
128 | |
129 DISALLOW_COPY_AND_ASSIGN(Core); | |
130 }; | |
131 | |
132 // Call into the corresponding DirectoryListerDelegate. Must not be called | |
133 // after cancellation. | |
134 void OnListFile(const DirectoryListerData& data); | |
135 void OnListDone(int error); | |
136 | |
137 scoped_refptr<Core> core_; | |
138 DirectoryListerDelegate* const delegate_; | |
139 | |
140 DISALLOW_COPY_AND_ASSIGN(DirectoryLister); | |
141 }; | |
142 | |
143 } // namespace net | |
144 | |
145 #endif // NET_BASE_DIRECTORY_LISTER_H_ | |
OLD | NEW |