********** WebCore blob hacking

WebCore/platform/network/FormData.cpp

 /*
  * Copyright (C) 2004, 2006, 2008, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Google Inc. All rights reserved.
  * Copyright (C) 2012 Digia Plc. and/or its subsidiary(-ies)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB. If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "config.h"
 
 #include "FormData.h"
 
-#include "BlobData.h"
-#include "BlobRegistryImpl.h"
-#include "BlobURL.h"
 #include "Chrome.h"
 #include "ChromeClient.h"
 #include "Document.h"
 #include "File.h"
 #include "FileSystem.h"
 #include "FormDataBuilder.h"
 #include "FormDataList.h"
 #include "MIMETypeRegistry.h"
 #include "Page.h"
 #include "PlatformMemoryInstrumentation.h"
 #include "TextEncoding.h"
 #include <wtf/Decoder.h>
 #include <wtf/Encoder.h>
 #include <wtf/MemoryInstrumentationVector.h>
 
+#if PLATFORM(CHROMIUM)
+// Chromium doesn't store blob data in renderer processes.
+#else
+#include "BlobRegistryImpl.h"
+#endif
+
 namespace WebCore {
 
 inline FormData::FormData()
     : m_identifier(0)
     , m_hasGeneratedFiles(false)
     , m_alwaysStream(false)
     , m_containsPasswordData(false)
 {
 }
 
@@ skipping 86 matching lines @@
             break;
         case FormDataElement::encodedFile:
 #if ENABLE(BLOB)
             formData->m_elements.append(FormDataElement(e.m_filename, e.m_fileStart, e.m_fileLength, e.m_expectedFileModificationTime, e.m_shouldGenerateFile));
 #else
             formData->m_elements.append(FormDataElement(e.m_filename, e.m_shouldGenerateFile));
 #endif
             break;
 #if ENABLE(BLOB)
         case FormDataElement::encodedBlob:
-            formData->m_elements.append(FormDataElement(e.m_url));
+            formData->m_elements.append(FormDataElement(e.m_blobUUID, e.m_optionalBlobDataHandle));
             break;
 #endif
 #if ENABLE(FILE_SYSTEM)
-        case FormDataElement::encodedURL:
-            formData->m_elements.append(FormDataElement(e.m_url, e.m_fileStart, e.m_fileLength, e.m_expectedFileModificationTime));
+        case FormDataElement::encodedFileSystemURL:
+            formData->m_elements.append(FormDataElement(e.m_fileSystemURL, e.m_fileStart, e.m_fileLength, e.m_expectedFileModificationTime));
             break;
 #endif
         }
     }
     return formData.release();
 }
 
 void FormData::appendData(const void* data, size_t size)
 {
     if (m_elements.isEmpty() || m_elements.last().m_type != FormDataElement::data)
@@ skipping 12 matching lines @@
     m_elements.append(FormDataElement(filename, shouldGenerateFile));
 #endif
 }
 
 #if ENABLE(BLOB)
 void FormData::appendFileRange(const String& filename, long long start, long long length, double expectedModificationTime, bool shouldGenerateFile)
 {
     m_elements.append(FormDataElement(filename, start, length, expectedModificationTime, shouldGenerateFile));
 }
 
-void FormData::appendBlob(const KURL& blobURL)
+void FormData::appendBlob(const String& blobUUID, PassRefPtr<BlobDataHandle> optionalBlobDataHandle)
 {
-    m_elements.append(FormDataElement(blobURL));
+    m_elements.append(FormDataElement(blobUUID, optionalBlobDataHandle));
 }
 #endif
 #if ENABLE(FILE_SYSTEM)
 void FormData::appendURL(const KURL& url)
 {
     m_elements.append(FormDataElement(url, 0, BlobDataItem::toEndOfFile, invalidFileTime()));
 }
 
 void FormData::appendURLRange(const KURL& url, long long start, long long length, double expectedModificationTime)
 {
@@ skipping 71 matching lines @@
                     // Do not add the file if the path is empty.
                     if (!file->path().isEmpty())
                         appendFile(file->path(), shouldGenerateFile);
 #if ENABLE(FILE_SYSTEM)
                     if (!file->fileSystemURL().isEmpty())
                         appendURL(file->fileSystemURL());
 #endif
                 }
 #if ENABLE(BLOB)
                 else
-                    appendBlob(value.blob()->url());
+                    appendBlob(value.blob()->uuid(), value.blob()->blobDataHandle());
 #endif
             } else
                 appendData(value.data().data(), value.data().length());
             appendData("\r\n", 2);
         } else {
             // Omit the name "isindex" if it's the first form data element.
             // FIXME: Why is this a good rule? Is this obsolete now?
             if (encodedData.isEmpty() && key.data() == "isindex")
                 FormDataBuilder::encodeStringAsFormData(encodedData, value.data());
             else
@@ skipping 20 matching lines @@
 }
 
 String FormData::flattenToString() const
 {
     Vector<char> bytes;
     flatten(bytes);
     return Latin1Encoding().decode(reinterpret_cast<const char*>(bytes.data()), bytes.size());
 }
 
 #if ENABLE(BLOB)
-static void appendBlobResolved(FormData* formData, const KURL& url)
+#if PLATFORM(CHROMIUM)
+// Chromium doesn't store blob data in renderer processes.
+#else
+static void appendBlobResolved(FormData* formData, const String& blobUUID)
 {
-    RefPtr<BlobStorageData> blobData = static_cast<BlobRegistryImpl&>(blobRegistry()).getBlobDataFromURL(KURL(ParsedURLString, url));
+    RefPtr<BlobStorageData> blobData = static_cast<BlobRegistryImpl&>(blobRegistry()).getBlobDataFromUUID(blobUUID);
     if (!blobData)
         return;
 
     BlobDataItemList::const_iterator it = blobData->items().begin();
     const BlobDataItemList::const_iterator itend = blobData->items().end();
     for (; it != itend; ++it) {
         const BlobDataItem& blobItem = *it;
         if (blobItem.type == BlobDataItem::Data)
             formData->appendData(blobItem.data->data() + static_cast<int>(blobItem.offset), static_cast<int>(blobItem.length));
         else if (blobItem.type == BlobDataItem::File)
             formData->appendFileRange(blobItem.path, blobItem.offset, blobItem.length, blobItem.expectedModificationTime);
         else if (blobItem.type == BlobDataItem::Blob)
-            appendBlobResolved(formData, blobItem.url);
+            appendBlobResolved(formData, blobItem.blobDataHandle->uuid());
         else
             ASSERT_NOT_REACHED();
     }
 }
 
 PassRefPtr<FormData> FormData::resolveBlobReferences()
 {
     // First check if any blobs needs to be resolved, or we can take the fast path.
     bool hasBlob = false;
     Vector<FormDataElement>::const_iterator it = elements().begin();
@@ skipping 13 matching lines @@
     newFormData->setAlwaysStream(alwaysStream());
     newFormData->setIdentifier(identifier());
     it = elements().begin();
     for (; it != itend; ++it) {
         const FormDataElement& element = *it;
         if (element.m_type == FormDataElement::data)
             newFormData->appendData(element.m_data.data(), element.m_data.size());
         else if (element.m_type == FormDataElement::encodedFile)
             newFormData->appendFileRange(element.m_filename, element.m_fileStart, element.m_fileLength, element.m_expectedFileModificationTime, element.m_shouldGenerateFile);
         else if (element.m_type == FormDataElement::encodedBlob)
-            appendBlobResolved(newFormData.get(), element.m_url);
+            appendBlobResolved(newFormData.get(), element.m_blobUUID);
         else
             ASSERT_NOT_REACHED();
     }
     return newFormData.release();
 }
-#endif
+#endif  // CHROMIUM
+#endif  // BLOB
 
 void FormData::generateFiles(Document* document)
 {
     ASSERT(!m_hasGeneratedFiles);
 
     if (m_hasGeneratedFiles)
         return;
 
     Page* page = document->page();
     if (!page)
@@ skipping 53 matching lines @@
         encoder.encodeDouble(element.m_expectedFileModificationTime);
 #else
         encoder.encodeInt64(0);
         encoder.encodeInt64(0);
         encoder.encodeDouble(invalidFileTime());
 #endif
         return;
 
 #if ENABLE(BLOB)
     case FormDataElement::encodedBlob:
-        encoder.encodeString(element.m_url.string());
+        encoder.encodeString(element.m_blobUUID);
         return;
 #endif
 
 #if ENABLE(FILE_SYSTEM)
-    case FormDataElement::encodedURL:
-        encoder.encodeString(element.m_url.string());
+    case FormDataElement::encodedFileSystemURL:
+        encoder.encodeString(element.m_fileSystemURL.string());
         encoder.encodeInt64(element.m_fileStart);
         encoder.encodeInt64(element.m_fileLength);
         encoder.encodeDouble(element.m_expectedFileModificationTime);
         return;
 #endif
     }
 
     ASSERT_NOT_REACHED();
 }
 
@@ skipping 10 matching lines @@
         if (!decoder.decodeBytes(data))
             return false;
         size_t size = data.size();
         element.m_data.resize(size);
         memcpy(element.m_data.data(), data.data(), size);
         return true;
     }
 
     case FormDataElement::encodedFile:
 #if ENABLE(FILE_SYSTEM)
-    case FormDataElement::encodedURL:
+    case FormDataElement::encodedFileSystemURL:
 #endif
     {
         element.m_type = static_cast<FormDataElement::Type>(type);
         String filenameOrURL;
         if (!decoder.decodeString(filenameOrURL))
             return false;
         if (type == FormDataElement::encodedFile && !decoder.decodeBool(element.m_shouldGenerateFile))
             return false;
         int64_t fileStart;
         if (!decoder.decodeInt64(fileStart))
             return false;
         if (fileStart < 0)
             return false;
         int64_t fileLength;
         if (!decoder.decodeInt64(fileLength))
             return false;
         if (fileLength < fileStart)
             return false;
         double expectedFileModificationTime;
         if (!decoder.decodeDouble(expectedFileModificationTime))
             return false;
 
 #if ENABLE(FILE_SYSTEM)
-        if (type == FormDataElement::encodedURL)
-            element.m_url = KURL(KURL(), filenameOrURL);
+        if (type == FormDataElement::encodedFileSystemURL)
+            element.m_fileSystemURL = KURL(KURL(), filenameOrURL);
         else
 #endif
         element.m_filename = filenameOrURL;
 
 #if ENABLE(BLOB)
         element.m_fileStart = fileStart;
         element.m_fileLength = fileLength;
         element.m_expectedFileModificationTime = expectedFileModificationTime;
 #endif
         return true;
     }
 
 #if ENABLE(BLOB)
     case FormDataElement::encodedBlob:
         element.m_type = FormDataElement::encodedBlob;
-        String blobURLString;
-        if (!decoder.decodeString(blobURLString))
+        String blobUUID;
+        if (!decoder.decodeString(blobUUID))
             return false;
-        element.m_url = KURL(KURL(), blobURLString);
+        element.m_blobUUID = blobUUID;
+        // Note we're not setting the optionalBlobDataHandle here.
         return true;
 #endif
 
     }
 
     return false;
 }
 
 void FormData::encodeForBackForward(Encoder& encoder) const
 {
@@ skipping 38 matching lines @@
     if (!decoder.decodeBool(data->m_hasGeneratedFiles))
         return 0;
 
     if (!decoder.decodeInt64(data->m_identifier))
         return 0;
 
     return data.release();
 }
 
 } // namespace WebCore