Break large blobs into multiple ipcs during creation.

content/common/webkit_param_traits.cc

 // Copyright (c) 2011 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.
 
 // NOTE: New trait definitions that will be used by Chrome Frame must be placed
 // in common_param_traits2.cc.
 
 #include "content/common/webkit_param_traits.h"
 
 #include "base/string_number_conversions.h"
@@ skipping 132 matching lines @@
     const param_type& p, std::string* l) {
   l->append("(");
   if (p) {
     LogParam(p->request_headers, l);
     l->append(", ");
     LogParam(p->response_headers, l);
   }
   l->append(")");
 }
 
-// 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<NPVariant_Param>::Write(Message* m, const param_type& p) {
   WriteParam(m, static_cast<int>(p.type));
   if (p.type == NPVARIANT_PARAM_BOOL) {
     WriteParam(m, p.bool_value);
   } else if (p.type == NPVARIANT_PARAM_INT) {
     WriteParam(m, p.int_value);
   } else if (p.type == NPVARIANT_PARAM_DOUBLE) {
     WriteParam(m, p.double_value);
   } else if (p.type == NPVARIANT_PARAM_STRING) {
     WriteParam(m, p.string_value);
@@ skipping 111 matching lines @@
       ReadParam(m, iter, &p->ssl_valid) &&
       ReadParam(m, iter, &p->preferred) &&
       ReadParam(m, iter, &p->blacklisted_by_user);
 }
 void ParamTraits<webkit_glue::PasswordForm>::Log(const param_type& p,
                                                  std::string* l) {
   l->append("<PasswordForm>");
 }
 
 }  // namespace IPC