Chromium Blob hacking

webkit/browser/blob/blob_storage_context.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "webkit/browser/blob/blob_storage_context.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop_proxy.h"
@@ skipping 76 matching lines @@
            data->items().begin();
        iter != data->items().end(); ++iter) {
     AppendBlobDataItem(data->uuid(), *iter);
   }
   FinishBuildingBlob(data->uuid(), data->content_type());
   scoped_ptr<BlobDataHandle> handle = GetBlobDataFromUUID(data->uuid());
   DecrementBlobRefCount(data->uuid());
   return handle.Pass();
 }
 
+std::string BlobStorageContext::LookupUuidFromDeprecatedURL(
+    const GURL& url) {
+  BlobURLMap::const_iterator found = deprecated_blob_urls_.find(url);
+  if (found == deprecated_blob_urls_.end())
+    return std::string();
+  return found->second;
+}
+
 void BlobStorageContext::StartBuildingBlob(const std::string& uuid) {
   DCHECK(!IsInUse(uuid) && !uuid.empty());
   blob_map_[uuid] = BlobMapEntry(1, BEING_BUILT, new BlobData(uuid));
 }
 
 void BlobStorageContext::AppendBlobDataItem(
     const std::string& uuid, const BlobData::Item& item) {
   DCHECK(IsBeingBuilt(uuid));
   BlobMap::iterator found = blob_map_.find(uuid);
   if (found == blob_map_.end())
@@ skipping 32 matching lines @@
                      item.expected_modification_time());
       break;
     case BlobData::Item::TYPE_FILE_FILESYSTEM:
       AppendFileSystemFileItem(target_blob_data,
                                item.filesystem_url(),
                                item.offset(),
                                item.length(),
                                item.expected_modification_time());
       break;
     case BlobData::Item::TYPE_BLOB: {
-      scoped_ptr<BlobDataHandle> src = GetBlobDataFromUUID(item.blob_uuid());
+      scoped_ptr<BlobDataHandle> src = GetBlobDataFromUUID(
+          item.blob_uuid().empty()
+          ? LookupUuidFromDeprecatedURL(item.blob_url())
+          : item.blob_uuid());
       if (src)
         exceeded_memory = !ExpandStorageItems(target_blob_data,
                                               src->data(),
                                               item.offset(),
                                               item.length());
       break;
     }
     default:
       NOTREACHED();
       break;
@@ skipping 55 matching lines @@
 }
 
 void BlobStorageContext::RevokePublicBlobURL(const GURL& blob_url) {
   DCHECK(!BlobUrlHasRef(blob_url));
   if (!IsUrlRegistered(blob_url))
     return;
   DecrementBlobRefCount(public_blob_urls_[blob_url]);
   public_blob_urls_.erase(blob_url);
 }
 
+void BlobStorageContext::DeprecatedRegisterPrivateBlobURL(
+    const GURL& url, const std::string& uuid) {
+  if (!IsInUse(uuid))
+    return;
+  IncrementBlobRefCount(uuid);
+  deprecated_blob_urls_[url] = uuid;
+}
+
+void BlobStorageContext::DeprecatedRevokePrivateBlobURL(const GURL& url) {
+  if (deprecated_blob_urls_.find(url) == deprecated_blob_urls_.end())
+    return;
+  DecrementBlobRefCount(deprecated_blob_urls_[url]);
+  deprecated_blob_urls_.erase(url);
+}
+
 bool BlobStorageContext::ExpandStorageItems(
     BlobData* target_blob_data, BlobData* src_blob_data,
     uint64 offset, uint64 length) {
   DCHECK(target_blob_data && src_blob_data &&
          length != static_cast<uint64>(-1));
 
   std::vector<BlobData::Item>::const_iterator iter =
       src_blob_data->items().begin();
   if (offset) {
     for (; iter != src_blob_data->items().end(); ++iter) {
@@ skipping 78 matching lines @@
   if (found == blob_map_.end())
     return false;
   return found->second.flags & BEING_BUILT;
 }
 
 bool BlobStorageContext::IsUrlRegistered(const GURL& blob_url) {
   return public_blob_urls_.find(blob_url) != public_blob_urls_.end();
 }
 
 }  // namespace webkit_blob