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