Support sending BlobData to browser process. Also support sending UploadData...

webkit/glue/glue_serialize.cc

 // Copyright (c) 2010 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/glue/glue_serialize.h"
 
 #include <string>
 
 #include "base/pickle.h"
 #include "base/utf_string_conversions.h"
 #include "googleurl/src/gurl.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebData.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebHistoryItem.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebHTTPBody.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebPoint.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebSerializedScriptValue.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebString.h"
+#include "third_party/WebKit/WebKit/chromium/public/WebURL.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebVector.h"
 #include "webkit/glue/webkit_glue.h"
 
 using WebKit::WebData;
 using WebKit::WebFileInfo;
 using WebKit::WebHistoryItem;
 using WebKit::WebHTTPBody;
 using WebKit::WebPoint;
 using WebKit::WebSerializedScriptValue;
 using WebKit::WebString;
@@ skipping 21 matching lines @@
 // 2: Added case for NULL string versus "". Version 2 code can read Version 1
 //    data, but not vice versa.
 // 3: Version 2 was broken, it stored number of WebUChars, not number of bytes.
 //    This version checks and reads v1 and v2 correctly.
 // 4: Adds support for storing FormData::identifier().
 // 5: Adds support for empty FormData
 // 6: Adds support for documentSequenceNumbers
 // 7: Adds support for stateObject
 // 8: Adds support for file range and modification time
 // 9: Adds support for itemSequenceNumbers
+// 10: Adds support for blob
 // Should be const, but unit tests may modify it.
 //
 // NOTE: If the version is -1, then the pickle contains only a URL string.
 // See CreateHistoryStateForURL.
 //
-int kVersion = 9;
+int kVersion = 10;
 
 // A bunch of convenience functions to read/write to SerializeObjects.
 // The serializers assume the input data is in the correct format and so does
 // no error checking.
 inline void WriteData(const void* data, int length, SerializeObject* obj) {
   obj->pickle.WriteData(static_cast<const char*>(data), length);
 }
 
 inline void ReadData(const SerializeObject* obj, const void** data,
                      int* length) {
@@ skipping 152 matching lines @@
   if (http_body.isNull())
     return;
 
   WriteInteger(static_cast<int>(http_body.elementCount()), obj);
   WebHTTPBody::Element element;
   for (size_t i = 0; http_body.elementAt(i, element); ++i) {
     WriteInteger(element.type, obj);
     if (element.type == WebHTTPBody::Element::TypeData) {
       WriteData(element.data.data(), static_cast<int>(element.data.size()),
                 obj);
-    } else {
+    } else if (element.type == WebHTTPBody::Element::TypeFile) {
       WriteString(element.filePath, obj);
       WriteInteger64(element.fileStart, obj);
       WriteInteger64(element.fileLength, obj);
       WriteReal(element.fileInfo.modificationTime, obj);
+    } else {
+      WriteGURL(element.blobURL, obj);
     }
   }
   WriteInteger64(http_body.identifier(), obj);
 }
 
 static WebHTTPBody ReadFormData(const SerializeObject* obj) {
   // In newer versions, an initial boolean indicates if we have form data.
   if (obj->version >= 5 && !ReadBoolean(obj))
     return WebHTTPBody();
 
   // In older versions, 0 elements implied no form data.
   int num_elements = ReadInteger(obj);
   if (num_elements == 0 && obj->version < 5)
     return WebHTTPBody();
 
   WebHTTPBody http_body;
   http_body.initialize();
 
   for (int i = 0; i < num_elements; ++i) {
     int type = ReadInteger(obj);
     if (type == WebHTTPBody::Element::TypeData) {
       const void* data;
       int length = -1;
       ReadData(obj, &data, &length);
       if (length >= 0)
         http_body.appendData(WebData(static_cast<const char*>(data), length));
-    } else {
+    } else if (type == WebHTTPBody::Element::TypeFile) {
       WebString file_path = ReadString(obj);
       long long file_start = 0;
       long long file_length = -1;
       WebFileInfo file_info;
       if (obj->version >= 8) {
         file_start = ReadInteger64(obj);
         file_length = ReadInteger64(obj);
         file_info.modificationTime = ReadReal(obj);
       }
       http_body.appendFileRange(file_path, file_start, file_length, file_info);
+    } else if (obj->version >= 10) {
+      GURL blob_url = ReadGURL(obj);
+      http_body.appendBlob(blob_url);
     }
   }
   if (obj->version >= 4)
     http_body.setIdentifier(ReadInteger64(obj));
 
   return http_body;
 }
 
 // Writes the HistoryItem data into the SerializeObject object for
 // serialization.
@@ skipping 177 matching lines @@
   const WebHistoryItem& item = HistoryItemFromString(content_state, false);
   if (item.isNull()) {
     // Couldn't parse the string, return an empty string.
     return std::string();
   }
 
   return HistoryItemToString(item);
 }
 
 }  // namespace webkit_glue