| 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/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 | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 15746017:
Move webkit/blob to new locations. (Closed)
Base URL: svn://chrome-svn/chrome/trunk/src/