Support sending a sliced file in chromium....

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/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;
 using WebKit::WebUChar;
 using WebKit::WebVector;
 
 namespace webkit_glue {
 
@@ skipping 14 matching lines @@
 // Version ID used in reading/writing history items.
 // 1: Initial revision.
 // 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
 // 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 = 7;
+int kVersion = 8;
 
 // 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 151 matching lines @@
 
   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 {
       WriteString(element.filePath, obj);
+      WriteInteger64(element.fileStart, obj);
+      WriteInteger64(element.fileLength, obj);
+      WriteReal(element.fileInfo.modificationTime, 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 {
-      http_body.appendFile(ReadString(obj));
+      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);
     }
   }
   if (obj->version >= 4)
     http_body.setIdentifier(ReadInteger64(obj));
 
   return http_body;
 }
 
 // Writes the HistoryItem data into the SerializeObject object for
 // serialization.
@@ skipping 173 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