Split net::UploadData into two: for IPC and for upload handling

content/public/common/common_param_traits.cc

Index: content/public/common/common_param_traits.cc
diff --git a/content/public/common/common_param_traits.cc b/content/public/common/common_param_traits.cc
index 656ad68c7607760c088f7aac32376e53fc4ef4be..62ed8044a2eb0c3d93cc9729dd1ce5ec27c1798c 100644
--- a/content/public/common/common_param_traits.cc
+++ b/content/public/common/common_param_traits.cc
@@ -13,6 +13,7 @@
 #include "ui/base/range/range.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/rect_f.h"
+#include "webkit/glue/webupload_data.h"
 
 namespace {
 
@@ -157,17 +158,14 @@ struct ParamTraits<net::UploadData::Element> {
         WriteParam(m, p.is_last_chunk());
         break;
       }
-      case net::UploadData::TYPE_FILE: {
+      default: {
+        DCHECK(p.type() == net::UploadData::TYPE_FILE);
         WriteParam(m, p.file_path());
         WriteParam(m, p.file_range_offset());
         WriteParam(m, p.file_range_length());
         WriteParam(m, p.expected_file_modification_time());
         break;
       }
-      default: {
-        WriteParam(m, p.blob_url());
-        break;
-      }
     }
   }
   static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
@@ -198,7 +196,8 @@ struct ParamTraits<net::UploadData::Element> {
         r->set_is_last_chunk(is_last_chunk);
         break;
       }
-      case net::UploadData::TYPE_FILE: {
+      default: {
+        DCHECK(type == net::UploadData::TYPE_FILE);
         FilePath file_path;
         uint64 offset, length;
         base::Time expected_modification_time;
@@ -214,14 +213,6 @@ struct ParamTraits<net::UploadData::Element> {
                               expected_modification_time);
         break;
       }
-      default: {
-        DCHECK(type == net::UploadData::TYPE_BLOB);
-        GURL blob_url;
-        if (!ReadParam(m, iter, &blob_url))
-          return false;
-        r->SetToBlobUrl(blob_url);
-        break;
-      }
     }
     return true;
   }
@@ -269,6 +260,108 @@ void ParamTraits<scoped_refptr<net::UploadData> >::Log(const param_type& p,
   l->append("<net::UploadData>");
 }
 
+template <>
+struct ParamTraits<WebUploadData::Element> {
+  typedef WebUploadData::Element param_type;
+  static void Write(Message* m, const param_type& p) {
+    WriteParam(m, static_cast<int>(p.type()));
+    switch (p.type()) {
+      case WebUploadData::TYPE_BYTES: {
+        m->WriteData(&p.bytes()[0], static_cast<int>(p.bytes().size()));
+        break;
+      }
+      case WebUploadData::TYPE_FILE: {
+        WriteParam(m, p.file_path());
+        WriteParam(m, p.file_range_offset());
+        WriteParam(m, p.file_range_length());
+        WriteParam(m, p.expected_file_modification_time());
+        break;
+      }
+      default: {
+        WriteParam(m, p.blob_url());
+        break;
+      }
+    }
+  }
+  static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
+    int type;
+    if (!ReadParam(m, iter, &type))
+      return false;
+    switch (type) {
+      case WebUploadData::TYPE_BYTES: {
+        const char* data;
+        int len;
+        if (!m->ReadData(iter, &data, &len))
+          return false;
+        r->SetToBytes(data, len);
+        break;
+      }
+      case WebUploadData::TYPE_FILE: {
+        FilePath file_path;
+        uint64 offset, length;
+        base::Time expected_modification_time;
+        if (!ReadParam(m, iter, &file_path))
+          return false;
+        if (!ReadParam(m, iter, &offset))
+          return false;
+        if (!ReadParam(m, iter, &length))
+          return false;
+        if (!ReadParam(m, iter, &expected_modification_time))
+          return false;
+        r->SetToFilePathRange(file_path, offset, length,
+                              expected_modification_time);
+        break;
+      }
+      default: {
+        DCHECK(type == WebUploadData::TYPE_BLOB);
+        GURL blob_url;
+        if (!ReadParam(m, iter, &blob_url))
+          return false;
+        r->SetToBlobUrl(blob_url);
+        break;
+      }
+    }
+    return true;
+  }
+  static void Log(const param_type& p, std::string* l) {
+    l->append("<WebUploadData::Element>");
+  }
+};
+
+void ParamTraits<scoped_refptr<WebUploadData> >::Write(Message* m,
+                                                       const param_type& p) {
+  WriteParam(m, p.get() != NULL);
+  if (p) {
+    WriteParam(m, *p->elements());
+    WriteParam(m, p->identifier());
+  }
+}
+
+bool ParamTraits<scoped_refptr<WebUploadData> >::Read(const Message* m,
+                                                      PickleIterator* iter,
+                                                      param_type* r) {
+  bool has_object;
+  if (!ReadParam(m, iter, &has_object))
+    return false;
+  if (!has_object)
+    return true;
+  std::vector<WebUploadData::Element> elements;
+  if (!ReadParam(m, iter, &elements))
+    return false;
+  int64 identifier;
+  if (!ReadParam(m, iter, &identifier))
+    return false;
+  *r = new WebUploadData;
+  (*r)->swap_elements(&elements);
+  (*r)->set_identifier(identifier);
+  return true;
+}
+
+void ParamTraits<scoped_refptr<WebUploadData> >::Log(const param_type& p,
+                                                     std::string* l) {
+  l->append("<WebUploadData>");
+}
+
 void ParamTraits<net::HostPortPair>::Write(Message* m, const param_type& p) {
   WriteParam(m, p.host());
   WriteParam(m, p.port());