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

chrome/common/common_param_traits.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 "chrome/common/common_param_traits.h"
 
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/content_settings.h"
 #include "chrome/common/geoposition.h"
 #include "chrome/common/thumbnail_score.h"
 #include "gfx/rect.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/upload_data.h"
 #include "printing/native_metafile.h"
 #include "printing/page_range.h"
 
 #ifndef EXCLUDE_SKIA_DEPENDENCIES
 #include "third_party/skia/include/core/SkBitmap.h"
 #endif
+#include "webkit/blob/blob_data.h"
 #include "webkit/glue/dom_operations.h"
 #include "webkit/glue/password_form.h"
 
 namespace IPC {
 
 #ifndef EXCLUDE_SKIA_DEPENDENCIES
 
 namespace {
 
 struct SkBitmap_Data {
@@ skipping 290 matching lines @@
 // Only the net::UploadData ParamTraits<> definition needs this definition, so
 // keep this in the implementation file so we can forward declare UploadData in
 // the header.
 template <>
 struct ParamTraits<net::UploadData::Element> {
   typedef net::UploadData::Element param_type;
   static void Write(Message* m, const param_type& p) {
     WriteParam(m, static_cast<int>(p.type()));
     if (p.type() == net::UploadData::TYPE_BYTES) {
       m->WriteData(&p.bytes()[0], static_cast<int>(p.bytes().size()));
-    } else {
+    } else if (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());
+    } else {
+      WriteParam(m, p.blob_url());
     }
   }
   static bool Read(const Message* m, void** iter, param_type* r) {
     int type;
     if (!ReadParam(m, iter, &type))
       return false;
     if (type == net::UploadData::TYPE_BYTES) {
       const char* data;
       int len;
       if (!m->ReadData(iter, &data, &len))
         return false;
       r->SetToBytes(data, len);
-    } else {
-      DCHECK(type == net::UploadData::TYPE_FILE);
+    } else if (type == net::UploadData::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);
+    } else {
+      DCHECK(type == net::UploadData::TYPE_BLOB);
+      GURL blob_url;
+      if (!ReadParam(m, iter, &blob_url))
+        return false;
+      r->SetToBlobUrl(blob_url);
     }
     return true;
   }
   static void Log(const param_type& p, std::string* l) {
     l->append("<net::UploadData::Element>");
   }
 };
 
 void ParamTraits<scoped_refptr<net::UploadData> >::Write(Message* m,
                                                          const param_type& p) {
@@ skipping 22 matching lines @@
   (*r)->swap_elements(&elements);
   (*r)->set_identifier(identifier);
   return true;
 }
 
 void ParamTraits<scoped_refptr<net::UploadData> >::Log(const param_type& p,
                                                        std::string* l) {
   l->append("<net::UploadData>");
 }
 
+// Only the webkit_blob::BlobData ParamTraits<> definition needs this
+// definition, so keep this in the implementation file so we can forward declare
+// BlobData in the header.
+template <>
+struct ParamTraits<webkit_blob::BlobData::Item> {
+  typedef webkit_blob::BlobData::Item param_type;
+  static void Write(Message* m, const param_type& p) {
+    WriteParam(m, static_cast<int>(p.type()));
+    if (p.type() == webkit_blob::BlobData::TYPE_DATA) {
+      WriteParam(m, p.data());
+    } else if (p.type() == webkit_blob::BlobData::TYPE_FILE) {
+      WriteParam(m, p.file_path());
+      WriteParam(m, p.offset());
+      WriteParam(m, p.length());
+      WriteParam(m, p.expected_modification_time());
+    } else {
+      WriteParam(m, p.blob_url());
+      WriteParam(m, p.offset());
+      WriteParam(m, p.length());
+    }
+  }
+  static bool Read(const Message* m, void** iter, param_type* r) {
+    int type;
+    if (!ReadParam(m, iter, &type))
+      return false;
+    if (type == webkit_blob::BlobData::TYPE_DATA) {
+      std::string data;
+      if (!ReadParam(m, iter, &data))
+        return false;
+      r->SetToData(data);
+    } else if (type == webkit_blob::BlobData::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->SetToFile(file_path, offset, length, expected_modification_time);
+    } else {
+      DCHECK(type == webkit_blob::BlobData::TYPE_BLOB);
+      GURL blob_url;
+      uint64 offset, length;
+      if (!ReadParam(m, iter, &blob_url))
+        return false;
+      if (!ReadParam(m, iter, &offset))
+        return false;
+      if (!ReadParam(m, iter, &length))
+        return false;
+      r->SetToBlob(blob_url, offset, length);
+    }
+    return true;
+  }
+  static void Log(const param_type& p, std::string* l) {
+    l->append("<BlobData::Item>");
+  }
+};
+
+void ParamTraits<scoped_refptr<webkit_blob::BlobData> >::Write(
+    Message* m, const param_type& p) {
+  WriteParam(m, p.get() != NULL);
+  if (p) {
+    WriteParam(m, p->items());
+    WriteParam(m, p->content_type());
+    WriteParam(m, p->content_disposition());
+  }
+}
+
+bool ParamTraits<scoped_refptr<webkit_blob::BlobData> >::Read(
+    const Message* m, void** iter, param_type* r) {
+  bool has_object;
+  if (!ReadParam(m, iter, &has_object))
+    return false;
+  if (!has_object)
+    return true;
+  std::vector<webkit_blob::BlobData::Item> items;
+  if (!ReadParam(m, iter, &items))
+    return false;
+  std::string content_type;
+  if (!ReadParam(m, iter, &content_type))
+    return false;
+  std::string content_disposition;
+  if (!ReadParam(m, iter, &content_disposition))
+    return false;
+  *r = new webkit_blob::BlobData;
+  (*r)->swap_items(&items);
+  (*r)->set_content_type(content_type);
+  (*r)->set_content_disposition(content_disposition);
+  return true;
+}
+
+void ParamTraits<scoped_refptr<webkit_blob::BlobData> >::Log(
+    const param_type& p, std::string* l) {
+  l->append("<webkit_blob::BlobData>");
+}
+
 void ParamTraits<ThumbnailScore>::Write(Message* m, const param_type& p) {
   IPC::ParamTraits<double>::Write(m, p.boring_score);
   IPC::ParamTraits<bool>::Write(m, p.good_clipping);
   IPC::ParamTraits<bool>::Write(m, p.at_top);
   IPC::ParamTraits<base::Time>::Write(m, p.time_at_snapshot);
 }
 
 bool ParamTraits<ThumbnailScore>::Read(const Message* m, void** iter,
                                        param_type* r) {
   double boring_score;
@@ skipping 159 matching lines @@
          p->Init(&buffer.front(), static_cast<uint32>(buffer.size()));
 #endif  // defined(OS_WIN)
 }
 
 void ParamTraits<printing::NativeMetafile>::Log(
     const param_type& p, std::string* l) {
   l->append("<printing::NativeMetafile>");
 }
 
 }  // namespace IPC