test_file_system_backend.cc revision 5d1f7b1de12d16ceb2c938c56701a3e8bfa558f7 
1// Copyright 2013 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#include "content/public/test/test_file_system_backend.h"
6
7#include <set>
8#include <string>
9#include <vector>
10
11#include "base/file_util.h"
12#include "base/sequenced_task_runner.h"
13#include "webkit/browser/blob/file_stream_reader.h"
14#include "webkit/browser/fileapi/copy_or_move_file_validator.h"
15#include "webkit/browser/fileapi/file_observers.h"
16#include "webkit/browser/fileapi/file_system_operation.h"
17#include "webkit/browser/fileapi/file_system_operation_context.h"
18#include "webkit/browser/fileapi/file_system_quota_util.h"
19#include "webkit/browser/fileapi/local_file_util.h"
20#include "webkit/browser/fileapi/native_file_util.h"
21#include "webkit/browser/fileapi/quota/quota_reservation.h"
22#include "webkit/browser/fileapi/sandbox_file_stream_writer.h"
23#include "webkit/browser/quota/quota_manager.h"
24#include "webkit/common/fileapi/file_system_util.h"
25
26using fileapi::FileSystemContext;
27using fileapi::FileSystemOperation;
28using fileapi::FileSystemOperationContext;
29using fileapi::FileSystemType;
30using fileapi::FileSystemURL;
31
32namespace content {
33
34namespace {
35
36class TestFileUtil : public fileapi::LocalFileUtil {
37 public:
38  explicit TestFileUtil(const base::FilePath& base_path)
39      : base_path_(base_path) {}
40  virtual ~TestFileUtil() {}
41
42  // LocalFileUtil overrides.
43  virtual base::File::Error GetLocalFilePath(
44      FileSystemOperationContext* context,
45      const FileSystemURL& file_system_url,
46      base::FilePath* local_file_path) OVERRIDE {
47    *local_file_path = base_path_.Append(file_system_url.path());
48    return base::File::FILE_OK;
49  }
50
51 private:
52  base::FilePath base_path_;
53};
54
55}  // namespace
56
57// This only supports single origin.
58class TestFileSystemBackend::QuotaUtil
59    : public fileapi::FileSystemQuotaUtil,
60      public fileapi::FileUpdateObserver {
61 public:
62  explicit QuotaUtil(base::SequencedTaskRunner* task_runner)
63      : usage_(0),
64        task_runner_(task_runner) {
65    update_observers_ = update_observers_.AddObserver(this, task_runner_.get());
66  }
67  virtual ~QuotaUtil() {}
68
69  // FileSystemQuotaUtil overrides.
70  virtual base::File::Error DeleteOriginDataOnFileTaskRunner(
71      FileSystemContext* context,
72      quota::QuotaManagerProxy* proxy,
73      const GURL& origin_url,
74      FileSystemType type) OVERRIDE {
75    NOTREACHED();
76    return base::File::FILE_OK;
77  }
78
79  virtual scoped_refptr<fileapi::QuotaReservation>
80      CreateQuotaReservationOnFileTaskRunner(
81          const GURL& origin_url,
82          FileSystemType type) OVERRIDE {
83    NOTREACHED();
84    return scoped_refptr<fileapi::QuotaReservation>();
85  }
86
87  virtual void GetOriginsForTypeOnFileTaskRunner(
88      FileSystemType type,
89      std::set<GURL>* origins) OVERRIDE {
90    NOTREACHED();
91  }
92
93  virtual void GetOriginsForHostOnFileTaskRunner(
94      FileSystemType type,
95      const std::string& host,
96      std::set<GURL>* origins) OVERRIDE {
97    NOTREACHED();
98  }
99
100  virtual int64 GetOriginUsageOnFileTaskRunner(
101      FileSystemContext* context,
102      const GURL& origin_url,
103      FileSystemType type) OVERRIDE {
104    return usage_;
105  }
106
107  virtual void AddFileUpdateObserver(
108      FileSystemType type,
109      FileUpdateObserver* observer,
110      base::SequencedTaskRunner* task_runner) OVERRIDE {
111    NOTIMPLEMENTED();
112  }
113
114  virtual void AddFileChangeObserver(
115      FileSystemType type,
116      fileapi::FileChangeObserver* observer,
117      base::SequencedTaskRunner* task_runner) OVERRIDE {
118    change_observers_ = change_observers_.AddObserver(observer, task_runner);
119  }
120
121  virtual void AddFileAccessObserver(
122      FileSystemType type,
123      fileapi::FileAccessObserver* observer,
124      base::SequencedTaskRunner* task_runner) OVERRIDE {
125    NOTIMPLEMENTED();
126  }
127
128  virtual const fileapi::UpdateObserverList* GetUpdateObservers(
129      FileSystemType type) const OVERRIDE {
130    return &update_observers_;
131  }
132
133  virtual const fileapi::ChangeObserverList* GetChangeObservers(
134      FileSystemType type) const OVERRIDE {
135    return &change_observers_;
136  }
137
138  virtual const fileapi::AccessObserverList* GetAccessObservers(
139      FileSystemType type) const OVERRIDE {
140    NOTIMPLEMENTED();
141    return NULL;
142  }
143
144  // FileUpdateObserver overrides.
145  virtual void OnStartUpdate(const FileSystemURL& url) OVERRIDE {}
146  virtual void OnUpdate(const FileSystemURL& url, int64 delta) OVERRIDE {
147    usage_ += delta;
148  }
149  virtual void OnEndUpdate(const FileSystemURL& url) OVERRIDE {}
150
151  base::SequencedTaskRunner* task_runner() { return task_runner_.get(); }
152
153 private:
154  int64 usage_;
155
156  scoped_refptr<base::SequencedTaskRunner> task_runner_;
157
158  fileapi::UpdateObserverList update_observers_;
159  fileapi::ChangeObserverList change_observers_;
160};
161
162TestFileSystemBackend::TestFileSystemBackend(
163    base::SequencedTaskRunner* task_runner,
164    const base::FilePath& base_path)
165    : base_path_(base_path),
166      file_util_(
167          new fileapi::AsyncFileUtilAdapter(new TestFileUtil(base_path))),
168      quota_util_(new QuotaUtil(task_runner)),
169      require_copy_or_move_validator_(false) {
170}
171
172TestFileSystemBackend::~TestFileSystemBackend() {
173}
174
175bool TestFileSystemBackend::CanHandleType(FileSystemType type) const {
176  return (type == fileapi::kFileSystemTypeTest);
177}
178
179void TestFileSystemBackend::Initialize(FileSystemContext* context) {
180}
181
182void TestFileSystemBackend::OpenFileSystem(
183    const GURL& origin_url,
184    FileSystemType type,
185    fileapi::OpenFileSystemMode mode,
186    const OpenFileSystemCallback& callback) {
187  callback.Run(GetFileSystemRootURI(origin_url, type),
188               GetFileSystemName(origin_url, type),
189               base::File::FILE_OK);
190}
191
192fileapi::AsyncFileUtil* TestFileSystemBackend::GetAsyncFileUtil(
193    FileSystemType type) {
194  return file_util_.get();
195}
196
197fileapi::CopyOrMoveFileValidatorFactory*
198TestFileSystemBackend::GetCopyOrMoveFileValidatorFactory(
199    FileSystemType type, base::File::Error* error_code) {
200  DCHECK(error_code);
201  *error_code = base::File::FILE_OK;
202  if (require_copy_or_move_validator_) {
203    if (!copy_or_move_file_validator_factory_)
204      *error_code = base::File::FILE_ERROR_SECURITY;
205    return copy_or_move_file_validator_factory_.get();
206  }
207  return NULL;
208}
209
210void TestFileSystemBackend::InitializeCopyOrMoveFileValidatorFactory(
211    scoped_ptr<fileapi::CopyOrMoveFileValidatorFactory> factory) {
212  if (!copy_or_move_file_validator_factory_)
213    copy_or_move_file_validator_factory_ = factory.Pass();
214}
215
216FileSystemOperation* TestFileSystemBackend::CreateFileSystemOperation(
217    const FileSystemURL& url,
218    FileSystemContext* context,
219    base::File::Error* error_code) const {
220  scoped_ptr<FileSystemOperationContext> operation_context(
221      new FileSystemOperationContext(context));
222  operation_context->set_update_observers(*GetUpdateObservers(url.type()));
223  operation_context->set_change_observers(
224      *quota_util_->GetChangeObservers(url.type()));
225  return FileSystemOperation::Create(url, context, operation_context.Pass());
226}
227
228scoped_ptr<webkit_blob::FileStreamReader>
229TestFileSystemBackend::CreateFileStreamReader(
230    const FileSystemURL& url,
231    int64 offset,
232    const base::Time& expected_modification_time,
233    FileSystemContext* context) const {
234  return scoped_ptr<webkit_blob::FileStreamReader>(
235      webkit_blob::FileStreamReader::CreateForFileSystemFile(
236          context, url, offset, expected_modification_time));
237}
238
239scoped_ptr<fileapi::FileStreamWriter>
240TestFileSystemBackend::CreateFileStreamWriter(
241    const FileSystemURL& url,
242    int64 offset,
243    FileSystemContext* context) const {
244  return scoped_ptr<fileapi::FileStreamWriter>(
245      new fileapi::SandboxFileStreamWriter(context, url, offset,
246                                           *GetUpdateObservers(url.type())));
247}
248
249fileapi::FileSystemQuotaUtil* TestFileSystemBackend::GetQuotaUtil() {
250  return quota_util_.get();
251}
252
253const fileapi::UpdateObserverList* TestFileSystemBackend::GetUpdateObservers(
254    FileSystemType type) const {
255  return quota_util_->GetUpdateObservers(type);
256}
257
258void TestFileSystemBackend::AddFileChangeObserver(
259    fileapi::FileChangeObserver* observer) {
260  quota_util_->AddFileChangeObserver(
261      fileapi::kFileSystemTypeTest, observer, quota_util_->task_runner());
262}
263
264}  // namespace content
265