Chromium Blob hacking

content/browser/loader/upload_data_stream_builder.cc

Index: content/browser/loader/upload_data_stream_builder.cc
diff --git a/content/browser/loader/upload_data_stream_builder.cc b/content/browser/loader/upload_data_stream_builder.cc
index 1a7dfc33e09fe135665686a8ba79b8011778aaef..55d5f8b0f61590d050dcdabe6cee1f9598b11f31 100644
--- a/content/browser/loader/upload_data_stream_builder.cc
+++ b/content/browser/loader/upload_data_stream_builder.cc
@@ -8,12 +8,14 @@
 #include "net/base/upload_bytes_element_reader.h"
 #include "net/base/upload_data_stream.h"
 #include "net/base/upload_file_element_reader.h"
-#include "webkit/browser/blob/blob_storage_controller.h"
+#include "webkit/browser/blob/blob_data_handle.h"
+#include "webkit/browser/blob/blob_storage_context.h"
 #include "webkit/browser/fileapi/upload_file_system_file_element_reader.h"
 #include "webkit/common/resource_request_body.h"
 
 using webkit_blob::BlobData;
-using webkit_blob::BlobStorageController;
+using webkit_blob::BlobDataHandle;
+using webkit_blob::BlobStorageContext;
 using webkit_glue::ResourceRequestBody;
 
 namespace content {
@@ -64,49 +66,50 @@ class FileElementReader : public net::UploadFileElementReader {
 
 void ResolveBlobReference(
     ResourceRequestBody* body,
-    webkit_blob::BlobStorageController* blob_controller,
-    const GURL& blob_url,
+    webkit_blob::BlobStorageContext* blob_context,
+    const ResourceRequestBody::Element& element,
     std::vector<const ResourceRequestBody::Element*>* resolved_elements) {
-  DCHECK(blob_controller);
-  BlobData* blob_data = blob_controller->GetBlobDataFromUrl(blob_url);
-  DCHECK(blob_data);
-  if (!blob_data)
+  DCHECK(blob_context);
+  std::string uuid = element.blob_uuid();
+  if (uuid.empty())
+    uuid = blob_context->LookupUuidFromDeprecatedURL(element.blob_url());
+  scoped_ptr<webkit_blob::BlobDataHandle> handle =
+      blob_context->GetBlobDataFromUUID(uuid);
+  DCHECK(handle);
+  if (!handle)
     return;
 
   // If there is no element in the referred blob data, just return.
-  if (blob_data->items().empty())
+  if (handle->data()->items().empty())
     return;
 
-  // Ensure the blob and any attached shareable files survive until
-  // upload completion.
-  body->SetUserData(blob_data, new base::UserDataAdapter<BlobData>(blob_data));
-
   // Append the elements in the referred blob data.

[ericu, 2013/08/21 23:26:09]

s/referred/referenced/ ?

[michaeln, 2013/08/27 23:24:06]

Done.

[ericu, 2013/08/28 22:01:28]

Nope.

[michaeln, 2013/08/28 22:54:47]

done, really now :?)

-  for (size_t i = 0; i < blob_data->items().size(); ++i) {
-    const BlobData::Item& item = blob_data->items().at(i);
+  for (size_t i = 0; i < handle->data()->items().size(); ++i) {
+    const BlobData::Item& item = handle->data()->items().at(i);
     DCHECK_NE(BlobData::Item::TYPE_BLOB, item.type());
     resolved_elements->push_back(&item);
   }
+
+  // Ensure the blob and any attached shareable files survive until
+  // upload completion.
+  body->SetUserData(handle.get(), handle.release());

[ericu, 2013/08/21 23:26:09]

handle.release() could be called before handle.get() here; C++ explicitly
disavows any guarantee on parameter evaluation order.
Also, do we really want to use the handle as both key and value?
Where does it get cleaned up?

[michaeln, 2013/08/27 23:24:06]

Yikes, thnx, changed things to not be dependent on param eval order.

The |body| owns this handle now. It will get cleaned up when body is deleted.
Multiple handles can be attached to the body in this way, using the ptr value as
the key ensures there are no collisions.

[ericu, 2013/08/28 22:01:28]

OK, so it's not going to be looked up by key later, just via an iterator?  If
so, that seems fine.

 }
 
 }  // namespace
 
 scoped_ptr<net::UploadDataStream> UploadDataStreamBuilder::Build(
     ResourceRequestBody* body,
-    BlobStorageController* blob_controller,
+    BlobStorageContext* blob_context,
     fileapi::FileSystemContext* file_system_context,
     base::TaskRunner* file_task_runner) {
   // Resolve all blob elements.
   std::vector<const ResourceRequestBody::Element*> resolved_elements;
   for (size_t i = 0; i < body->elements()->size(); ++i) {
     const ResourceRequestBody::Element& element = (*body->elements())[i];
-    if (element.type() == ResourceRequestBody::Element::TYPE_BLOB) {
-      ResolveBlobReference(body, blob_controller, element.url(),
-                           &resolved_elements);
-    } else {
-      // No need to resolve, just append the element.
+    if (element.type() == ResourceRequestBody::Element::TYPE_BLOB)
+      ResolveBlobReference(body, blob_context, element, &resolved_elements);
+    else
       resolved_elements.push_back(&element);
-    }
   }
 
   ScopedVector<net::UploadElementReader> element_readers;
@@ -124,7 +127,7 @@ scoped_ptr<net::UploadDataStream> UploadDataStreamBuilder::Build(
         element_readers.push_back(
             new fileapi::UploadFileSystemFileElementReader(
                 file_system_context,
-                element.url(),
+                element.filesystem_url(),
                 element.offset(),
                 element.length(),
                 element.expected_modification_time()));