Chrome changes to support cached form submissions....

webkit/glue/glue_serialize.cc

 // Copyright (c) 2006-2008 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 "config.h"
 #include <string>
 
 #include "base/compiler_specific.h"
 
 MSVC_PUSH_WARNING_LEVEL(0);
@@ skipping 27 matching lines @@
   mutable int version;
 };
 
 // TODO(mpcomplete): obsolete versions 1 and 2 after 1/1/2008.
 // 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 UChars, not number of bytes.
 //    This version checks and reads v1 and v2 correctly.
+// 4: Adds support for storing FormData::identifier().
 // Should be const, but unit tests may modify it.
-int kVersion = 3;
+int kVersion = 4;
 
 // 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 14 matching lines @@
 inline void WriteInteger(int data, SerializeObject* obj) {
   obj->pickle.WriteInt(data);
 }
 
 inline int ReadInteger(const SerializeObject* obj) {
   int tmp;
   obj->pickle.ReadInt(&obj->iter, &tmp);
   return tmp;
 }
 
+inline void WriteInteger64(int64 data, SerializeObject* obj) {
+  obj->pickle.WriteInt64(data);
+}
+
+inline int64 ReadInteger64(const SerializeObject* obj) {
+  int64 tmp;

[sky, 2009/03/24 20:34:40]

should you set this to 0, just in case ReadInt64 fails? I guess same comment for
ReadInteger.

[darin (slow to review), 2009/03/24 21:12:15]

Good idea!

+  obj->pickle.ReadInt64(&obj->iter, &tmp);
+  return tmp;
+}
+
 inline void WriteReal(double data, SerializeObject* obj) {
   WriteData(&data, sizeof(double), obj);
 }
 
 inline double ReadReal(const SerializeObject* obj) {
   const void* tmp;
   int length;
   ReadData(obj, &tmp, &length);
   return *static_cast<const double*>(tmp);
 }
@@ skipping 23 matching lines @@
       // Version 2 writes <length in UChars><string data>.
       // It uses -1 in the length field to mean String().
       if (data.isNull()) {
         obj->pickle.WriteInt(-1);
       } else {
         obj->pickle.WriteInt(data.length());
         obj->pickle.WriteBytes(data.characters(),
                                data.length() * sizeof(UChar));
       }
       break;
-    case 3:
-      // Version 3 writes <length in bytes><string data>.
+    default:
+      // Version 3+ writes <length in bytes><string data>.
       // It uses -1 in the length field to mean String().
       if (data.isNull()) {
         obj->pickle.WriteInt(-1);
       } else {
         obj->pickle.WriteInt(data.length() * sizeof(UChar));
         obj->pickle.WriteBytes(data.characters(),
                                data.length() * sizeof(UChar));
       }
       break;
-    default:
-      NOTREACHED();
-      break;
   }
 }
 
 // This reads a serialized String from obj. If a string can't be read,
 // String() is returned.
 inline String ReadString(const SerializeObject* obj) {
   int length;
 
   // Versions 1, 2, and 3 all start with an integer.
   if (!obj->pickle.ReadInt(&obj->iter, &length))
@@ skipping 41 matching lines @@
   for (size_t i = 0, c = form_data->elements().size(); i < c; ++i) {
     const FormDataElement& e = form_data->elements().at(i);
     WriteInteger(e.m_type, obj);
 
     if (e.m_type == FormDataElement::data) {
       WriteData(e.m_data.data(), static_cast<int>(e.m_data.size()), obj);
     } else {
       WriteString(e.m_filename, obj);
     }
   }
+  WriteInteger64(form_data->identifier(), obj);
 }
 
 static PassRefPtr<FormData> ReadFormData(const SerializeObject* obj) {
   int num_elements = ReadInteger(obj);
   if (num_elements == 0)
     return NULL;
 
   RefPtr<FormData> form_data = FormData::create();
 
   for (int i = 0; i < num_elements; ++i) {
     int type = ReadInteger(obj);
     if (type == FormDataElement::data) {
       const void* data;
       int length;
       ReadData(obj, &data, &length);
       form_data->appendData(static_cast<const char*>(data), length);
     } else {
       form_data->appendFile(ReadString(obj));
     }
   }
+  if (obj->version >= 4)
+    form_data->setIdentifier(ReadInteger64(obj));
 
   return form_data.release();
 }
 
 // Writes the HistoryItem data into the SerializeObject object for
 // serialization.
 static void WriteHistoryItem(const HistoryItem* item, SerializeObject* obj) {
   // WARNING: This data may be persisted for later use. As such, care must be
   // taken when changing the serialized format. If a new field needs to be
   // written, only adding at the end will make it easier to deal with loading
@@ skipping 25 matching lines @@
   for (size_t i = 0, c = item->children().size(); i < c; ++i)
     WriteHistoryItem(item->children().at(i).get(), obj);
 }
 
 // Creates a new HistoryItem tree based on the serialized string.
 // Assumes the data is in the format returned by WriteHistoryItem.
 static PassRefPtr<HistoryItem> ReadHistoryItem(const SerializeObject* obj) {
   // See note in WriteHistoryItem. on this.
   obj->version = ReadInteger(obj);
 
-  if (obj->version > kVersion)
+  if (obj->version > kVersion || obj->version < 1)
     return NULL;
 
   RefPtr<HistoryItem> item = HistoryItem::create();
 
   item->setURLString(ReadString(obj));
   item->setOriginalURLString(ReadString(obj));
   item->setTarget(ReadString(obj));
   item->setParent(ReadString(obj));
   item->setTitle(ReadString(obj));
   item->setAlternateTitle(ReadString(obj));
@@ skipping 75 matching lines @@
 
 std::string CreateHistoryStateForURL(const GURL& url) {
   // TODO(eseide): We probably should be passing a list visit time other than 0
   RefPtr<HistoryItem> item(HistoryItem::create(GURLToKURL(url), String(), 0));
   std::string data;
   HistoryItemToString(item, &data);
   return data;
 }
 
 }  // namespace webkit_glue