Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(459)

Side by Side Diff: webkit/blob/blob_storage_context.cc

Issue 15746017: Move webkit/blob to new locations. (Closed) Base URL: svn://chrome-svn/chrome/trunk/src/
Patch Set: Created 7 years, 6 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
« no previous file with comments | « webkit/blob/blob_storage_context.h ('k') | webkit/blob/blob_storage_context_unittest.cc » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
1 // Copyright (c) 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 "webkit/blob/blob_storage_context.h"
6
7 #include "base/bind.h"
8 #include "base/location.h"
9 #include "base/logging.h"
10 #include "base/message_loop_proxy.h"
11 #include "googleurl/src/gurl.h"
12 #include "webkit/blob/blob_data.h"
13 #include "webkit/blob/blob_data_handle.h"
14
15 namespace webkit_blob {
16
17 namespace {
18
19 // We can't use GURL directly for these hash fragment manipulations
20 // since it doesn't have specific knowlege of the BlobURL format. GURL
21 // treats BlobURLs as if they were PathURLs which don't support hash
22 // fragments.
23
24 bool BlobUrlHasRef(const GURL& url) {
25 return url.spec().find('#') != std::string::npos;
26 }
27
28 GURL ClearBlobUrlRef(const GURL& url) {
29 size_t hash_pos = url.spec().find('#');
30 if (hash_pos == std::string::npos)
31 return url;
32 return GURL(url.spec().substr(0, hash_pos));
33 }
34
35 // TODO(michaeln): use base::SysInfo::AmountOfPhysicalMemoryMB() in some
36 // way to come up with a better limit.
37 static const int64 kMaxMemoryUsage = 500 * 1024 * 1024; // Half a gig.
38
39 } // namespace
40
41 BlobStorageContext::BlobMapEntry::BlobMapEntry()
42 : refcount(0), flags(0) {
43 }
44
45 BlobStorageContext::BlobMapEntry::BlobMapEntry(
46 int refcount, int flags, BlobData* data)
47 : refcount(refcount), flags(flags), data(data) {
48 }
49
50 BlobStorageContext::BlobMapEntry::~BlobMapEntry() {
51 }
52
53 BlobStorageContext::BlobStorageContext()
54 : memory_usage_(0) {
55 }
56
57 BlobStorageContext::~BlobStorageContext() {
58 }
59
60 scoped_ptr<BlobDataHandle> BlobStorageContext::GetBlobDataFromUUID(
61 const std::string& uuid) {
62 scoped_ptr<BlobDataHandle> result;
63 BlobMap::iterator found = blob_map_.find(uuid);
64 if (found == blob_map_.end())
65 return result.Pass();
66 if (found->second.flags & EXCEEDED_MEMORY)
67 return result.Pass();
68 DCHECK(!(found->second.flags & BEING_BUILT));
69 result.reset(new BlobDataHandle(found->second.data, this,
70 base::MessageLoopProxy::current()));
71 return result.Pass();
72 }
73
74 scoped_ptr<BlobDataHandle> BlobStorageContext::GetBlobDataFromPublicURL(
75 const GURL& url) {
76 BlobURLMap::iterator found = public_blob_urls_.find(
77 BlobUrlHasRef(url) ? ClearBlobUrlRef(url) : url);
78 if (found == public_blob_urls_.end())
79 return scoped_ptr<BlobDataHandle>();
80 return GetBlobDataFromUUID(found->second);
81 }
82
83 scoped_ptr<BlobDataHandle> BlobStorageContext::AddFinishedBlob(
84 const BlobData* data) {
85 StartBuildingBlob(data->uuid());
86 for (std::vector<BlobData::Item>::const_iterator iter =
87 data->items().begin();
88 iter != data->items().end(); ++iter) {
89 AppendBlobDataItem(data->uuid(), *iter);
90 }
91 FinishBuildingBlob(data->uuid(), data->content_type());
92 scoped_ptr<BlobDataHandle> handle = GetBlobDataFromUUID(data->uuid());
93 DecrementBlobRefCount(data->uuid());
94 return handle.Pass();
95 }
96
97 void BlobStorageContext::StartBuildingBlob(const std::string& uuid) {
98 DCHECK(!IsInUse(uuid) && !uuid.empty());
99 blob_map_[uuid] = BlobMapEntry(1, BEING_BUILT, new BlobData(uuid));
100 }
101
102 void BlobStorageContext::AppendBlobDataItem(
103 const std::string& uuid, const BlobData::Item& item) {
104 DCHECK(IsBeingBuilt(uuid));
105 BlobMap::iterator found = blob_map_.find(uuid);
106 if (found == blob_map_.end())
107 return;
108 if (found->second.flags & EXCEEDED_MEMORY)
109 return;
110 BlobData* target_blob_data = found->second.data;
111 DCHECK(target_blob_data);
112
113 bool exceeded_memory = false;
114
115 // The blob data is stored in the canonical way which only contains a
116 // list of Data, File, and FileSystem items. Aggregated TYPE_BLOB items
117 // are expanded into the primitive constituent types.
118 // 1) The Data item is denoted by the raw data and length.
119 // 2) The File item is denoted by the file path, the range and the expected
120 // modification time.
121 // 3) The FileSystem File item is denoted by the FileSystem URL, the range
122 // and the expected modification time.
123 // 4) The Blob items are expanded.
124 // TODO(michaeln): Would be nice to avoid copying Data items when expanding.
125
126 DCHECK(item.length() > 0);
127 switch (item.type()) {
128 case BlobData::Item::TYPE_BYTES:
129 DCHECK(!item.offset());
130 exceeded_memory = !AppendBytesItem(target_blob_data,
131 item.bytes(),
132 static_cast<int64>(item.length()));
133 break;
134 case BlobData::Item::TYPE_FILE:
135 AppendFileItem(target_blob_data,
136 item.path(),
137 item.offset(),
138 item.length(),
139 item.expected_modification_time());
140 break;
141 case BlobData::Item::TYPE_FILE_FILESYSTEM:
142 AppendFileSystemFileItem(target_blob_data,
143 item.filesystem_url(),
144 item.offset(),
145 item.length(),
146 item.expected_modification_time());
147 break;
148 case BlobData::Item::TYPE_BLOB: {
149 scoped_ptr<BlobDataHandle> src = GetBlobDataFromUUID(item.blob_uuid());
150 if (src)
151 exceeded_memory = !ExpandStorageItems(target_blob_data,
152 src->data(),
153 item.offset(),
154 item.length());
155 break;
156 }
157 default:
158 NOTREACHED();
159 break;
160 }
161
162 // If we're using too much memory, drop this blob's data.
163 // TODO(michaeln): Blob memory storage does not yet spill over to disk,
164 // as a stop gap, we'll prevent memory usage over a max amount.
165 if (exceeded_memory) {
166 memory_usage_ -= target_blob_data->GetMemoryUsage();
167 found->second.flags |= EXCEEDED_MEMORY;
168 found->second.data = new BlobData(uuid);
169 return;
170 }
171 }
172
173 void BlobStorageContext::FinishBuildingBlob(
174 const std::string& uuid, const std::string& content_type) {
175 DCHECK(IsBeingBuilt(uuid));
176 BlobMap::iterator found = blob_map_.find(uuid);
177 if (found == blob_map_.end())
178 return;
179 found->second.data->set_content_type(content_type);
180 found->second.flags &= ~BEING_BUILT;
181 }
182
183 void BlobStorageContext::CancelBuildingBlob(const std::string& uuid) {
184 DCHECK(IsBeingBuilt(uuid));
185 DecrementBlobRefCount(uuid);
186 }
187
188 void BlobStorageContext::IncrementBlobRefCount(const std::string& uuid) {
189 BlobMap::iterator found = blob_map_.find(uuid);
190 if (found == blob_map_.end()) {
191 DCHECK(false);
192 return;
193 }
194 ++(found->second.refcount);
195 }
196
197 void BlobStorageContext::DecrementBlobRefCount(const std::string& uuid) {
198 BlobMap::iterator found = blob_map_.find(uuid);
199 if (found == blob_map_.end())
200 return;
201 DCHECK_EQ(found->second.data->uuid(), uuid);
202 if (--(found->second.refcount) == 0) {
203 memory_usage_ -= found->second.data->GetMemoryUsage();
204 blob_map_.erase(found);
205 }
206 }
207
208 void BlobStorageContext::RegisterPublicBlobURL(
209 const GURL& blob_url, const std::string& uuid) {
210 DCHECK(!BlobUrlHasRef(blob_url));
211 DCHECK(IsInUse(uuid));
212 DCHECK(!IsUrlRegistered(blob_url));
213 IncrementBlobRefCount(uuid);
214 public_blob_urls_[blob_url] = uuid;
215 }
216
217 void BlobStorageContext::RevokePublicBlobURL(const GURL& blob_url) {
218 DCHECK(!BlobUrlHasRef(blob_url));
219 if (!IsUrlRegistered(blob_url))
220 return;
221 DecrementBlobRefCount(public_blob_urls_[blob_url]);
222 public_blob_urls_.erase(blob_url);
223 }
224
225 bool BlobStorageContext::ExpandStorageItems(
226 BlobData* target_blob_data, BlobData* src_blob_data,
227 uint64 offset, uint64 length) {
228 DCHECK(target_blob_data && src_blob_data &&
229 length != static_cast<uint64>(-1));
230
231 std::vector<BlobData::Item>::const_iterator iter =
232 src_blob_data->items().begin();
233 if (offset) {
234 for (; iter != src_blob_data->items().end(); ++iter) {
235 if (offset >= iter->length())
236 offset -= iter->length();
237 else
238 break;
239 }
240 }
241
242 for (; iter != src_blob_data->items().end() && length > 0; ++iter) {
243 uint64 current_length = iter->length() - offset;
244 uint64 new_length = current_length > length ? length : current_length;
245 if (iter->type() == BlobData::Item::TYPE_BYTES) {
246 if (!AppendBytesItem(
247 target_blob_data,
248 iter->bytes() + static_cast<size_t>(iter->offset() + offset),
249 static_cast<int64>(new_length))) {
250 return false; // exceeded memory
251 }
252 } else if (iter->type() == BlobData::Item::TYPE_FILE) {
253 AppendFileItem(target_blob_data,
254 iter->path(),
255 iter->offset() + offset,
256 new_length,
257 iter->expected_modification_time());
258 } else {
259 DCHECK(iter->type() == BlobData::Item::TYPE_FILE_FILESYSTEM);
260 AppendFileSystemFileItem(target_blob_data,
261 iter->filesystem_url(),
262 iter->offset() + offset,
263 new_length,
264 iter->expected_modification_time());
265 }
266 length -= new_length;
267 offset = 0;
268 }
269 return true;
270 }
271
272 bool BlobStorageContext::AppendBytesItem(
273 BlobData* target_blob_data, const char* bytes, int64 length) {
274 if (length < 0) {
275 DCHECK(false);
276 return false;
277 }
278 if (memory_usage_ + length > kMaxMemoryUsage)
279 return false;
280 target_blob_data->AppendData(bytes, static_cast<size_t>(length));
281 memory_usage_ += length;
282 return true;
283 }
284
285 void BlobStorageContext::AppendFileItem(
286 BlobData* target_blob_data,
287 const base::FilePath& file_path, uint64 offset, uint64 length,
288 const base::Time& expected_modification_time) {
289 target_blob_data->AppendFile(file_path, offset, length,
290 expected_modification_time);
291
292 // It may be a temporary file that should be deleted when no longer needed.
293 scoped_refptr<ShareableFileReference> shareable_file =
294 ShareableFileReference::Get(file_path);
295 if (shareable_file)
296 target_blob_data->AttachShareableFileReference(shareable_file);
297 }
298
299 void BlobStorageContext::AppendFileSystemFileItem(
300 BlobData* target_blob_data,
301 const GURL& filesystem_url, uint64 offset, uint64 length,
302 const base::Time& expected_modification_time) {
303 target_blob_data->AppendFileSystemFile(filesystem_url, offset, length,
304 expected_modification_time);
305 }
306
307 bool BlobStorageContext::IsInUse(const std::string& uuid) {
308 return blob_map_.find(uuid) != blob_map_.end();
309 }
310
311 bool BlobStorageContext::IsBeingBuilt(const std::string& uuid) {
312 BlobMap::iterator found = blob_map_.find(uuid);
313 if (found == blob_map_.end())
314 return false;
315 return found->second.flags & BEING_BUILT;
316 }
317
318 bool BlobStorageContext::IsUrlRegistered(const GURL& blob_url) {
319 return public_blob_urls_.find(blob_url) != public_blob_urls_.end();
320 }
321
322 } // namespace webkit_blob
OLDNEW
« no previous file with comments | « webkit/blob/blob_storage_context.h ('k') | webkit/blob/blob_storage_context_unittest.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698