| OLD | NEW |
|---|
| (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/browser/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/message_loop_proxy.h" | |
| 11 #include "url/gurl.h" | |
| 12 #include "webkit/browser/blob/blob_data_handle.h" | |
| 13 #include "webkit/common/blob/blob_data.h" | |
| 14 | |
| 15 namespace storage { | |
| 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( | |
| 70 found->second.data.get(), this, base::MessageLoopProxy::current().get())); | |
| 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 bool BlobStorageContext::RegisterPublicBlobURL( | |
| 98 const GURL& blob_url, const std::string& uuid) { | |
| 99 DCHECK(!BlobUrlHasRef(blob_url)); | |
| 100 DCHECK(IsInUse(uuid)); | |
| 101 DCHECK(!IsUrlRegistered(blob_url)); | |
| 102 if (!IsInUse(uuid) || IsUrlRegistered(blob_url)) | |
| 103 return false; | |
| 104 IncrementBlobRefCount(uuid); | |
| 105 public_blob_urls_[blob_url] = uuid; | |
| 106 return true; | |
| 107 } | |
| 108 | |
| 109 void BlobStorageContext::RevokePublicBlobURL(const GURL& blob_url) { | |
| 110 DCHECK(!BlobUrlHasRef(blob_url)); | |
| 111 if (!IsUrlRegistered(blob_url)) | |
| 112 return; | |
| 113 DecrementBlobRefCount(public_blob_urls_[blob_url]); | |
| 114 public_blob_urls_.erase(blob_url); | |
| 115 } | |
| 116 | |
| 117 void BlobStorageContext::StartBuildingBlob(const std::string& uuid) { | |
| 118 DCHECK(!IsInUse(uuid) && !uuid.empty()); | |
| 119 blob_map_[uuid] = BlobMapEntry(1, BEING_BUILT, new BlobData(uuid)); | |
| 120 } | |
| 121 | |
| 122 void BlobStorageContext::AppendBlobDataItem( | |
| 123 const std::string& uuid, const BlobData::Item& item) { | |
| 124 DCHECK(IsBeingBuilt(uuid)); | |
| 125 BlobMap::iterator found = blob_map_.find(uuid); | |
| 126 if (found == blob_map_.end()) | |
| 127 return; | |
| 128 if (found->second.flags & EXCEEDED_MEMORY) | |
| 129 return; | |
| 130 BlobData* target_blob_data = found->second.data.get(); | |
| 131 DCHECK(target_blob_data); | |
| 132 | |
| 133 bool exceeded_memory = false; | |
| 134 | |
| 135 // The blob data is stored in the canonical way which only contains a | |
| 136 // list of Data, File, and FileSystem items. Aggregated TYPE_BLOB items | |
| 137 // are expanded into the primitive constituent types. | |
| 138 // 1) The Data item is denoted by the raw data and length. | |
| 139 // 2) The File item is denoted by the file path, the range and the expected | |
| 140 // modification time. | |
| 141 // 3) The FileSystem File item is denoted by the FileSystem URL, the range | |
| 142 // and the expected modification time. | |
| 143 // 4) The Blob items are expanded. | |
| 144 // TODO(michaeln): Would be nice to avoid copying Data items when expanding. | |
| 145 | |
| 146 DCHECK(item.length() > 0); | |
| 147 switch (item.type()) { | |
| 148 case BlobData::Item::TYPE_BYTES: | |
| 149 DCHECK(!item.offset()); | |
| 150 exceeded_memory = !AppendBytesItem(target_blob_data, | |
| 151 item.bytes(), | |
| 152 static_cast<int64>(item.length())); | |
| 153 break; | |
| 154 case BlobData::Item::TYPE_FILE: | |
| 155 AppendFileItem(target_blob_data, | |
| 156 item.path(), | |
| 157 item.offset(), | |
| 158 item.length(), | |
| 159 item.expected_modification_time()); | |
| 160 break; | |
| 161 case BlobData::Item::TYPE_FILE_FILESYSTEM: | |
| 162 AppendFileSystemFileItem(target_blob_data, | |
| 163 item.filesystem_url(), | |
| 164 item.offset(), | |
| 165 item.length(), | |
| 166 item.expected_modification_time()); | |
| 167 break; | |
| 168 case BlobData::Item::TYPE_BLOB: { | |
| 169 scoped_ptr<BlobDataHandle> src = GetBlobDataFromUUID(item.blob_uuid()); | |
| 170 if (src) | |
| 171 exceeded_memory = !ExpandStorageItems(target_blob_data, | |
| 172 src->data(), | |
| 173 item.offset(), | |
| 174 item.length()); | |
| 175 break; | |
| 176 } | |
| 177 default: | |
| 178 NOTREACHED(); | |
| 179 break; | |
| 180 } | |
| 181 | |
| 182 // If we're using too much memory, drop this blob's data. | |
| 183 // TODO(michaeln): Blob memory storage does not yet spill over to disk, | |
| 184 // as a stop gap, we'll prevent memory usage over a max amount. | |
| 185 if (exceeded_memory) { | |
| 186 memory_usage_ -= target_blob_data->GetMemoryUsage(); | |
| 187 found->second.flags |= EXCEEDED_MEMORY; | |
| 188 found->second.data = new BlobData(uuid); | |
| 189 return; | |
| 190 } | |
| 191 } | |
| 192 | |
| 193 void BlobStorageContext::FinishBuildingBlob( | |
| 194 const std::string& uuid, const std::string& content_type) { | |
| 195 DCHECK(IsBeingBuilt(uuid)); | |
| 196 BlobMap::iterator found = blob_map_.find(uuid); | |
| 197 if (found == blob_map_.end()) | |
| 198 return; | |
| 199 found->second.data->set_content_type(content_type); | |
| 200 found->second.flags &= ~BEING_BUILT; | |
| 201 } | |
| 202 | |
| 203 void BlobStorageContext::CancelBuildingBlob(const std::string& uuid) { | |
| 204 DCHECK(IsBeingBuilt(uuid)); | |
| 205 DecrementBlobRefCount(uuid); | |
| 206 } | |
| 207 | |
| 208 void BlobStorageContext::IncrementBlobRefCount(const std::string& uuid) { | |
| 209 BlobMap::iterator found = blob_map_.find(uuid); | |
| 210 if (found == blob_map_.end()) { | |
| 211 DCHECK(false); | |
| 212 return; | |
| 213 } | |
| 214 ++(found->second.refcount); | |
| 215 } | |
| 216 | |
| 217 void BlobStorageContext::DecrementBlobRefCount(const std::string& uuid) { | |
| 218 BlobMap::iterator found = blob_map_.find(uuid); | |
| 219 if (found == blob_map_.end()) | |
| 220 return; | |
| 221 DCHECK_EQ(found->second.data->uuid(), uuid); | |
| 222 if (--(found->second.refcount) == 0) { | |
| 223 memory_usage_ -= found->second.data->GetMemoryUsage(); | |
| 224 blob_map_.erase(found); | |
| 225 } | |
| 226 } | |
| 227 | |
| 228 bool BlobStorageContext::ExpandStorageItems( | |
| 229 BlobData* target_blob_data, BlobData* src_blob_data, | |
| 230 uint64 offset, uint64 length) { | |
| 231 DCHECK(target_blob_data && src_blob_data && | |
| 232 length != static_cast<uint64>(-1)); | |
| 233 | |
| 234 std::vector<BlobData::Item>::const_iterator iter = | |
| 235 src_blob_data->items().begin(); | |
| 236 if (offset) { | |
| 237 for (; iter != src_blob_data->items().end(); ++iter) { | |
| 238 if (offset >= iter->length()) | |
| 239 offset -= iter->length(); | |
| 240 else | |
| 241 break; | |
| 242 } | |
| 243 } | |
| 244 | |
| 245 for (; iter != src_blob_data->items().end() && length > 0; ++iter) { | |
| 246 uint64 current_length = iter->length() - offset; | |
| 247 uint64 new_length = current_length > length ? length : current_length; | |
| 248 if (iter->type() == BlobData::Item::TYPE_BYTES) { | |
| 249 if (!AppendBytesItem( | |
| 250 target_blob_data, | |
| 251 iter->bytes() + static_cast<size_t>(iter->offset() + offset), | |
| 252 static_cast<int64>(new_length))) { | |
| 253 return false; // exceeded memory | |
| 254 } | |
| 255 } else if (iter->type() == BlobData::Item::TYPE_FILE) { | |
| 256 AppendFileItem(target_blob_data, | |
| 257 iter->path(), | |
| 258 iter->offset() + offset, | |
| 259 new_length, | |
| 260 iter->expected_modification_time()); | |
| 261 } else { | |
| 262 DCHECK(iter->type() == BlobData::Item::TYPE_FILE_FILESYSTEM); | |
| 263 AppendFileSystemFileItem(target_blob_data, | |
| 264 iter->filesystem_url(), | |
| 265 iter->offset() + offset, | |
| 266 new_length, | |
| 267 iter->expected_modification_time()); | |
| 268 } | |
| 269 length -= new_length; | |
| 270 offset = 0; | |
| 271 } | |
| 272 return true; | |
| 273 } | |
| 274 | |
| 275 bool BlobStorageContext::AppendBytesItem( | |
| 276 BlobData* target_blob_data, const char* bytes, int64 length) { | |
| 277 if (length < 0) { | |
| 278 DCHECK(false); | |
| 279 return false; | |
| 280 } | |
| 281 if (memory_usage_ + length > kMaxMemoryUsage) | |
| 282 return false; | |
| 283 target_blob_data->AppendData(bytes, static_cast<size_t>(length)); | |
| 284 memory_usage_ += length; | |
| 285 return true; | |
| 286 } | |
| 287 | |
| 288 void BlobStorageContext::AppendFileItem( | |
| 289 BlobData* target_blob_data, | |
| 290 const base::FilePath& file_path, uint64 offset, uint64 length, | |
| 291 const base::Time& expected_modification_time) { | |
| 292 target_blob_data->AppendFile(file_path, offset, length, | |
| 293 expected_modification_time); | |
| 294 | |
| 295 // It may be a temporary file that should be deleted when no longer needed. | |
| 296 scoped_refptr<ShareableFileReference> shareable_file = | |
| 297 ShareableFileReference::Get(file_path); | |
| 298 if (shareable_file.get()) | |
| 299 target_blob_data->AttachShareableFileReference(shareable_file.get()); | |
| 300 } | |
| 301 | |
| 302 void BlobStorageContext::AppendFileSystemFileItem( | |
| 303 BlobData* target_blob_data, | |
| 304 const GURL& filesystem_url, uint64 offset, uint64 length, | |
| 305 const base::Time& expected_modification_time) { | |
| 306 target_blob_data->AppendFileSystemFile(filesystem_url, offset, length, | |
| 307 expected_modification_time); | |
| 308 } | |
| 309 | |
| 310 bool BlobStorageContext::IsInUse(const std::string& uuid) { | |
| 311 return blob_map_.find(uuid) != blob_map_.end(); | |
| 312 } | |
| 313 | |
| 314 bool BlobStorageContext::IsBeingBuilt(const std::string& uuid) { | |
| 315 BlobMap::iterator found = blob_map_.find(uuid); | |
| 316 if (found == blob_map_.end()) | |
| 317 return false; | |
| 318 return found->second.flags & BEING_BUILT; | |
| 319 } | |
| 320 | |
| 321 bool BlobStorageContext::IsUrlRegistered(const GURL& blob_url) { | |
| 322 return public_blob_urls_.find(blob_url) != public_blob_urls_.end(); | |
| 323 } | |
| 324 | |
| 325 } // namespace storage | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 539143002:
Migrate webkit/browser/ to storage/browser/ (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master