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 #include "webkit/browser/fileapi/file_system_quota_client.h"
6
7 #include <algorithm>
8 #include <set>
9
10 #include "base/bind.h"
11 #include "base/file_util.h"
12 #include "base/files/file_path.h"
13 #include "base/location.h"
14 #include "base/logging.h"
15 #include "base/memory/scoped_ptr.h"
16 #include "base/sequenced_task_runner.h"
17 #include "base/single_thread_task_runner.h"
18 #include "base/task_runner_util.h"
19 #include "net/base/net_util.h"
20 #include "url/gurl.h"
21 #include "webkit/browser/fileapi/file_system_context.h"
22 #include "webkit/browser/fileapi/file_system_quota_util.h"
23 #include "webkit/browser/fileapi/file_system_usage_cache.h"
24 #include "webkit/browser/fileapi/sandbox_file_system_backend.h"
25 #include "webkit/common/fileapi/file_system_util.h"
26
27 using quota::StorageType;
28
29 namespace fileapi {
30
31 namespace {
32
GetOriginsForTypeOnFileThread(FileSystemContext * context,StorageType storage_type,std::set<GURL> * origins_ptr)33 void GetOriginsForTypeOnFileThread(
34 FileSystemContext* context,
35 StorageType storage_type,
36 std::set<GURL>* origins_ptr) {
37 FileSystemType type = QuotaStorageTypeToFileSystemType(storage_type);
38 DCHECK(type != kFileSystemTypeUnknown);
39
40 FileSystemQuotaUtil* quota_util = context->GetQuotaUtil(type);
41 if (!quota_util)
42 return;
43 quota_util->GetOriginsForTypeOnFileThread(type, origins_ptr);
44 }
45
GetOriginsForHostOnFileThread(FileSystemContext * context,StorageType storage_type,const std::string & host,std::set<GURL> * origins_ptr)46 void GetOriginsForHostOnFileThread(
47 FileSystemContext* context,
48 StorageType storage_type,
49 const std::string& host,
50 std::set<GURL>* origins_ptr) {
51 FileSystemType type = QuotaStorageTypeToFileSystemType(storage_type);
52 DCHECK(type != kFileSystemTypeUnknown);
53
54 FileSystemQuotaUtil* quota_util = context->GetQuotaUtil(type);
55 if (!quota_util)
56 return;
57 quota_util->GetOriginsForHostOnFileThread(type, host, origins_ptr);
58 }
59
DidGetOrigins(const quota::QuotaClient::GetOriginsCallback & callback,std::set<GURL> * origins_ptr)60 void DidGetOrigins(
61 const quota::QuotaClient::GetOriginsCallback& callback,
62 std::set<GURL>* origins_ptr) {
63 callback.Run(*origins_ptr);
64 }
65
DeleteOriginOnFileThread(FileSystemContext * context,const GURL & origin,FileSystemType type)66 quota::QuotaStatusCode DeleteOriginOnFileThread(
67 FileSystemContext* context,
68 const GURL& origin,
69 FileSystemType type) {
70 FileSystemBackend* provider = context->GetFileSystemBackend(type);
71 if (!provider || !provider->GetQuotaUtil())
72 return quota::kQuotaErrorNotSupported;
73 base::PlatformFileError result =
74 provider->GetQuotaUtil()->DeleteOriginDataOnFileThread(
75 context, context->quota_manager_proxy(), origin, type);
76 if (result == base::PLATFORM_FILE_OK)
77 return quota::kQuotaStatusOk;
78 return quota::kQuotaErrorInvalidModification;
79 }
80
81 } // namespace
82
FileSystemQuotaClient(FileSystemContext * file_system_context,bool is_incognito)83 FileSystemQuotaClient::FileSystemQuotaClient(
84 FileSystemContext* file_system_context,
85 bool is_incognito)
86 : file_system_context_(file_system_context),
87 is_incognito_(is_incognito) {
88 }
89
~FileSystemQuotaClient()90 FileSystemQuotaClient::~FileSystemQuotaClient() {}
91
id() const92 quota::QuotaClient::ID FileSystemQuotaClient::id() const {
93 return quota::QuotaClient::kFileSystem;
94 }
95
OnQuotaManagerDestroyed()96 void FileSystemQuotaClient::OnQuotaManagerDestroyed() {
97 delete this;
98 }
99
GetOriginUsage(const GURL & origin_url,StorageType storage_type,const GetUsageCallback & callback)100 void FileSystemQuotaClient::GetOriginUsage(
101 const GURL& origin_url,
102 StorageType storage_type,
103 const GetUsageCallback& callback) {
104 DCHECK(!callback.is_null());
105
106 if (is_incognito_) {
107 // We don't support FileSystem in incognito mode yet.
108 callback.Run(0);
109 return;
110 }
111
112 FileSystemType type = QuotaStorageTypeToFileSystemType(storage_type);
113 DCHECK(type != kFileSystemTypeUnknown);
114
115 FileSystemQuotaUtil* quota_util = file_system_context_->GetQuotaUtil(type);
116 if (!quota_util) {
117 callback.Run(0);
118 return;
119 }
120
121 base::PostTaskAndReplyWithResult(
122 file_task_runner(),
123 FROM_HERE,
124 // It is safe to pass Unretained(quota_util) since context owns it.
125 base::Bind(&FileSystemQuotaUtil::GetOriginUsageOnFileThread,
126 base::Unretained(quota_util),
127 file_system_context_,
128 origin_url,
129 type),
130 callback);
131 }
132
GetOriginsForType(StorageType storage_type,const GetOriginsCallback & callback)133 void FileSystemQuotaClient::GetOriginsForType(
134 StorageType storage_type,
135 const GetOriginsCallback& callback) {
136 DCHECK(!callback.is_null());
137
138 if (is_incognito_) {
139 // We don't support FileSystem in incognito mode yet.
140 std::set<GURL> origins;
141 callback.Run(origins);
142 return;
143 }
144
145 std::set<GURL>* origins_ptr = new std::set<GURL>();
146 file_task_runner()->PostTaskAndReply(
147 FROM_HERE,
148 base::Bind(&GetOriginsForTypeOnFileThread,
149 file_system_context_,
150 storage_type,
151 base::Unretained(origins_ptr)),
152 base::Bind(&DidGetOrigins,
153 callback,
154 base::Owned(origins_ptr)));
155 }
156
GetOriginsForHost(StorageType storage_type,const std::string & host,const GetOriginsCallback & callback)157 void FileSystemQuotaClient::GetOriginsForHost(
158 StorageType storage_type,
159 const std::string& host,
160 const GetOriginsCallback& callback) {
161 DCHECK(!callback.is_null());
162
163 if (is_incognito_) {
164 // We don't support FileSystem in incognito mode yet.
165 std::set<GURL> origins;
166 callback.Run(origins);
167 return;
168 }
169
170 std::set<GURL>* origins_ptr = new std::set<GURL>();
171 file_task_runner()->PostTaskAndReply(
172 FROM_HERE,
173 base::Bind(&GetOriginsForHostOnFileThread,
174 file_system_context_,
175 storage_type,
176 host,
177 base::Unretained(origins_ptr)),
178 base::Bind(&DidGetOrigins,
179 callback,
180 base::Owned(origins_ptr)));
181 }
182
DeleteOriginData(const GURL & origin,StorageType type,const DeletionCallback & callback)183 void FileSystemQuotaClient::DeleteOriginData(
184 const GURL& origin,
185 StorageType type,
186 const DeletionCallback& callback) {
187 FileSystemType fs_type = QuotaStorageTypeToFileSystemType(type);
188 DCHECK(fs_type != kFileSystemTypeUnknown);
189
190 base::PostTaskAndReplyWithResult(
191 file_task_runner(),
192 FROM_HERE,
193 base::Bind(&DeleteOriginOnFileThread,
194 file_system_context_,
195 origin,
196 fs_type),
197 callback);
198 }
199
DoesSupport(quota::StorageType storage_type) const200 bool FileSystemQuotaClient::DoesSupport(quota::StorageType storage_type) const {
201 FileSystemType type = QuotaStorageTypeToFileSystemType(storage_type);
202 DCHECK(type != kFileSystemTypeUnknown);
203 return file_system_context_->IsSandboxFileSystem(type);
204 }
205
file_task_runner() const206 base::SequencedTaskRunner* FileSystemQuotaClient::file_task_runner() const {
207 return file_system_context_->default_file_task_runner();
208 }
209
210 } // namespace fileapi
211