Store non-standard HTTP headers in history

webkit/glue/glue_serialize.cc

 // Copyright (c) 2006-2009 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/string_util.h"
 #include "googleurl/src/gurl.h"
 #include "webkit/api/public/WebData.h"
 #include "webkit/api/public/WebHistoryItem.h"
 #include "webkit/api/public/WebHTTPBody.h"
+#include "webkit/api/public/WebHTTPHeaderVisitor.h"
 #include "webkit/api/public/WebPoint.h"
 #include "webkit/api/public/WebString.h"
 #include "webkit/api/public/WebVector.h"
 #include "webkit/glue/glue_util.h"
 #include "webkit/glue/webkit_glue.h"
 
 using WebKit::WebData;
 using WebKit::WebHistoryItem;
 using WebKit::WebHTTPBody;
+using WebKit::WebHTTPHeaderVisitor;
 using WebKit::WebPoint;
 using WebKit::WebString;
 using WebKit::WebUChar;
 using WebKit::WebVector;
 
 namespace webkit_glue {
 
 struct SerializeObject {
   SerializeObject() : iter(NULL) {}
   SerializeObject(const char* data, int len) : pickle(data, len), iter(NULL) {}
 
   std::string GetAsString() {
     return std::string(static_cast<const char*>(pickle.data()), pickle.size());
   }
 
   Pickle pickle;
   mutable void* iter;
   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 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 extra HTTP headers.
 // Should be const, but unit tests may modify it.
-int kVersion = 5;
+int kVersion = 6;
 
 // 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 213 matching lines @@
   // compatibility with the format.
   WriteFormData(item.httpBody(), obj);
   WriteString(item.httpContentType(), obj);
   WriteString(item.referrer(), obj);
 
   // Subitems
   const WebVector<WebHistoryItem>& children = item.children();
   WriteInteger(static_cast<int>(children.size()), obj);
   for (size_t i = 0, c = children.size(); i < c; ++i)
     WriteHistoryItem(children[i], obj);
+
+  // Extra HTTP headers.
+  std::map<string16, string16> header_map;
+  class HeaderMapVisitor : public WebHTTPHeaderVisitor {
+  public:
+    HeaderMapVisitor(std::map<string16, string16>* header_map) {
+      map_ = header_map;
+    }
+    virtual void visitHeader(const WebString& name, const WebString& value) {
+      map_->insert(std::make_pair(name, value));
+    }
+  private:
+    std::map<string16, string16>* map_;
+  } header_map_visitor(&header_map);
+  item.visitHTTPHeaderFields(&header_map_visitor);
+  WriteInteger(static_cast<int>(header_map.size()), obj);
+  std::map<string16, string16>::const_iterator it = header_map.begin();
+  for (; it != header_map.end(); ++it) {
+    WriteString(it->first, obj);
+    WriteString(it->second, obj);
+  }
 }
 
 // Creates a new HistoryItem tree based on the serialized string.
 // Assumes the data is in the format returned by WriteHistoryItem.
 static WebHistoryItem ReadHistoryItem(
     const SerializeObject* obj, bool include_form_data) {
   // See note in WriteHistoryItem. on this.
   obj->version = ReadInteger(obj);
 
   if (obj->version > kVersion || obj->version < 1)
@@ skipping 25 matching lines @@
   if (include_form_data) {
     item.setHTTPBody(http_body);
     item.setHTTPContentType(http_content_type);
   }
 
   // Subitems
   int num_children = ReadInteger(obj);
   for (int i = 0; i < num_children; ++i)
     item.appendToChildren(ReadHistoryItem(obj, include_form_data));
 
+  if (obj->version >= 6) {
+    // Extra HTTP headers.
+    int num_extra_headers = ReadInteger(obj);
+    if (num_extra_headers > 0) {
+      WebString name, value;
+      for (int i = 0; i < num_extra_headers; ++i) {
+        name = ReadString(obj);
+        value = ReadString(obj);
+        item.setHTTPHeaderField(name, value);
+      }
+    }
+  }
+
   return item;
 }
 
 // Serialize a HistoryItem to a string, using our JSON Value serializer.
 std::string HistoryItemToString(const WebHistoryItem& item) {
   if (item.isNull())
     return std::string();
 
   SerializeObject obj;
   WriteHistoryItem(item, &obj);
@@ skipping 51 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